[turns] without rescaling, include start turns in calculation

barendgehrels · barendgehrels · commit 3e111a0302f1 · 2020-10-28T14:27:26.000+01:00
diff --git a/include/boost/geometry/algorithms/detail/buffer/get_piece_turns.hpp b/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,
diff --git a/include/boost/geometry/algorithms/detail/disjoint/linear_linear.hpp b/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;
 };
 
 
diff --git a/include/boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp b/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
diff --git a/include/boost/geometry/algorithms/detail/overlay/get_turn_info.hpp b/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)
         {
diff --git a/include/boost/geometry/algorithms/detail/overlay/handle_colocations.hpp b/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;
         }
diff --git a/include/boost/geometry/algorithms/detail/overlay/linear_linear.hpp b/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;
     };
 
 
diff --git a/include/boost/geometry/algorithms/detail/overlay/overlay.hpp b/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);
             }
         }
diff --git a/include/boost/geometry/algorithms/detail/overlay/turn_info.hpp b/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
 };
 
diff --git a/include/boost/geometry/algorithms/detail/touches/implementation.hpp b/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 :
diff --git a/test/algorithms/set_operations/check_turn_less.hpp b/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
         <
diff --git a/test/algorithms/set_operations/test_get_turns_ll_invariance.hpp b/test/algorithms/set_operations/test_get_turns_ll_invariance.hpp
@@ -45,6 +45,7 @@ class test_get_turns_ll_invariance
         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
         <

Original file line number	Diff line number	Diff line change
`@@ -266,7 +266,7 @@ class piece_turn_visitor`
`266`	`266`
`267`	`267`	`typedef detail::overlay::get_turn_info`
`268`	`268`	`<`
`269`		`- detail::overlay::assign_null_policy`
	`269`	`+ detail::overlay::assign_policy_only_start_turns`
`270`	`270`	`> turn_policy;`
`271`	`271`
`272`	`272`	`turn_policy::apply(unique_sub_range1, unique_sub_range2,`
Original file line number	Diff line number	Diff line change
`@@ -491,8 +491,8 @@ inline void enrich_intersection_points(Turns& turns,`
`491`	`491`	`{`
`492`	`492`	`detail::overlay::discard_closed_turns`
`493`	`493`	`<`
`494`		`- OverlayType,`
`495`		`- target_operation`
	`494`	`+ OverlayType,`
	`495`	`+ target_operation`
`496`	`496`	`>::apply(turns, clusters, geometry1, geometry2,`
`497`	`497`	`strategy);`
`498`	`498`	`detail::overlay::discard_open_turns`
Original file line number	Diff line number	Diff line change
`@@ -306,7 +306,7 @@ std::cout << "get turns" << std::endl;`
`306`	`306`	`geometry::get_turns`
`307`	`307`	`<`
`308`	`308`	`Reverse1, Reverse2,`
`309`		`- detail::overlay::assign_null_policy`
	`309`	`+ assign_policy_only_start_turns`
`310`	`310`	`>(geometry1, geometry2, strategy, robust_policy, turns, policy);`
`311`	`311`
`312`	`312`	`visitor.visit_turns(1, turns);`
`@@ -318,12 +318,12 @@ std::cout << "get turns" << std::endl;`
`318`	`318`	`// and if necessary (e.g.: multi-geometry, polygon with interior rings)`
`319`	`319`	`if (needs_self_turns<Geometry1>::apply(geometry1))`
`320`	`320`	`{`
`321`		`- self_get_turn_points::self_turns<Reverse1, assign_null_policy>(geometry1,`
	`321`	`+ self_get_turn_points::self_turns<Reverse1, assign_policy_only_start_turns>(geometry1,`
`322`	`322`	`strategy, robust_policy, turns, policy, 0);`
`323`	`323`	`}`
`324`	`324`	`if (needs_self_turns<Geometry2>::apply(geometry2))`
`325`	`325`	`{`
`326`		`- self_get_turn_points::self_turns<Reverse2, assign_null_policy>(geometry2,`
	`326`	`+ self_get_turn_points::self_turns<Reverse2, assign_policy_only_start_turns>(geometry2,`
`327`	`327`	`strategy, robust_policy, turns, policy, 1);`
`328`	`328`	`}`
`329`	`329`	`}`
Original file line number	Diff line number	Diff line change
`@@ -181,6 +181,7 @@ struct areal_interrupt_policy`
`181`	`181`	`return true;`
`182`	`182`	`}`
`183`	`183`	`break;`
	`184`	`+ case overlay::method_start :`
`184`	`185`	`case overlay::method_none :`
`185`	`186`	`case overlay::method_disjoint :`
`186`	`187`	`case overlay::method_error :`
Original file line number	Diff line number	Diff line change
`@@ -55,6 +55,7 @@ struct check_turn_less`
`55`	`55`	`static bool const include_no_turn = false;`
`56`	`56`	`static bool const include_degenerate = EnableDegenerateTurns;`
`57`	`57`	`static bool const include_opposite = false;`
	`58`	`+ static bool const include_start_turn = false;`
`58`	`59`
`59`	`60`	`template`
`60`	`61`	`<`
Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,7 @@ class test_get_turns_ll_invariance`
`45`	`45`	`static bool const include_no_turn = false;`
`46`	`46`	`static bool const include_degenerate = EnableDegenerateTurns;`
`47`	`47`	`static bool const include_opposite = false;`
	`48`	`+ static bool const include_start_turn = false;`
`48`	`49`
`49`	`50`	`template`
`50`	`51`	`<`