refactor: removed unused functionality and minor changes preparing next pr

barendgehrels · barendgehrels · commit 07f419e5011f · 2025-01-01T23:35:33.000+01:00
diff --git a/include/boost/geometry/algorithms/detail/buffer/buffer_policies.hpp b/include/boost/geometry/algorithms/detail/buffer/buffer_policies.hpp
@@ -87,20 +87,6 @@ g_backtrack_warning_count++;
 struct buffer_overlay_visitor
 {
 public :
-    void print(char const* /*header*/)
-    {
-    }
-
-    template <typename Turns>
-    void print(char const* /*header*/, Turns const& /*turns*/, int /*turn_index*/)
-    {
-    }
-
-    template <typename Turns>
-    void print(char const* /*header*/, Turns const& /*turns*/, int /*turn_index*/, int /*op_index*/)
-    {
-    }
-
     template <typename Turns>
     void visit_turns(int , Turns const& ) {}
 
@@ -170,26 +156,6 @@ struct buffer_turn_info
     {}
 };
 
-struct buffer_less
-{
-    template <typename Indexed>
-    inline bool operator()(Indexed const& left, Indexed const& right) const
-    {
-        if (! (left.subject->seg_id == right.subject->seg_id))
-        {
-            return left.subject->seg_id < right.subject->seg_id;
-        }
-
-        // Both left and right are located on the SAME segment.
-        if (! (left.subject->fraction == right.subject->fraction))
-        {
-            return left.subject->fraction < right.subject->fraction;
-        }
-
-        return left.turn_index < right.turn_index;
-    }
-};
-
 template <typename Strategy>
 struct piece_get_box
 {
diff --git a/include/boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp b/include/boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp
@@ -104,8 +104,7 @@ inline void enrich_sort(Operations& operations,
 
 // Assign travel-to-vertex/ip index for each turn.
 template <typename Operations, typename Turns>
-inline void enrich_assign(Operations& operations, Turns& turns,
-                          bool check_consecutive_turns)
+inline void enrich_assign(Operations& operations, Turns& turns)
 {
     for (auto const& item : util::enumerate(operations))
     {
@@ -131,34 +130,6 @@ inline void enrich_assign(Operations& operations, Turns& turns,
             return next_turn.operations[operations[next_index].operation_index];
         };
 
-        if (check_consecutive_turns
-            && indexed.turn_index == operations[next_index].turn_index
-            && op.seg_id == next_operation().seg_id)
-        {
-            // If the two operations on the same turn are ordered consecutively,
-            // and they are on the same segment, then the turn where to travel to should
-            // be considered one further. Therefore next is increased.
-            //
-            // It often happens in buffer, in these configurations:
-            // +---->--+
-            // |       |
-            // |   +->-*---->
-            // |   |   |
-            // ^   +-<-+
-            // If the next index is not corrected, the small rectangle
-            // will be kept in the output.
-
-            // This is a normal situation and occurs, for example, in every concave bend.
-            // In general it should always travel from turn to next turn.
-            // Only in some circumstances traveling to the same turn is necessary, for example
-            // if there is only one turn in the outer ring.
-            //
-            // (For dissolve this is not done, turn_index is often
-            // the same for two consecutive operations - but the conditions are changed
-            // and this should be verified again)
-            next_index = advance(next_index);
-        }
-
         // Cluster behaviour: next should point after cluster, unless
         // their seg_ids are not the same
         // (For dissolve, this is still to be examined - TODO)
@@ -285,36 +256,50 @@ struct enriched_map_default_include_policy
 // Add all (non discarded) operations on this ring
 // Blocked operations or uu on clusters (for intersection)
 // should be included, to block potential paths in clusters
-template <typename Turns, typename MappedVector, typename IncludePolicy>
-inline void create_map(Turns const& turns, MappedVector& mapped_vector,
-                       IncludePolicy const& include_policy)
+template <typename Turns, typename IncludePolicy>
+inline auto create_map(Turns const& turns, IncludePolicy const& include_policy)
 {
+    using turn_type = typename boost::range_value<Turns>::type;
+    using indexed_turn_operation = detail::overlay::indexed_turn_operation
+        <
+            typename turn_type::turn_operation_type
+        >;
+
+    std::map
+    <
+        ring_identifier,
+        std::vector<indexed_turn_operation>
+    > mapped_vector;
+
     for (auto const& turn_item : util::enumerate(turns))
     {
         auto const& index = turn_item.index;
         auto const& turn = turn_item.value;
-        if (! turn.discarded)
+        if (turn.discarded)
         {
-            for (auto const& op_item : util::enumerate(turn.operations))
+            continue;
+        }
+
+        for (auto const& op_item : util::enumerate(turn.operations))
+        {
+            auto const& op_index = op_item.index;
+            auto const& op = op_item.value;
+            if (include_policy.include(op.operation))
             {
-                auto const& op_index = op_item.index;
-                auto const& op = op_item.value;
-                if (include_policy.include(op.operation))
-                {
-                    ring_identifier const ring_id
-                        (
-                            op.seg_id.source_index,
-                            op.seg_id.multi_index,
-                            op.seg_id.ring_index
-                        );
-                    mapped_vector[ring_id].emplace_back
-                        (
-                            index, op_index, op, turn.operations[1 - op_index].seg_id
-                        );
-                }
+                ring_identifier const ring_id
+                    (
+                        op.seg_id.source_index,
+                        op.seg_id.multi_index,
+                        op.seg_id.ring_index
+                    );
+                mapped_vector[ring_id].emplace_back
+                    (
+                        index, op_index, op, turn.operations[1 - op_index].seg_id
+                    );
             }
         }
     }
+    return mapped_vector;
 }
 
 template <typename Point1, typename Point2>
@@ -356,7 +341,6 @@ inline void calculate_remaining_distance(Turns& turns)
     }
 }
 
-
 }} // namespace detail::overlay
 #endif //DOXYGEN_NO_DETAIL
 
@@ -398,51 +382,14 @@ inline void enrich_intersection_points(Turns& turns,
             ? detail::overlay::operation_intersection
             : detail::overlay::operation_union;
     constexpr bool is_dissolve = OverlayType == overlay_dissolve;
-    constexpr bool is_buffer = OverlayType == overlay_buffer;
-
-    using turn_type = typename boost::range_value<Turns>::type;
-    using indexed_turn_operation = detail::overlay::indexed_turn_operation
-        <
-            typename turn_type::turn_operation_type
-        > ;
-
-    using mapped_vector_type = std::map
-        <
-            ring_identifier,
-            std::vector<indexed_turn_operation>
-        >;
 
     // Turns are often used by index (in clusters, next_index, etc)
     // and turns may therefore NOT be DELETED - they may only be flagged as discarded
 
-    bool has_cc = false;
-    bool has_colocations = false;
-
-    if BOOST_GEOMETRY_CONSTEXPR (! is_buffer)
-    {
-        // Handle colocations, gathering clusters and (below) their properties.
-        has_colocations = detail::overlay::handle_colocations
-                    <
-                        Reverse1, Reverse2, OverlayType, Geometry1, Geometry2
-                    >(turns, clusters);
-        // Gather cluster properties (using even clusters with
-        // discarded turns - for open turns)
-        detail::overlay::gather_cluster_properties
-            <
-                Reverse1,
-                Reverse2,
-                OverlayType
-            >(clusters, turns, target_operation,
-            geometry1, geometry2, strategy);
-    }
-    else
-    {
-        // For buffer, this was already done before calling enrich_intersection_points.
-        has_colocations = ! clusters.empty();
-    }
-
     discard_duplicate_turns(turns, geometry1, geometry2);
 
+    bool has_cc = false;
+
     // Discard turns not part of target overlay
     for (auto& turn : turns)
     {
@@ -491,11 +438,15 @@ inline void enrich_intersection_points(Turns& turns,
                      strategy);
     }
 
+    if (! clusters.empty())
+    {
+        detail::overlay::cleanup_clusters(turns, clusters);
+        detail::overlay::colocate_clusters(clusters, turns);
+    }
+
     // Create a map of vectors of indexed operation-types to be able
     // to sort intersection points PER RING
-    mapped_vector_type mapped_vector;
-
-    detail::overlay::create_map(turns, mapped_vector,
+    auto mapped_vector = detail::overlay::create_map(turns,
                                 detail::overlay::enriched_map_default_include_policy());
 
     for (auto& pair : mapped_vector)
@@ -506,14 +457,6 @@ inline void enrich_intersection_points(Turns& turns,
                     strategy);
     }
 
-    if (has_colocations)
-    {
-        detail::overlay::cleanup_clusters(turns, clusters);
-        detail::overlay::colocate_clusters(clusters, turns);
-    }
-
-    // After cleaning up clusters assign the next turns
-
     for (auto& pair : mapped_vector)
     {
 #ifdef BOOST_GEOMETRY_DEBUG_ENRICH
@@ -524,7 +467,7 @@ inline void enrich_intersection_points(Turns& turns,
             detail::overlay::enrich_adapt(pair.second, turns);
         }
 
-        detail::overlay::enrich_assign(pair.second, turns, ! is_dissolve);
+        detail::overlay::enrich_assign(pair.second, turns);
     }
 
     if (has_cc)
diff --git a/include/boost/geometry/algorithms/detail/overlay/handle_colocations.hpp b/include/boost/geometry/algorithms/detail/overlay/handle_colocations.hpp
@@ -364,23 +364,6 @@ inline bool handle_colocations(Turns& turns, Clusters& clusters)
     return true;
 }
 
-
-struct is_turn_index
-{
-    is_turn_index(signed_size_type index)
-        : m_index(index)
-    {}
-
-    template <typename Indexed>
-    inline bool operator()(Indexed const& indexed) const
-    {
-        // Indexed is a indexed_turn_operation<Operation>
-        return indexed.turn_index == m_index;
-    }
-
-    signed_size_type m_index;
-};
-
 template
 <
     typename Sbs,
diff --git a/include/boost/geometry/algorithms/detail/overlay/less_by_segment_ratio.hpp b/include/boost/geometry/algorithms/detail/overlay/less_by_segment_ratio.hpp
@@ -43,7 +43,6 @@ struct indexed_turn_operation
 
     std::size_t turn_index;
     std::size_t operation_index;
-    bool skip;
     // use pointers to avoid copies, const& is not possible because of usage in vector
     segment_identifier const* other_seg_id; // segment id of other segment of intersection of two segments
     TurnOperation const* subject;
@@ -53,7 +52,6 @@ struct indexed_turn_operation
                 segment_identifier const& oid)
         : turn_index(ti)
         , operation_index(oi)
-        , skip(false)
         , other_seg_id(&oid)
         , subject(boost::addressof(sub))
     {}
diff --git a/include/boost/geometry/algorithms/detail/overlay/overlay.hpp b/include/boost/geometry/algorithms/detail/overlay/overlay.hpp
@@ -60,14 +60,6 @@ namespace detail { namespace overlay
 //! Default visitor for overlay, doing nothing
 struct overlay_null_visitor
 {
-    void print(char const* ) {}
-
-    template <typename Turns>
-    void print(char const* , Turns const& , int) {}
-
-    template <typename Turns>
-    void print(char const* , Turns const& , int , int ) {}
-
     template <typename Turns>
     void visit_turns(int , Turns const& ) {}
 
@@ -271,6 +263,8 @@ struct overlay
                 cluster_info
             >;
 
+        constexpr operation_type target_operation = operation_from_overlay<OverlayType>::value;
+
         turn_container_type turns;
 
         detail::get_turns::no_interrupt_policy policy;
@@ -303,6 +297,21 @@ struct overlay
         cluster_type clusters;
         std::map<ring_identifier, ring_turn_info> turn_info_per_ring;
 
+        // Handle colocations, gathering clusters and (below) their properties.
+        detail::overlay::handle_colocations
+                    <
+                        Reverse1, Reverse2, OverlayType, Geometry1, Geometry2
+                    >(turns, clusters);
+
+        // Gather cluster properties (using even clusters with
+        // discarded turns - for open turns)
+        detail::overlay::gather_cluster_properties
+            <
+                Reverse1,
+                Reverse2,
+                OverlayType
+            >(clusters, turns, target_operation, geometry1, geometry2, strategy);
+
         geometry::enrich_intersection_points<Reverse1, Reverse2, OverlayType>(
             turns, clusters, geometry1, geometry2, strategy);
 
diff --git a/include/boost/geometry/extensions/algorithms/dissolve.hpp b/include/boost/geometry/extensions/algorithms/dissolve.hpp
@@ -173,6 +173,8 @@ struct dissolve_ring
                 typename segment_ratio_type<point_type, RescalePolicy>::type
             >;
 
+        constexpr operation_type target_operation = operation_from_overlay<OverlayType>::value;
+
         std::deque<turn_info> turns;
         detail::dissolve::no_interrupt_policy policy;
         detail::self_get_turn_points::self_turns
@@ -198,6 +200,21 @@ struct dissolve_ring
         std::map<signed_size_type, detail::overlay::cluster_info> clusters;
 
         // Enrich/traverse the polygons
+        // Handle colocations, gathering clusters and (below) their properties.
+        detail::overlay::handle_colocations
+                    <
+                        Reverse1, Reverse2, OverlayType, Geometry1, Geometry2
+                    >(turns, clusters);
+
+        // Gather cluster properties (using even clusters with
+        // discarded turns - for open turns)
+        detail::overlay::gather_cluster_properties
+            <
+                Reverse1,
+                Reverse2,
+                OverlayType
+            >(clusters, turns, target_operation, geometry1, geometry2, strategy);
+
         enrich_intersection_points<Reverse, Reverse, overlay_dissolve>(turns,
                     clusters, input_ring, input_ring, rescale_policy,
                     strategy);
diff --git a/test/algorithms/overlay/sort_by_side.cpp b/test/algorithms/overlay/sort_by_side.cpp
@@ -159,6 +159,12 @@ std::vector<std::size_t> apply_overlay(
 
     cluster_type clusters;
 
+    // Handle colocations, gathering clusters and (below) their properties.
+    bg::detail::overlay::handle_colocations
+                <
+                    Reverse1, Reverse2, OverlayType, Geometry1, Geometry2
+                >(turns, clusters);
+
     bg::enrich_intersection_points<Reverse1, Reverse2, OverlayType>(turns,
             clusters, geometry1, geometry2, strategy);
 
diff --git a/test/robustness/overlay/buffer/recursive_polygons_buffer.cpp b/test/robustness/overlay/buffer/recursive_polygons_buffer.cpp
