diff --git a/include/boost/geometry/algorithms/assign.hpp b/include/boost/geometry/algorithms/assign.hpp
index fd23f1ddb..f7b8679f1 100644
--- a/include/boost/geometry/algorithms/assign.hpp
+++ b/include/boost/geometry/algorithms/assign.hpp
@@ -3,6 +3,7 @@
 // Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
 // Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
 // Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Samuel Debionne, Grenoble, France.
 
 // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
 // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
@@ -40,6 +41,8 @@
 
 #include <boost/geometry/util/for_each_coordinate.hpp>
 
+#include <boost/variant/variant_fwd.hpp>
+
 namespace boost { namespace geometry
 {
 
@@ -121,6 +124,137 @@ inline void assign_zero(Geometry& geometry)
         >::apply(geometry);
 }
 
+
+namespace resolve_variant
+{
+
+template <typename Geometry1, typename Geometry2>
+struct assign
+{
+    static inline void
+    apply(
+            Geometry1& geometry1,
+            const Geometry2& geometry2)
+    {
+        concept::check<Geometry1>();
+        concept::check<Geometry2 const>();
+        concept::check_concepts_and_equal_dimensions<Geometry1, Geometry2 const>();
+            
+        bool const same_point_order =
+            point_order<Geometry1>::value == point_order<Geometry2>::value;
+        bool const same_closure =
+            closure<Geometry1>::value == closure<Geometry2>::value;
+            
+        BOOST_MPL_ASSERT_MSG
+        (
+                same_point_order, ASSIGN_IS_NOT_SUPPORTED_FOR_DIFFERENT_POINT_ORDER
+                , (types<Geometry1, Geometry2>)
+        );
+        BOOST_MPL_ASSERT_MSG
+        (
+                same_closure, ASSIGN_IS_NOT_SUPPORTED_FOR_DIFFERENT_CLOSURE
+                , (types<Geometry1, Geometry2>)
+        );
+            
+        dispatch::convert<Geometry2, Geometry1>::apply(geometry2, geometry1);
+    }
+};
+    
+    
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct assign<variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+{
+    struct visitor: static_visitor<void>
+    {
+        Geometry2 const& m_geometry2;
+            
+        visitor(Geometry2 const& geometry2)
+        : m_geometry2(geometry2)
+        {}
+            
+        template <typename Geometry1>
+        result_type operator()(Geometry1& geometry1) const
+        {
+            return assign
+            <
+                Geometry1,
+                Geometry2
+            >::apply
+            (geometry1, m_geometry2);
+        }
+    };
+        
+    static inline void
+    apply(variant<BOOST_VARIANT_ENUM_PARAMS(T)>& geometry1,
+          Geometry2 const& geometry2)
+    {
+        return apply_visitor(visitor(geometry2), geometry1);
+    }
+};
+    
+    
+template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct assign<Geometry1, variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    struct visitor: static_visitor<void>
+    {
+        Geometry1& m_geometry1;
+            
+        visitor(Geometry1 const& geometry1)
+        : m_geometry1(geometry1)
+        {}
+            
+        template <typename Geometry2>
+        result_type operator()(Geometry2 const& geometry2) const
+        {
+            return assign
+            <
+                Geometry1,
+                Geometry2
+            >::apply
+            (m_geometry1, geometry2);
+        }
+    };
+        
+    static inline void
+    apply(Geometry1& geometry1,
+          variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2)
+    {
+        return apply_visitor(visitor(geometry1), geometry2);
+    }
+};
+    
+    
+template <BOOST_VARIANT_ENUM_PARAMS(typename A), BOOST_VARIANT_ENUM_PARAMS(typename B)>
+struct assign<variant<BOOST_VARIANT_ENUM_PARAMS(A)>, variant<BOOST_VARIANT_ENUM_PARAMS(B)> >
+{
+    struct visitor: static_visitor<void>
+    {
+        template <typename Geometry1, typename Geometry2>
+        result_type operator()(
+                                Geometry1& geometry1,
+                                Geometry2 const& geometry2) const
+        {
+            return assign
+            <
+                Geometry1,
+                Geometry2
+            >::apply
+            (geometry1, geometry2);
+        }
+    };
+        
+    static inline void
+    apply(variant<BOOST_VARIANT_ENUM_PARAMS(A)>& geometry1,
+          variant<BOOST_VARIANT_ENUM_PARAMS(B)> const& geometry2)
+    {
+        return apply_visitor(visitor(), geometry1, geometry2);
+    }
+};
+    
+} // namespace resolve_variant
+    
+
 /*!
 \brief Assigns one geometry to another geometry
 \details The assign algorithm assigns one geometry, e.g. a BOX, to another
@@ -142,25 +276,7 @@ geometry, e.g. a RING. This only works if it is possible and applicable.
 template <typename Geometry1, typename Geometry2>
 inline void assign(Geometry1& geometry1, Geometry2 const& geometry2)
 {
-    concept::check_concepts_and_equal_dimensions<Geometry1, Geometry2 const>();
-
-    bool const same_point_order =
-            point_order<Geometry1>::value == point_order<Geometry2>::value;
-    bool const same_closure =
-            closure<Geometry1>::value == closure<Geometry2>::value;
-
-    BOOST_MPL_ASSERT_MSG
-        (
-            same_point_order, ASSIGN_IS_NOT_SUPPORTED_FOR_DIFFERENT_POINT_ORDER
-            , (types<Geometry1, Geometry2>)
-        );
-    BOOST_MPL_ASSERT_MSG
-        (
-            same_closure, ASSIGN_IS_NOT_SUPPORTED_FOR_DIFFERENT_CLOSURE
-            , (types<Geometry1, Geometry2>)
-        );
-
-    dispatch::convert<Geometry2, Geometry1>::apply(geometry2, geometry1);
+    resolve_variant::assign<Geometry1, Geometry2>::apply(geometry1, geometry2);
 }
 
 
diff --git a/test/algorithms/assign.cpp b/test/algorithms/assign.cpp
index a64f4010d..df8901324 100644
--- a/test/algorithms/assign.cpp
+++ b/test/algorithms/assign.cpp
@@ -4,6 +4,7 @@
 // Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
 // Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
 // Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Samuel Debionne, Grenoble, France.
 
 // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
 // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
@@ -189,6 +190,70 @@ void test_assign_conversion()
 }
 
 
+template <typename P>
+void test_assign_conversion_variant()
+{
+    typedef bg::model::box<P> box_type;
+    typedef bg::model::ring<P> ring_type;
+    typedef bg::model::polygon<P> polygon_type;
+
+    P p;
+    bg::assign_values(p, 1, 2);
+
+    box_type b;
+    bg::assign(boost::variant<box_type&>(b), p);
+
+    BOOST_CHECK_CLOSE((bg::get<0, 0>(b)), 1.0, 0.001);
+    BOOST_CHECK_CLOSE((bg::get<0, 1>(b)), 2.0, 0.001);
+    BOOST_CHECK_CLOSE((bg::get<1, 0>(b)), 1.0, 0.001);
+    BOOST_CHECK_CLOSE((bg::get<1, 1>(b)), 2.0, 0.001);
+
+
+    bg::set<bg::min_corner, 0>(b, 1);
+    bg::set<bg::min_corner, 1>(b, 2);
+    bg::set<bg::max_corner, 0>(b, 3);
+    bg::set<bg::max_corner, 1>(b, 4);
+
+    ring_type ring;
+    bg::assign(boost::variant<ring_type&>(ring), boost::variant<box_type>(b));
+
+    {
+        typedef bg::model::ring<P, false, false> ring_type_ccw;
+        ring_type_ccw ring_ccw;
+        // Should NOT compile (currently): bg::assign(ring_ccw, ring);
+
+    }
+
+    typename boost::range_const_iterator<ring_type>::type it = ring.begin();
+    BOOST_CHECK_CLOSE(bg::get<0>(*it), 1.0, 0.001);
+    BOOST_CHECK_CLOSE(bg::get<1>(*it), 2.0, 0.001);
+    it++;
+    BOOST_CHECK_CLOSE(bg::get<0>(*it), 1.0, 0.001);
+    BOOST_CHECK_CLOSE(bg::get<1>(*it), 4.0, 0.001);
+    it++;
+    BOOST_CHECK_CLOSE(bg::get<0>(*it), 3.0, 0.001);
+    BOOST_CHECK_CLOSE(bg::get<1>(*it), 4.0, 0.001);
+    it++;
+    BOOST_CHECK_CLOSE(bg::get<0>(*it), 3.0, 0.001);
+    BOOST_CHECK_CLOSE(bg::get<1>(*it), 2.0, 0.001);
+    it++;
+    BOOST_CHECK_CLOSE(bg::get<0>(*it), 1.0, 0.001);
+    BOOST_CHECK_CLOSE(bg::get<1>(*it), 2.0, 0.001);
+
+    BOOST_CHECK_EQUAL(ring.size(), 5u);
+
+
+    polygon_type polygon;
+
+    bg::assign(boost::variant<polygon_type&>(polygon), boost::variant<ring_type>(ring));
+    BOOST_CHECK_EQUAL(bg::num_points(polygon), 5u);
+
+    ring_type ring2;
+    bg::assign(boost::variant<ring_type&>(ring2), boost::variant<polygon_type>(polygon));
+    BOOST_CHECK_EQUAL(bg::num_points(ring2), 5u);
+}
+
+
 template <typename Point>
 void test_assign_point_2d()
 {
@@ -225,6 +290,7 @@ int test_main(int, char* [])
     test_assign_point_2d<bg::model::point<double, 2, bg::cs::cartesian> >();
 
     test_assign_conversion<bg::model::point<double, 2, bg::cs::cartesian> >();
+    test_assign_conversion_variant<bg::model::point<double, 2, bg::cs::cartesian> >();
 
 
     // Segment (currently) cannot handle array's because derived from std::pair