From 8e9dfdf3e626d994976d541413fac5fcafff484f Mon Sep 17 00:00:00 2001
From: Barend Gehrels <barend@xs4all.nl>
Date: Mon, 24 May 2010 17:03:41 +0000
Subject: [PATCH] Moved order/closure outside dispatches, not necessary there /
 more overhead Implemented order/closure in within

[SVN r62175]
---
 include/boost/geometry/algorithms/area.hpp    | 41 ++++++------
 .../boost/geometry/algorithms/centroid.hpp    | 41 ++++++------
 include/boost/geometry/algorithms/within.hpp  | 63 +++++++++++++++----
 .../boost/geometry/multi/algorithms/area.hpp  |  5 +-
 .../geometry/multi/algorithms/centroid.hpp    |  7 +--
 .../geometry/multi/algorithms/within.hpp      |  2 +
 test/algorithms/test_within.hpp               | 54 ++++++++++------
 test/algorithms/within.cpp                    |  2 +-
 8 files changed, 140 insertions(+), 75 deletions(-)

diff --git a/include/boost/geometry/algorithms/area.hpp b/include/boost/geometry/algorithms/area.hpp
index fc833e69d..bca72e401 100644
--- a/include/boost/geometry/algorithms/area.hpp
+++ b/include/boost/geometry/algorithms/area.hpp
@@ -116,7 +116,6 @@ struct ring_area
             return type();
         }
 
-
         typedef reversible_view<Ring const, Direction> rview_type;
         typedef closeable_view
             <
@@ -158,8 +157,6 @@ template
 <
     typename Tag,
     typename Geometry,
-    order_selector Order,
-    closure_selector Closure,
     typename Strategy
 >
 struct area
@@ -171,26 +168,38 @@ struct area
         > {};
 
 
-template <typename Geometry, order_selector Order, closure_selector Closure, typename Strategy>
-struct area<box_tag, Geometry, Order, Closure, Strategy>
+template 
+<
+    typename Geometry, 
+    typename Strategy
+>
+struct area<box_tag, Geometry, Strategy>
     : detail::area::box_area<Geometry, Strategy>
 {};
 
 
-template <typename Geometry, order_selector Order, closure_selector Closure, typename Strategy>
-struct area<ring_tag, Geometry, Order, Closure, Strategy>
+template 
+<
+    typename Ring, 
+    typename Strategy
+>
+struct area<ring_tag, Ring, Strategy>
     : detail::area::ring_area
         <
-            Geometry, 
-            order_as_direction<Order>::value, 
-            Closure, //closure_as_bool<Closure>::value,
+            Ring, 
+            order_as_direction<geometry::point_order<Ring>::value>::value,
+            geometry::closure<Ring>::value,
             Strategy
         >
 {};
 
 
-template <typename Polygon, order_selector Order, closure_selector Closure, typename Strategy>
-struct area<polygon_tag, Polygon, Order, Closure, Strategy>
+template 
+<
+    typename Polygon, 
+    typename Strategy
+>
+struct area<polygon_tag, Polygon, Strategy>
     : detail::calculate_polygon_sum
         <
             typename Strategy::return_type,
@@ -199,8 +208,8 @@ struct area<polygon_tag, Polygon, Order, Closure, Strategy>
             detail::area::ring_area
                 <
                     typename ring_type<Polygon>::type,
-                    order_as_direction<Order>::value,
-                    Closure, //closure_as_bool<Closure>::value,
+                    order_as_direction<geometry::point_order<Polygon>::value>::value,
+                    geometry::closure<Polygon>::value,
                     Strategy
                 >
         >
@@ -234,8 +243,6 @@ inline typename area_result<Geometry>::type area(Geometry const& geometry)
         <
             typename tag<Geometry>::type,
             Geometry,
-            geometry::point_order<Geometry>::value,
-            geometry::closure<Geometry>::value,
             strategy_type
         >::apply(geometry, strategy_type());
 }
@@ -259,8 +266,6 @@ inline typename Strategy::return_type area(
         <
             typename tag<Geometry>::type,
             Geometry,
-            geometry::point_order<Geometry>::value,
-            geometry::closure<Geometry>::value,
             Strategy
         >::apply(geometry, strategy);
 }
diff --git a/include/boost/geometry/algorithms/centroid.hpp b/include/boost/geometry/algorithms/centroid.hpp
index d9fb5ea8b..d0c74e88c 100644
--- a/include/boost/geometry/algorithms/centroid.hpp
+++ b/include/boost/geometry/algorithms/centroid.hpp
@@ -276,16 +276,18 @@ struct centroid_linestring
     \note Because outer ring is clockwise, inners are counter clockwise,
     triangle approach is OK and works for polygons with rings.
 */
-template<typename Polygon, closure_selector Closure, typename Strategy>
+template<typename Polygon, typename Strategy>
 struct centroid_polygon_state
 {
+    typedef typename ring_type<Polygon>::type ring_type;
+
     static inline void apply(Polygon const& poly,
             Strategy const& strategy, typename Strategy::state_type& state)
     {
         typedef centroid_ring_state
             <
-                typename ring_type<Polygon>::type,
-                Closure,
+                ring_type,
+                geometry::closure<ring_type>::value,
                 Strategy
             > per_ring;
 
@@ -303,7 +305,7 @@ struct centroid_polygon_state
     }
 };
 
-template<typename Polygon, typename Point, closure_selector Closure, typename Strategy>
+template<typename Polygon, typename Point, typename Strategy>
 struct centroid_polygon
 {
     static inline void apply(Polygon const& poly, Point& centroid,
@@ -315,7 +317,6 @@ struct centroid_polygon
             centroid_polygon_state
                 <
                     Polygon,
-                    Closure,
                     Strategy
                 >::apply(poly, strategy, state);
             Strategy::result(state, centroid);
@@ -337,7 +338,6 @@ template
     typename Tag,
     typename Geometry,
     typename Point,
-    closure_selector Closure,
     typename Strategy
 >
 struct centroid {};
@@ -346,10 +346,9 @@ template
 <
     typename Geometry,
     typename Point,
-    closure_selector Closure,
     typename Strategy
 >
-struct centroid<point_tag, Geometry, Point, Closure, Strategy>
+struct centroid<point_tag, Geometry, Point, Strategy>
     : detail::centroid::centroid_point<Geometry, Point, Strategy>
 {};
 
@@ -357,26 +356,31 @@ template
 <
     typename Box,
     typename Point,
-    closure_selector Closure,
     typename Strategy
 >
-struct centroid<box_tag, Box, Point, Closure, Strategy>
+struct centroid<box_tag, Box, Point, Strategy>
     : detail::centroid::centroid_box<Box, Point, Strategy>
 {};
 
-template <typename Ring, typename Point, closure_selector Closure, typename Strategy>
-struct centroid<ring_tag, Ring, Point, Closure, Strategy>
-    : detail::centroid::centroid_ring<Ring, Point, Closure, Strategy>
+template <typename Ring, typename Point, typename Strategy>
+struct centroid<ring_tag, Ring, Point, Strategy>
+    : detail::centroid::centroid_ring
+        <
+            Ring, 
+            Point, 
+            geometry::closure<Ring>::value,
+            Strategy
+        >
 {};
 
-template <typename Linestring, typename Point, closure_selector Closure, typename Strategy>
-struct centroid<linestring_tag, Linestring, Point, Closure, Strategy>
+template <typename Linestring, typename Point, typename Strategy>
+struct centroid<linestring_tag, Linestring, Point, Strategy>
     : detail::centroid::centroid_linestring<Linestring, Point, Strategy>
  {};
 
-template <typename Polygon, typename Point, closure_selector Closure, typename Strategy>
-struct centroid<polygon_tag, Polygon, Point, Closure, Strategy>
-    : detail::centroid::centroid_polygon<Polygon, Point, Closure, Strategy>
+template <typename Polygon, typename Point, typename Strategy>
+struct centroid<polygon_tag, Polygon, Point, Strategy>
+    : detail::centroid::centroid_polygon<Polygon, Point, Strategy>
  {};
 
 } // namespace dispatch
@@ -407,7 +411,6 @@ inline void centroid(Geometry const& geometry, Point& c,
             typename tag<Geometry>::type,
             Geometry,
             Point,
-            geometry::closure<Geometry>::value,
             Strategy
         >::apply(geometry, c, strategy);
 }
diff --git a/include/boost/geometry/algorithms/within.hpp b/include/boost/geometry/algorithms/within.hpp
index e13a83a4d..ec5b4a6d6 100644
--- a/include/boost/geometry/algorithms/within.hpp
+++ b/include/boost/geometry/algorithms/within.hpp
@@ -51,14 +51,18 @@ The within algorithm is used as following:
 #include <boost/geometry/algorithms/make.hpp>
 
 #include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/cs.hpp>
 #include <boost/geometry/core/exterior_ring.hpp>
 #include <boost/geometry/core/interior_rings.hpp>
-#include <boost/geometry/core/cs.hpp>
-
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/core/ring_type.hpp>
 #include <boost/geometry/geometries/concepts/check.hpp>
-
 #include <boost/geometry/strategies/point_in_poly.hpp>
 #include <boost/geometry/strategies/concepts/within_concept.hpp>
+#include <boost/geometry/util/order_as_direction.hpp>
+#include <boost/geometry/util/closeable_view.hpp>
+#include <boost/geometry/util/reversible_view.hpp>
 
 
 namespace boost { namespace geometry
@@ -168,7 +172,14 @@ struct box_in_box<Box1, Box2, Strategy, DimensionCount, DimensionCount>
 };
 
 
-template<typename Point, typename Ring, typename Strategy>
+template
+<
+    typename Point, 
+    typename Ring, 
+    iterate_direction Direction, 
+    closure_selector Closure,
+    typename Strategy
+>
 struct point_in_ring
 {
     BOOST_CONCEPT_ASSERT( (geometry::concept::WithinStrategy<Strategy>) );
@@ -181,14 +192,23 @@ struct point_in_ring
             return false;
         }
 
-        typedef typename boost::range_iterator<Ring const>::type iterator_type;
+        typedef reversible_view<Ring const, Direction> rev_view_type;
+        typedef closeable_view
+            <
+                rev_view_type const,
+                Closure == open // close it if it is open
+            > cl_view_type;
+        typedef typename boost::range_iterator<cl_view_type const>::type iterator_type;
 
+        rev_view_type rev_view(ring);
+        cl_view_type view(rev_view);
         typename Strategy::state_type state;
+        iterator_type it = boost::begin(view);
+        iterator_type end = boost::end(view);
 
-        iterator_type it = boost::begin(ring);
         for (iterator_type previous = it++;
-            it != boost::end(ring);
-            previous = it++)
+            it != end;
+            ++previous, ++it)
         {
             if (! strategy.apply(point, *previous, *it, state))
             {
@@ -200,7 +220,14 @@ struct point_in_ring
 };
 
 // Polygon: in exterior ring, and if so, not within interior ring(s)
-template<typename Point, typename Polygon, typename Strategy>
+template
+<
+    typename Point, 
+    typename Polygon, 
+    iterate_direction Direction, 
+    closure_selector Closure,
+    typename Strategy
+>
 struct point_in_polygon
 {
     BOOST_CONCEPT_ASSERT( (geometry::concept::WithinStrategy<Strategy>) );
@@ -213,6 +240,8 @@ struct point_in_polygon
             <
                 Point,
                 typename ring_type<Polygon>::type,
+                Direction,
+                Closure,
                 Strategy
             > per_ring;
 
@@ -286,13 +315,25 @@ struct within<box_tag, box_tag, Box1, Box2, Strategy>
 template <typename Point, typename Ring, typename Strategy>
 struct within<point_tag, ring_tag, Point, Ring, Strategy>
     : detail::within::point_in_ring
-        <Point, Ring, Strategy>
+        <
+            Point, 
+            Ring, 
+            order_as_direction<geometry::point_order<Ring>::value>::value,
+            geometry::closure<Ring>::value,
+            Strategy
+        >
 {};
 
 template <typename Point, typename Polygon, typename Strategy>
 struct within<point_tag, polygon_tag, Point, Polygon, Strategy>
     : detail::within::point_in_polygon
-        <Point, Polygon, Strategy>
+        <
+            Point, 
+            Polygon, 
+            order_as_direction<geometry::point_order<Polygon>::value>::value,
+            geometry::closure<Polygon>::value,
+            Strategy
+        >
 {};
 
 } // namespace dispatch
diff --git a/include/boost/geometry/multi/algorithms/area.hpp b/include/boost/geometry/multi/algorithms/area.hpp
index 0112208d4..28d98f0dc 100644
--- a/include/boost/geometry/multi/algorithms/area.hpp
+++ b/include/boost/geometry/multi/algorithms/area.hpp
@@ -24,8 +24,8 @@ namespace boost { namespace geometry
 #ifndef DOXYGEN_NO_DISPATCH
 namespace dispatch
 {
-template <typename MultiGeometry, order_selector Order, closure_selector Closure, typename Strategy>
-struct area<multi_polygon_tag, MultiGeometry, Order, Closure, Strategy>
+template <typename MultiGeometry, typename Strategy>
+struct area<multi_polygon_tag, MultiGeometry, Strategy>
     : detail::multi_sum
         <
             typename Strategy::return_type,
@@ -35,7 +35,6 @@ struct area<multi_polygon_tag, MultiGeometry, Order, Closure, Strategy>
                 <
                     polygon_tag,
                     typename boost::range_value<MultiGeometry>::type,
-                    Order, Closure,
                     Strategy
                 >
     >
diff --git a/include/boost/geometry/multi/algorithms/centroid.hpp b/include/boost/geometry/multi/algorithms/centroid.hpp
index a2ec1dd61..a1797df77 100644
--- a/include/boost/geometry/multi/algorithms/centroid.hpp
+++ b/include/boost/geometry/multi/algorithms/centroid.hpp
@@ -103,10 +103,9 @@ template
 <
     typename MultiPolygon,
     typename Point,
-    closure_selector Closure,
     typename Strategy
 >
-struct centroid<multi_polygon_tag, MultiPolygon, Point, Closure, Strategy>
+struct centroid<multi_polygon_tag, MultiPolygon, Point,  Strategy>
     : detail::centroid::centroid_multi
         <
             MultiPolygon,
@@ -115,7 +114,6 @@ struct centroid<multi_polygon_tag, MultiPolygon, Point, Closure, Strategy>
             detail::centroid::centroid_polygon_state
                 <
                     typename boost::range_value<MultiPolygon>::type,
-                    Closure,
                     Strategy
                 >
         >
@@ -126,10 +124,9 @@ template
 <
     typename MultiPoint,
     typename Point,
-    closure_selector Closure,
     typename Strategy
 >
-struct centroid<multi_point_tag, MultiPoint, Point, Closure, Strategy>
+struct centroid<multi_point_tag, MultiPoint, Point,  Strategy>
     : detail::centroid::centroid_multi
         <
             MultiPoint,
diff --git a/include/boost/geometry/multi/algorithms/within.hpp b/include/boost/geometry/multi/algorithms/within.hpp
index da74def93..438ba337a 100644
--- a/include/boost/geometry/multi/algorithms/within.hpp
+++ b/include/boost/geometry/multi/algorithms/within.hpp
@@ -71,6 +71,8 @@ struct within<point_tag, multi_polygon_tag, Point, MultiPolygon, Strategy>
                     <
                         Point,
                         typename boost::range_value<MultiPolygon>::type,
+                        order_as_direction<geometry::point_order<MultiPolygon>::value>::value,
+                        geometry::closure<MultiPolygon>::value,
                         Strategy
                     >
         >
diff --git a/test/algorithms/test_within.hpp b/test/algorithms/test_within.hpp
index 0c24d35b2..cfbd0a87a 100644
--- a/test/algorithms/test_within.hpp
+++ b/test/algorithms/test_within.hpp
@@ -24,13 +24,14 @@ template <typename Geometry1, typename Geometry2>
 void test_geometry(std::string const& wkt1,
         std::string const& wkt2, bool expected)
 {
+    namespace bg = boost::geometry;
     Geometry1 geometry1;
     Geometry2 geometry2;
 
-    boost::geometry::read_wkt(wkt1, geometry1);
-    boost::geometry::read_wkt(wkt2, geometry2);
+    bg::read_wkt(wkt1, geometry1);
+    bg::read_wkt(wkt2, geometry2);
 
-    bool detected = boost::geometry::within(geometry1, geometry2);
+    bool detected = bg::within(geometry1, geometry2);
 
     BOOST_CHECK_MESSAGE(detected == expected,
         "within: " << wkt1
@@ -40,53 +41,68 @@ void test_geometry(std::string const& wkt1,
 }
 
 
-template <typename Point, bool CW>
+template <typename Point, bool Clockwise, bool Closed>
 void test_ordered_ring(std::string const& wkt_point,
         std::string const& wkt_geometry, bool expected, bool on_border)
 {
-    typedef boost::geometry::linear_ring<Point, std::vector, CW> ring_type;
+    namespace bg = boost::geometry;
+    typedef bg::linear_ring<Point, std::vector, Clockwise, Closed> ring_type;
     ring_type ring;
     Point point;
 
-    boost::geometry::read_wkt(wkt_geometry, ring);
-    if (! CW)
+    bg::read_wkt(wkt_geometry, ring);
+    if (! Clockwise)
     {
         std::reverse(boost::begin(ring), boost::end(ring));
     }
-    boost::geometry::read_wkt(wkt_point, point);
+    if (! Closed)
+    {
+        ring.resize(ring.size() - 1);
+    }
 
-    bool detected = boost::geometry::within(point, ring);
+    bg::read_wkt(wkt_point, point);
+
+    bool detected = bg::within(point, ring);
 
     BOOST_CHECK_MESSAGE(detected == expected,
         "within: " << wkt_point
         << " in " << wkt_geometry
         << " -> Expected: " << expected
-        << " detected: " << detected);
+        << " detected: " << detected
+        << " clockwise: " << int(Clockwise)
+        << " closed: " << int(Closed)
+        );
 
     // other strategy (note that this one cannot detect OnBorder
     // (without modifications)
 
-    boost::geometry::strategy::within::franklin<Point> franklin;
-    detected = boost::geometry::within(point, ring, franklin);
+    bg::strategy::within::franklin<Point> franklin;
+    detected = bg::within(point, ring, franklin);
     if (! on_border)
     {
         BOOST_CHECK_MESSAGE(detected == expected,
             "within: " << wkt_point
             << " in " << wkt_geometry
             << " -> Expected: " << expected
-            << " detected: " << detected);
+            << " detected: " << detected
+            << " clockwise: " << int(Clockwise)
+            << " closed: " << int(Closed)
+            );
     }
 
 
-    boost::geometry::strategy::within::crossings_multiply<Point> cm;
-    detected = boost::geometry::within(point, ring, cm);
+    bg::strategy::within::crossings_multiply<Point> cm;
+    detected = bg::within(point, ring, cm);
     if (! on_border)
     {
         BOOST_CHECK_MESSAGE(detected == expected,
             "within: " << wkt_point
             << " in " << wkt_geometry
             << " -> Expected: " << expected
-            << " detected: " << detected);
+            << " detected: " << detected
+            << " clockwise: " << int(Clockwise)
+            << " closed: " << int(Closed)
+            );
     }
 }
 
@@ -95,8 +111,10 @@ void test_ring(std::string const& wkt_point,
         std::string const& wkt_geometry,
         bool expected, bool on_border)
 {
-    test_ordered_ring<Point, true>(wkt_point, wkt_geometry, expected, on_border);
-    test_ordered_ring<Point, false>(wkt_point, wkt_geometry, expected, on_border);
+    test_ordered_ring<Point, true, true>(wkt_point, wkt_geometry, expected, on_border);
+    test_ordered_ring<Point, false, true>(wkt_point, wkt_geometry, expected, on_border);
+    test_ordered_ring<Point, true, false>(wkt_point, wkt_geometry, expected, on_border);
+    test_ordered_ring<Point, false, false>(wkt_point, wkt_geometry, expected, on_border);
     test_geometry<Point, boost::geometry::polygon<Point> >(wkt_point, wkt_geometry, expected);
 }
 
diff --git a/test/algorithms/within.cpp b/test/algorithms/within.cpp
index 08d4ab2b7..d3dfca501 100644
--- a/test/algorithms/within.cpp
+++ b/test/algorithms/within.cpp
@@ -77,5 +77,5 @@ int test_main( int , char* [] )
     test_all<boost::geometry::point_xy<boost::numeric_adaptor::gmp_value_type> >();
 #endif
 
-    return 0;
+        return 0;
 }