[turns] without rescaling, include start turns in calculation

Author: barendgehrels

include/boost/geometry/algorithms/detail/buffer/get_piece_turns.hpp

@@ -266,7 +266,7 @@ class piece_turn_visitor
 
                 typedef detail::overlay::get_turn_info
                     <
-                        detail::overlay::assign_null_policy
+                        detail::overlay::assign_policy_only_start_turns
                     > turn_policy;
 
                 turn_policy::apply(unique_sub_range1, unique_sub_range2,

include/boost/geometry/algorithms/detail/disjoint/linear_linear.hpp

@@ -79,6 +79,7 @@ struct assign_disjoint_policy
     static bool const include_no_turn = true;
     static bool const include_degenerate = true;
     static bool const include_opposite = true;
+    static bool const include_start_turn = false;
 };
 
 

include/boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp

@@ -491,8 +491,8 @@ inline void enrich_intersection_points(Turns& turns,
     {
         detail::overlay::discard_closed_turns
             <
-            OverlayType,
-            target_operation
+                OverlayType,
+                target_operation
             >::apply(turns, clusters, geometry1, geometry2,
                      strategy);
         detail::overlay::discard_open_turns

include/boost/geometry/algorithms/detail/overlay/get_turn_info.hpp

@@ -830,6 +830,65 @@ struct equal : public base_turn_handler
     }
 };
 
+template
+<
+    typename TurnInfo
+>
+struct start : public base_turn_handler
+{
+    template
+    <
+        typename UniqueSubRange1,
+        typename UniqueSubRange2,
+        typename IntersectionInfo,
+        typename DirInfo,
+        typename SideCalculator,
+        typename UmbrellaStrategy
+    >
+    static inline bool apply(UniqueSubRange1 const& /*range_p*/,
+                UniqueSubRange2 const& /*range_q*/,
+                TurnInfo& ti,
+                IntersectionInfo const& info,
+                DirInfo const& dir_info,
+                SideCalculator const& side,
+                UmbrellaStrategy const& )
+    {
+#if defined(BOOST_GEOMETRY_USE_RESCALING)
+        // With rescaling, start turns are not needed.
+        return false;
+#endif
+
+        // Start turns have either how_a = -1, or how_b = -1 (either p leaves or q leaves)
+        BOOST_GEOMETRY_ASSERT(dir_info.how_a != dir_info.how_b);
+        BOOST_GEOMETRY_ASSERT(dir_info.how_a == -1 || dir_info.how_b == -1);
+        BOOST_GEOMETRY_ASSERT(dir_info.how_a == 0 || dir_info.how_b == 0);
+
+        if (dir_info.how_b == -1)
+        {
+            // p --------------->
+            //             |
+            //             | q         q leaves
+            //             v
+            //
+
+            int const side_qj_p1 = side.qj_wrt_p1();
+            ui_else_iu(side_qj_p1 == -1, ti);
+        }
+        else if (dir_info.how_a == -1)
+        {
+            // p leaves
+            int const side_pj_q1 = side.pj_wrt_q1();
+            ui_else_iu(side_pj_q1 == 1, ti);
+        }
+
+        // Copy intersection point
+        assign_point(ti, method_start, info, 0);
+        return true;
+    }
+
+};
+
+
 template
 <
     typename TurnInfo,
@@ -1194,6 +1253,15 @@ struct assign_null_policy
     static bool const include_no_turn = false;
     static bool const include_degenerate = false;
     static bool const include_opposite = false;
+    static bool const include_start_turn = false;
+};
+
+struct assign_policy_only_start_turns
+{
+    static bool const include_no_turn = false;
+    static bool const include_degenerate = false;
+    static bool const include_opposite = false;
+    static bool const include_start_turn = true;
 };
 
 /*!
@@ -1257,9 +1325,24 @@ struct get_turn_info
         bool handle_as_equal = method == 'e';
         bool const handle_as_collinear = method == 'c';
         bool const handle_as_degenerate = method == '0';
+        bool const handle_as_start = method == 's';
 
-        // (angle, from, start)
-        bool const do_only_convert = method == 'a' || method == 'f' || method == 's';
+        // (angle, from)
+        bool do_only_convert = method == 'a' || method == 'f';
+
+        if (handle_as_start)
+        {
+            // It is in some cases necessary to handle a start turn
+            if (AssignPolicy::include_start_turn
+                && start<TurnInfo>::apply(range_p, range_q, tp, inters.i_info(), inters.d_info(), inters.sides(), umbrella_strategy))
+            {
+                *out++ = tp;
+            }
+            else
+            {
+              do_only_convert = true;
+            }
+        }
 
         if (handle_as_touch_interior)
         {

include/boost/geometry/algorithms/detail/overlay/handle_colocations.hpp

@@ -507,6 +507,46 @@ inline void discard_interior_exterior_turns(Turns& turns, Clusters& clusters)
     }
 }
 
+template<typename Turns, typename Clusters>
+inline void discard_start_turns(Turns& turns, Clusters& clusters)
+{
+    for (auto& nv : clusters)
+    {
+        cluster_info& cinfo = nv.second;
+        auto& indices = cinfo.turn_indices;
+        std::size_t start_count{0};
+        for (signed_size_type index : indices)
+        {
+            auto const& turn = turns[index];
+            if (turn.method == method_start)
+            {
+               start_count++;
+            }
+        }
+        if (start_count == 0 && start_count == indices.size())
+        {
+            // There are no start turns, or all turns in the cluster are start turns.
+            continue;
+        }
+
+        // Discard the start turns and simultaneously erase them from the indices
+        for (auto it = indices.begin(); it != indices.end();)
+        {
+          auto& turn = turns[*it];
+          if (turn.method == method_start)
+          {
+              turn.discarded = true;
+              turn.cluster_id = -1;
+              it = indices.erase(it);
+          }
+          else
+          {
+              ++it;
+          }
+        }
+    }
+}
+
 template <typename Geometry0, typename Geometry1>
 inline segment_identifier get_preceding_segment_id(segment_identifier const& id,
         Geometry0 const& geometry0, Geometry1 const& geometry1)
@@ -700,6 +740,8 @@ inline bool handle_colocations(Turns& turns, Clusters& clusters,
     // on turns which are discarded afterwards
     set_colocation<OverlayType>(turns, clusters);
 
+    discard_start_turns(turns, clusters);
+
     if (BOOST_GEOMETRY_CONDITION(target_operation == operation_intersection))
     {
         discard_interior_exterior_turns
@@ -783,7 +825,7 @@ inline bool fill_sbs(Sbs& sbs, Point& turn_point,
     {
         signed_size_type turn_index = *sit;
         turn_type const& turn = turns[turn_index];
-        if (first )
+        if (first)
         {
             turn_point = turn.point;
         }

include/boost/geometry/algorithms/detail/overlay/linear_linear.hpp

@@ -138,6 +138,7 @@ class linear_linear_linestring
         static bool const include_no_turn = false;
         static bool const include_degenerate = EnableDegenerateTurns;
         static bool const include_opposite = false;
+        static bool const include_start_turn = false;
     };
 
 

include/boost/geometry/algorithms/detail/overlay/overlay.hpp

@@ -306,7 +306,7 @@ std::cout << "get turns" << std::endl;
         geometry::get_turns
             <
                 Reverse1, Reverse2,
-                detail::overlay::assign_null_policy
+                assign_policy_only_start_turns
             >(geometry1, geometry2, strategy, robust_policy, turns, policy);
 
         visitor.visit_turns(1, turns);
@@ -318,12 +318,12 @@ std::cout << "get turns" << std::endl;
             // and if necessary (e.g.: multi-geometry, polygon with interior rings)
             if (needs_self_turns<Geometry1>::apply(geometry1))
             {
-                self_get_turn_points::self_turns<Reverse1, assign_null_policy>(geometry1,
+                self_get_turn_points::self_turns<Reverse1, assign_policy_only_start_turns>(geometry1,
                     strategy, robust_policy, turns, policy, 0);
             }
             if (needs_self_turns<Geometry2>::apply(geometry2))
             {
-                self_get_turn_points::self_turns<Reverse2, assign_null_policy>(geometry2,
+                self_get_turn_points::self_turns<Reverse2, assign_policy_only_start_turns>(geometry2,
                     strategy, robust_policy, turns, policy, 1);
             }
         }

include/boost/geometry/algorithms/detail/overlay/turn_info.hpp

@@ -34,6 +34,7 @@ enum method_type
     method_touch_interior,
     method_collinear,
     method_equal,
+    method_start,
     method_error
 };
 

include/boost/geometry/algorithms/detail/touches/implementation.hpp

@@ -181,6 +181,7 @@ struct areal_interrupt_policy
                         return true;
                     }
                     break;
+                case overlay::method_start :
                 case overlay::method_none :
                 case overlay::method_disjoint :
                 case overlay::method_error :

test/algorithms/set_operations/check_turn_less.hpp

@@ -55,6 +55,7 @@ struct check_turn_less
         static bool const include_no_turn = false;
         static bool const include_degenerate = EnableDegenerateTurns;
         static bool const include_opposite = false;
+        static bool const include_start_turn = false;
 
         template
         <