[Boost-commit] svn:boost r60640 - sandbox/geometry/boost/geometry/algorithms

Subject: [Boost-commit] svn:boost r60640 - sandbox/geometry/boost/geometry/algorithms
From: barend.gehrels_at_[hidden]
Date: 2010-03-16 06:59:26

Author: barendgehrels
Date: 2010-03-16 06:59:25 EDT (Tue, 16 Mar 2010)
New Revision: 60640
URL: http://svn.boost.org/trac/boost/changeset/60640

Log:
Updated monotonic sections, splitted sectionalize_range to sectionalize_part to be able to create sections on-the-fly 
Text files modified: 
   sandbox/geometry/boost/geometry/algorithms/sectionalize.hpp |   111 +++++++++++++++++++++++++++------------ 
   1 files changed, 76 insertions(+), 35 deletions(-)

Modified: sandbox/geometry/boost/geometry/algorithms/sectionalize.hpp
==============================================================================
--- sandbox/geometry/boost/geometry/algorithms/sectionalize.hpp	(original)
+++ sandbox/geometry/boost/geometry/algorithms/sectionalize.hpp	2010-03-16 06:59:25 EDT (Tue, 16 Mar 2010)
@@ -74,7 +74,6 @@
     bool duplicate;
     int non_duplicate_index;
 
-
     inline section()
         : id(-1)
         , ring_index(-99)
@@ -110,7 +109,8 @@
 
 
 #ifndef DOXYGEN_NO_DETAIL
-namespace detail { namespace sectionalize {
+namespace detail { namespace sectionalize 
+{
 
 template <typename Segment, std::size_t Dimension, std::size_t DimensionCount>
 struct get_direction_loop
@@ -247,7 +247,7 @@
     }
 };
 
-
+/// @brief Helper class to create sections of a part of a range, on the fly
 template
 <
     typename Range,
@@ -256,61 +256,59 @@
     std::size_t DimensionCount,
     std::size_t MaxCount
 >
-struct sectionalize_range
+struct sectionalize_part
 {
-    static inline void apply(Range const& range, Sections& sections,
+    typedef geometry::segment<Point const> segment_type;
+    typedef typename boost::range_value<Sections>::type section_type;
+    typedef typename boost::range_iterator<Range const>::type iterator_type;
+
+    static inline void apply(Sections& sections, section_type& section,
+                std::size_t& index, int& ndi, 
+                Range const& range, 
                 int ring_index = -1, int multi_index = -1)
     {
-        typedef segment<const Point> segment_type;
 
         std::size_t const n = boost::size(range);
-        if (n == 0)
+        if (n <= index + 1)
         {
-            // Zero points, no section
+            // Zero points, or only one point
+            // -> no section can be generated
             return;
         }
 
-        if (n == 1)
+        if (index == 0)
         {
-            // Line with one point ==> no sections
-            return;
+            ndi = 0;
         }
 
-        int i = 0;
-        int ndi = 0; // non duplicate index
-
-        typedef typename boost::range_value<Sections>::type sections_range_type;
-        sections_range_type section;
-
-        typedef typename boost::range_const_iterator<Range>::type iterator_type;
         iterator_type it = boost::begin(range);
+        it += index;
 
         for(iterator_type previous = it++;
             it != boost::end(range);
-            previous = it++, i++)
+            previous = it++, index++)
         {
-            segment_type s(*previous, *it);
+            segment_type segment(*previous, *it);
 
             int direction_classes[DimensionCount] = {0};
             get_direction_loop
                 <
                     segment_type, 0, DimensionCount
-                >::apply(s, direction_classes);
+                >::apply(segment, direction_classes);
 
             // if "dir" == 0 for all point-dimensions, it is duplicate.
             // Those sections might be omitted, if wished, lateron
-            bool check_duplicate = true; //?
             bool duplicate = false;
 
-            if (check_duplicate && direction_classes[0] == 0)
+            if (direction_classes[0] == 0)
             {
-                // Recheck because all dimensions should be checked,
-                // not only first one,
-                // Note that DimensionCount might be < dimension<P>::value
+                // Recheck because ALL dimensions should be checked,
+                // not only first one.
+                // (DimensionCount might be < dimension<P>::value)
                 if (check_duplicate_loop
                     <
                         segment_type, 0, geometry::dimension<Point>::type::value
-                    >::apply(s)
+                    >::apply(segment)
                     )
                 {
                     duplicate = true;
@@ -336,12 +334,12 @@
                 )
             {
                 sections.push_back(section);
-                section = sections_range_type();
+                section = section_type();
             }
 
             if (section.count == 0)
             {
-                section.begin_index = i;
+                section.begin_index = index;
                 section.ring_index = ring_index;
                 section.multi_index = multi_index;
                 section.duplicate = duplicate;
@@ -356,14 +354,59 @@
             }
 
             geometry::combine(section.bounding_box, *it);
-            section.end_index = i + 1;
+            section.end_index = index + 1;
             section.count++;
             if (! duplicate)
             {
                 ndi++;
             }
         }
+    }
+};
+
 
+template
+<
+    typename Range,
+    typename Point,
+    typename Sections,
+    std::size_t DimensionCount,
+    std::size_t MaxCount
+>
+struct sectionalize_range
+{
+    static inline void apply(Range const& range, Sections& sections,
+                int ring_index = -1, int multi_index = -1)
+    {
+        typedef segment<const Point> segment_type;
+
+        std::size_t const n = boost::size(range);
+        if (n == 0)
+        {
+            // Zero points, no section
+            return;
+        }
+
+        if (n == 1)
+        {
+            // Line with one point ==> no sections
+            return;
+        }
+
+        std::size_t index = 0;
+        int ndi = 0; // non duplicate index
+
+        typedef typename boost::range_value<Sections>::type section_type;
+        section_type section;
+
+        sectionalize_part
+            <
+                Range, Point, Sections,
+                DimensionCount, MaxCount
+            >::apply(sections, section, index, ndi, 
+                        range, ring_index, multi_index);
+
+        // Add last section if applicable
         if (section.count > 0)
         {
             sections.push_back(section);
@@ -390,9 +433,9 @@
                 ring_type, point_type, Sections, DimensionCount, MaxCount
             > sectionalizer_type;
 
-        typedef typename boost::range_const_iterator
+        typedef typename boost::range_iterator
             <
-            typename interior_type<Polygon>::type
+                typename interior_type<Polygon>::type const
             >::type iterator_type;
 
         sectionalizer_type::apply(exterior_ring(poly), sections, -1, multi_index);
@@ -583,9 +626,7 @@
 }
 
 
-
-
-
 }} // namespace boost::geometry
 
+
 #endif // BOOST_GEOMETRY_ALGORITHMS_SECTIONALIZE_HPP