From e472d4b439210df9e040b401ee5891145276e758 Mon Sep 17 00:00:00 2001
From: Menelaos Karavelas <menelaos.karavelas@gmail.com>
Date: Mon, 11 Aug 2014 13:20:07 +0300
Subject: [PATCH] [algorithms][num_points] re-write the num_points code so that
 the add_for_open boolean argument is passed at the dispatch level as a
 template parameter; this enables the firther simplification of the code in
 detail::counting namespace

---
 .../geometry/algorithms/detail/counting.hpp   | 21 +-----
 .../boost/geometry/algorithms/num_points.hpp  | 66 ++++++++++++-------
 2 files changed, 45 insertions(+), 42 deletions(-)

diff --git a/include/boost/geometry/algorithms/detail/counting.hpp b/include/boost/geometry/algorithms/detail/counting.hpp
index d6572aca0..dc5bb26c1 100644
--- a/include/boost/geometry/algorithms/detail/counting.hpp
+++ b/include/boost/geometry/algorithms/detail/counting.hpp
@@ -62,16 +62,16 @@ template <typename RangeCount>
 struct polygon_count
 {
     template <typename Polygon>
-    static inline std::size_t apply(Polygon const& poly, bool add_for_open)
+    static inline std::size_t apply(Polygon const& poly)
     {
-        std::size_t n = RangeCount::apply(exterior_ring(poly), add_for_open);
+        std::size_t n = RangeCount::apply(exterior_ring(poly));
 
         typename interior_return_type<Polygon const>::type
             rings = interior_rings(poly);
         for (typename detail::interior_iterator<Polygon const>::type
                 it = boost::begin(rings); it != boost::end(rings); ++it)
         {
-            n += RangeCount::apply(*it, add_for_open);
+            n += RangeCount::apply(*it);
         }
 
         return n;
@@ -95,21 +95,6 @@ struct multi_count
         }
         return n;
     }
-
-    template <typename MultiGeometry>
-    static inline
-    std::size_t apply(MultiGeometry const& geometry, bool add_for_open)
-    {
-        std::size_t n = 0;
-        for (typename boost::range_iterator<MultiGeometry const>::type
-                 it = boost::begin(geometry);
-             it != boost::end(geometry);
-             ++it)
-        {
-            n += SingleCount::apply(*it, add_for_open);
-        }
-        return n;
-    }
 };
 
 
diff --git a/include/boost/geometry/algorithms/num_points.hpp b/include/boost/geometry/algorithms/num_points.hpp
index ab2afabe0..541240c78 100644
--- a/include/boost/geometry/algorithms/num_points.hpp
+++ b/include/boost/geometry/algorithms/num_points.hpp
@@ -36,8 +36,8 @@
 
 #include <boost/geometry/algorithms/not_implemented.hpp>
 
-#include <boost/geometry/algorithms/num_segments.hpp>
 #include <boost/geometry/algorithms/detail/counting.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_point.hpp>
 
 #include <boost/geometry/geometries/concepts/check.hpp>
 
@@ -57,14 +57,26 @@ namespace detail { namespace num_points
 {
 
 
+template <bool AddForOpen>
 struct range_count
 {
     template <typename Range>
-    static inline std::size_t apply(Range const& range, bool add_for_open)
+    static inline std::size_t apply(Range const& range)
     {
-        return (boost::size(range) > 0)
-            ? (num_segments::range_count::apply(range, add_for_open) + 1)
-            : 0;
+        std::size_t n = boost::size(range);
+        if ( n == 0 )
+        {
+            return 0;
+        }
+        if (AddForOpen
+            && geometry::closure<Range>::value == open
+            && detail::disjoint::disjoint_point_point(range::front(range),
+                                                      range::at(range, n - 1))
+            )
+        {
+            return n + 1;
+        }
+        return n;
     }
 };
 
@@ -79,6 +91,7 @@ namespace dispatch
 template
 <
     typename Geometry,
+    bool AddForOpen,
     typename Tag = typename tag_cast
         <
             typename tag<Geometry>::type, multi_tag
@@ -87,41 +100,44 @@ template
 struct num_points: not_implemented<Tag>
 {};
 
-template <typename Geometry>
-struct num_points<Geometry, point_tag>
+template <typename Geometry, bool AddForOpen>
+struct num_points<Geometry, AddForOpen, point_tag>
     : detail::counting::other_count<1>
 {};
 
-template <typename Geometry>
-struct num_points<Geometry, box_tag>
+template <typename Geometry, bool AddForOpen>
+struct num_points<Geometry, AddForOpen, box_tag>
     : detail::counting::other_count<(1 << geometry::dimension<Geometry>::value)>
 {};
 
-template <typename Geometry>
-struct num_points<Geometry, segment_tag>
+template <typename Geometry, bool AddForOpen>
+struct num_points<Geometry, AddForOpen, segment_tag>
     : detail::counting::other_count<2>
 {};
 
-template <typename Geometry>
-struct num_points<Geometry, linestring_tag>
-    : detail::num_points::range_count
+template <typename Geometry, bool AddForOpen>
+struct num_points<Geometry, AddForOpen, linestring_tag>
+    : detail::num_points::range_count<AddForOpen>
 {};
 
-template <typename Geometry>
-struct num_points<Geometry, ring_tag>
-    : detail::num_points::range_count
+template <typename Geometry, bool AddForOpen>
+struct num_points<Geometry, AddForOpen, ring_tag>
+    : detail::num_points::range_count<AddForOpen>
 {};
 
-template <typename Geometry>
-struct num_points<Geometry, polygon_tag>
-    : detail::counting::polygon_count<detail::num_points::range_count>
+template <typename Geometry, bool AddForOpen>
+struct num_points<Geometry, AddForOpen, polygon_tag>
+    : detail::counting::polygon_count
+        <
+            detail::num_points::range_count<AddForOpen>
+        >
 {};
 
-template <typename Geometry>
-struct num_points<Geometry, multi_tag>
+template <typename Geometry, bool AddForOpen>
+struct num_points<Geometry, AddForOpen, multi_tag>
     : detail::counting::multi_count
         <
-            num_points<typename boost::range_value<Geometry>::type>
+            num_points<typename boost::range_value<Geometry>::type, AddForOpen>
         >
 {};
 
@@ -140,7 +156,9 @@ struct num_points
     {
         concept::check<Geometry const>();
 
-        return dispatch::num_points<Geometry>::apply(geometry, add_for_open);
+        return add_for_open
+            ? dispatch::num_points<Geometry, true>::apply(geometry)
+            : dispatch::num_points<Geometry, false>::apply(geometry);
     }
 };