dissolve.patch

dissolve.patch

diff --git a/include/boost/geometry/extensions/algorithms/dissolve.hpp b/include/boost/geometry/extensions/algorithms/dissolve.hpp
index da03c1f..def7877 100644
--- a/include/boost/geometry/extensions/algorithms/dissolve.hpp
+++ b/include/boost/geometry/extensions/algorithms/dissolve.hpp
@@ -65,14 +65,12 @@ class backtrack_for_dissolve
 public :
     typedef detail::overlay::backtrack_state state_type;
 
-    template
-        <
-            typename Operation,
-            typename Rings,
-            typename Turns,
-            typename RobustPolicy,
-            typename Visitor
-        >
+    template <typename Operation,
+              typename Rings,
+              typename Turns,
+              typename IntersectionStrategy,
+              typename RobustPolicy,
+              typename Visitor>
     static inline void apply(std::size_t size_at_start,
                 Rings& rings,
                 typename boost::range_value<Rings>::type& ring,
@@ -80,12 +78,13 @@ public :
                 typename boost::range_value<Turns>::type const& turn,
                 Operation& operation,
                 detail::overlay::traverse_error_type,
-                Geometry const& ,
-                Geometry const& ,
-                RobustPolicy const& ,
-                state_type& state,
-                Visitor const& visitor
-                )
+                             Geometry const& ,
+                             Geometry const& ,
+                             IntersectionStrategy const&,
+                             RobustPolicy const& ,
+                             state_type& state,
+                             Visitor const& visitor
+        )
     {
         state.m_good = false;
 
@@ -146,25 +145,23 @@ struct dissolve_ring_or_polygon
                 OutputIterator out)
     {
         typedef typename point_type<Geometry>::type point_type;
+        typedef typename boost::geometry::strategy::intersection::services::default_strategy<typename boost::geometry::cs_tag<Geometry>::type
+                                                                                             >::type strategy_type;
+
 
         // Get the self-intersection points, including turns
-        typedef detail::overlay::traversal_turn_info
-            <
-                point_type,
-                typename segment_ratio_type<point_type, RescalePolicy>::type
-            > turn_info;
+        using turn_info = detail::overlay::traversal_turn_info<point_type,
+                                                               typename segment_ratio_type<point_type, RescalePolicy>::type>;
 
         std::vector<turn_info> turns;
         detail::dissolve::no_interrupt_policy policy;
-        geometry::self_turns
-            <
-                detail::overlay::assign_null_policy
-            >(geometry, rescale_policy, turns, policy);
+        geometry::self_turns<detail::overlay::assign_null_policy>(geometry, strategy_type(), rescale_policy, turns, policy);
 
         // The dissolve process is not necessary if there are no turns at all
 
         if (boost::size(turns) > 0)
         {
+            std::cerr << "TURNS size=" << turns.size() << std::endl;
             typedef typename ring_type<Geometry>::type ring_type;
             typedef std::vector<ring_type> out_vector;
             out_vector rings;
@@ -184,34 +181,35 @@ struct dissolve_ring_or_polygon
                 typename cs_tag<Geometry>::type
             >::type side_strategy_type;
 
-            enrich_intersection_points<false, false, overlay_dissolve>(turns,
-                        clusters, geometry, geometry, rescale_policy,
-                        side_strategy_type());
+
+            enrich_intersection_points<false, false, overlay_union>(turns,
+                                                                    clusters, geometry, geometry, rescale_policy,
+                                                                    side_strategy_type());
 
             detail::overlay::traverse
                 <
-                    false, false,
+                    false, true,
                     Geometry, Geometry,
-                    overlay_dissolve,
-                    backtrack_for_dissolve<Geometry>
-                >::apply(geometry, geometry, rescale_policy,
-                            turns, rings, clusters, visitor);
+                    overlay_union,
+            backtrack_for_dissolve<Geometry>
+            >::apply(geometry, geometry, strategy_type(), rescale_policy,
+                     turns, rings, clusters, visitor);
 
             clear_visit_info(turns);
 
             // ... and for intersection
             enrich_intersection_points<false, false, overlay_intersection>(turns,
-                        clusters, geometry, geometry, rescale_policy,
-                        side_strategy_type());
+                                                                           clusters, geometry, geometry, rescale_policy,
+                                                                           side_strategy_type());
 
             detail::overlay::traverse
                 <
-                    false, false,
+                    false, true,
                     Geometry, Geometry,
                     overlay_intersection,
                     backtrack_for_dissolve<Geometry>
-                >::apply(geometry, geometry, rescale_policy,
-                            turns, rings, clusters, visitor);
+            >::apply(geometry, geometry, strategy_type(), rescale_policy,
+                     turns, rings, clusters, visitor);
 
             std::map<ring_identifier, detail::overlay::ring_turn_info> map;
             get_ring_turn_info(map, turns);
@@ -219,9 +217,10 @@ struct dissolve_ring_or_polygon
             typedef detail::overlay::ring_properties<typename geometry::point_type<Geometry>::type> properties;
 
             std::map<ring_identifier, properties> selected;
+            std::cerr << "RINGS size=" << rings.size() << std::endl;
+            std::cerr << "MAP size=" << map.size() << std::endl;
 
             detail::overlay::select_rings<overlay_dissolve>(geometry, map, selected);
-
             // Add intersected rings
             {
                 ring_identifier id(2, 0, -1);
@@ -234,7 +233,6 @@ struct dissolve_ring_or_polygon
                     id.multi_index++;
                 }
             }
-
             detail::overlay::assign_parents(geometry, rings, selected, true);
             return detail::overlay::add_rings<GeometryOut>(selected, geometry, rings, out);
 
@@ -332,10 +330,11 @@ inline OutputIterator dissolve_inserter(Geometry const& geometry, OutputIterator
 
 template
 <
-    typename Geometry,
-    typename Collection
+typename Geometry,
+typename Collection,
+typename RescalePolicy
 >
-inline void dissolve(Geometry const& geometry, Collection& output_collection)
+inline void dissolve(Geometry const& geometry, Collection& output_collection, RescalePolicy const& rescale_policy)
 {
     concepts::check<Geometry const>();
 
@@ -349,7 +348,7 @@ inline void dissolve(Geometry const& geometry, Collection& output_collection)
         typename tag<geometry_out>::type,
         Geometry,
         geometry_out
-    >::apply(geometry, detail::no_rescale_policy(), std::back_inserter(output_collection));
+    >::apply(geometry, rescale_policy, std::back_inserter(output_collection));
 }