Feature/get turn info add retrieve policy

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

@@ -17,6 +17,7 @@
 #include <boost/core/ignore_unused.hpp>
 #include <boost/range.hpp>
 
+#include <boost/geometry/core/assert.hpp>
 #include <boost/geometry/algorithms/equals.hpp>
 #include <boost/geometry/algorithms/expand.hpp>
 #include <boost/geometry/algorithms/detail/disjoint/box_box.hpp>
@@ -34,34 +35,81 @@ namespace boost { namespace geometry
 namespace detail { namespace buffer
 {
 
-
-#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
-struct buffer_assign_turn
+// Implements a unique_sub_range for a buffered piece,
+// the range can return subsequent points
+// known as "i", "j" and "k" (and further),  indexed as 0,1,2,3
+template <typename Ring>
+struct unique_sub_range_from_piece
 {
-    static bool const include_no_turn = false;
-    static bool const include_degenerate = false;
-    static bool const include_opposite = false;
-
-    template
-    <
-        typename Info,
-        typename Point1,
-        typename Point2,
-        typename IntersectionInfo
-    >
-    static inline void apply(Info& info,
-                             Point1 const& /*p1*/,
-                             Point2 const& /*p2*/,
-                             IntersectionInfo const& iinfo)
+    typedef typename boost::range_iterator<Ring const>::type iterator_type;
+    typedef typename geometry::point_type<Ring const>::type point_type;
+
+    unique_sub_range_from_piece(Ring const& ring,
+                                iterator_type iterator_at_i, iterator_type iterator_at_j)
+        : m_ring(ring)
+        , m_iterator_at_i(iterator_at_i)
+        , m_iterator_at_j(iterator_at_j)
+        , m_point_retrieved(false)
+    {}
+
+    static inline bool is_first_segment() { return false; }
+    static inline bool is_last_segment() { return false; }
+
+    static inline std::size_t size() { return 3u; }
+
+    inline point_type const& at(std::size_t index) const
     {
-        info.rob_pi = iinfo.rpi();
-        info.rob_pj = iinfo.rpj();
-        info.rob_qi = iinfo.rqi();
-        info.rob_qj = iinfo.rqj();
+        BOOST_GEOMETRY_ASSERT(index < size());
+        switch (index)
+        {
+            case 0 : return *m_iterator_at_i;
+            case 1 : return *m_iterator_at_j;
+            case 2 : return get_point_k();
+            default : return *m_iterator_at_i;
+        }
     }
 
+private :
+
+    inline point_type const& get_point_k() const
+    {
+        if (! m_point_retrieved)
+        {
+            m_iterator_at_k = advance_one(m_iterator_at_j);
+            m_point_retrieved = true;
+        }
+        return *m_iterator_at_k;
+    }
+
+    inline void circular_advance_one(iterator_type& next) const
+    {
+        ++next;
+        if (next == boost::end(m_ring))
+        {
+            next = boost::begin(m_ring) + 1;
+        }
+    }
+
+    inline iterator_type advance_one(iterator_type it) const
+    {
+        iterator_type result = it;
+        circular_advance_one(result);
+
+        // TODO: we could also use piece-boundaries
+        // to check if the point equals the last one
+        while (geometry::equals(*it, *result))
+        {
+            circular_advance_one(result);
+        }
+        return result;
+    }
+
+    Ring const& m_ring;
+    iterator_type m_iterator_at_i;
+    iterator_type m_iterator_at_j;
+    mutable iterator_type m_iterator_at_k;
+    mutable bool m_point_retrieved;
 };
-#endif
 
 template
 <
@@ -102,29 +150,6 @@ class piece_turn_visitor
         return ! m_rings[piece1.first_seg_id.multi_index].has_concave;
     }
 
-    template <typename Range, typename Iterator>
-    inline void move_to_next_point(Range const& range, Iterator& next) const
-    {
-        ++next;
-        if (next == boost::end(range))
-        {
-            next = boost::begin(range) + 1;
-        }
-    }
-
-    template <typename Range, typename Iterator>
-    inline Iterator next_point(Range const& range, Iterator it) const
-    {
-        Iterator result = it;
-        move_to_next_point(range, result);
-        // TODO: we could use either piece-boundaries, or comparison with
-        // robust points, to check if the point equals the last one
-        while(geometry::equals(*it, *result))
-        {
-            move_to_next_point(range, result);
-        }
-        return result;
-    }
 
     template <std::size_t Dimension, typename Iterator, typename Box>
     inline void move_begin_iterator(Iterator& it_begin, Iterator it_beyond,
@@ -229,15 +254,23 @@ class piece_turn_visitor
             the_model.operations[1].piece_index = piece2.index;
             the_model.operations[1].seg_id = piece2.first_seg_id;
             the_model.operations[1].seg_id.segment_index = index2; // override
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+            geometry::recalculate(the_model.rob_pi, *prev1, m_robust_policy);
+            geometry::recalculate(the_model.rob_pj, *it1, m_robust_policy);
+#endif
 
-            iterator next1 = next_point(ring1, it1);
+            unique_sub_range_from_piece<ring_type> unique_sub_range1(ring1, prev1, it1);
 
             iterator it2 = it2_first;
             for (iterator prev2 = it2++;
                     it2 != it2_beyond;
                     prev2 = it2++, the_model.operations[1].seg_id.segment_index++)
             {
-                iterator next2 = next_point(ring2, it2);
+                unique_sub_range_from_piece<ring_type> unique_sub_range2(ring2, prev2, it2);
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+                geometry::recalculate(the_model.rob_qi, *prev2, m_robust_policy);
+                geometry::recalculate(the_model.rob_qj, *it2, m_robust_policy);
+#endif
 
                 // TODO: internally get_turn_info calculates robust points.
                 // But they are already calculated.
@@ -246,20 +279,14 @@ class piece_turn_visitor
                 // and iterating in sync with them...
                 typedef detail::overlay::get_turn_info
                     <
-#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
-                        buffer_assign_turn
-#else
                         detail::overlay::assign_null_policy
-#endif
                     > turn_policy;
 
-                turn_policy::apply(*prev1, *it1, *next1,
-                                    *prev2, *it2, *next2,
-                                    false, false, false, false,
-                                    the_model,
-                                    m_intersection_strategy,
-                                    m_robust_policy,
-                                    std::back_inserter(m_turns));
+                turn_policy::apply(unique_sub_range1, unique_sub_range2,
+                                   the_model,
+                                   m_intersection_strategy,
+                                   m_robust_policy,
+                                   std::back_inserter(m_turns));
             }
         }
     }

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

@@ -93,18 +93,6 @@ struct assign_disjoint_policy
     static bool const include_no_turn = true;
     static bool const include_degenerate = true;
     static bool const include_opposite = true;
-
-    // We don't assign extra info:
-    template
-    <
-        typename Info,
-        typename Point1,
-        typename Point2,
-        typename IntersectionInfo
-    >
-    static inline void apply(Info& , Point1 const& , Point2 const&,
-                IntersectionInfo const&)
-    {}
 };
 
 

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

@@ -44,12 +44,16 @@ template
 >
 struct get_turn_without_info
 {
-    template <typename Strategy, typename RobustPolicy, typename OutputIterator>
-    static inline OutputIterator apply(
-                Point1 const& pi, Point1 const& pj, Point1 const& /*pk*/,
-                Point2 const& qi, Point2 const& qj, Point2 const& /*qk*/,
-                bool /*is_p_first*/, bool /*is_p_last*/,
-                bool /*is_q_first*/, bool /*is_q_last*/,
+    template
+    <
+        typename UniqueSubRange1,
+        typename UniqueSubRange2,
+        typename Strategy,
+        typename RobustPolicy,
+        typename OutputIterator
+    >
+    static inline OutputIterator apply(UniqueSubRange1 const& range_p,
+                UniqueSubRange2 const& range_q,
                 TurnInfo const& ,
                 Strategy const& strategy,
                 RobustPolicy const& robust_policy,
@@ -71,6 +75,10 @@ struct get_turn_without_info
 
         typedef model::referring_segment<Point1 const> segment_type1;
         typedef model::referring_segment<Point2 const> segment_type2;
+        Point1 const& pi = range_p.at(0);
+        Point1 const& pj = range_p.at(1);
+        Point2 const& qi = range_q.at(0);
+        Point2 const& qj = range_q.at(1);
         segment_type1 p1(pi, pj);
         segment_type2 q1(qi, qj);