Imported Upstream version 1.64.0upstream/1.64.0

Change-Id: Id9212edd016dd55f21172c427aa7894d1d24148b
Signed-off-by: DongHun Kwak <dh0128.kwak@samsung.com>

9 files changed, 243 insertions, 102 deletions

diff --git a/boost/geometry/algorithms/detail/is_valid/box.hpp b/boost/geometry/algorithms/detail/is_valid/box.hpp
index 863ce625fe..69a4d4e78e 100644
--- a/boost/geometry/algorithms/detail/is_valid/box.hpp
+++ b/boost/geometry/algorithms/detail/is_valid/box.hpp
@@ -1,6 +1,6 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
 
 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
@@ -71,8 +71,8 @@ struct has_valid_corners<Box, 0>
 template <typename Box>
 struct is_valid_box
 {
-    template <typename VisitPolicy>
-    static inline bool apply(Box const& box, VisitPolicy& visitor)
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Box const& box, VisitPolicy& visitor, Strategy const&)
     {
         return
             ! has_invalid_coordinate<Box>::apply(box, visitor)
diff --git a/boost/geometry/algorithms/detail/is_valid/has_valid_self_turns.hpp b/boost/geometry/algorithms/detail/is_valid/has_valid_self_turns.hpp
index 0a81213743..b91dc6a697 100644
--- a/boost/geometry/algorithms/detail/is_valid/has_valid_self_turns.hpp
+++ b/boost/geometry/algorithms/detail/is_valid/has_valid_self_turns.hpp
@@ -1,8 +1,9 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
 
 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
 
 // Licensed under the Boost Software License version 1.0.
 // http://www.boost.org/users/license.html
@@ -69,10 +70,11 @@ public:
         > turn_type;
 
     // returns true if all turns are valid
-    template <typename Turns, typename VisitPolicy>
+    template <typename Turns, typename VisitPolicy, typename Strategy>
     static inline bool apply(Geometry const& geometry,
                              Turns& turns,
-                             VisitPolicy& visitor)
+                             VisitPolicy& visitor,
+                             Strategy const& strategy)
     {
         boost::ignore_unused(visitor);
 
@@ -85,6 +87,7 @@ public:
             > interrupt_policy;
 
         geometry::self_turns<turn_policy>(geometry,
+                                          strategy,
                                           robust_policy,
                                           turns,
                                           interrupt_policy);
@@ -101,11 +104,11 @@ public:
     }
 
     // returns true if all turns are valid
-    template <typename VisitPolicy>
-    static inline bool apply(Geometry const& geometry, VisitPolicy& visitor)
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Geometry const& geometry, VisitPolicy& visitor, Strategy const& strategy)
     {
         std::vector<turn_type> turns;
-        return apply(geometry, turns, visitor);
+        return apply(geometry, turns, visitor, strategy);
     }
 };
 
diff --git a/boost/geometry/algorithms/detail/is_valid/interface.hpp b/boost/geometry/algorithms/detail/is_valid/interface.hpp
index 5a04a92824..ee013377c4 100644
--- a/boost/geometry/algorithms/detail/is_valid/interface.hpp
+++ b/boost/geometry/algorithms/detail/is_valid/interface.hpp
@@ -1,8 +1,9 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
 
 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
 
 // Licensed under the Boost Software License version 1.0.
 // http://www.boost.org/users/license.html
@@ -23,48 +24,88 @@
 #include <boost/geometry/policies/is_valid/default_policy.hpp>
 #include <boost/geometry/policies/is_valid/failing_reason_policy.hpp>
 #include <boost/geometry/policies/is_valid/failure_type_policy.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/intersection.hpp>
 
 
 namespace boost { namespace geometry
 {
+    
+namespace resolve_strategy
+{
+
+struct is_valid
+{
+    template <typename Geometry, typename VisitPolicy, typename Strategy>
+    static inline bool apply(Geometry const& geometry,
+                             VisitPolicy& visitor,
+                             Strategy const& strategy)
+    {
+        return dispatch::is_valid<Geometry>::apply(geometry, visitor, strategy);
+    }
+
+    template <typename Geometry, typename VisitPolicy>
+    static inline bool apply(Geometry const& geometry,
+                             VisitPolicy& visitor,
+                             default_strategy)
+    {
+        // NOTE: Currently the strategy is only used for Areal geometries
+        typedef typename strategy::intersection::services::default_strategy
+            <
+                typename cs_tag<Geometry>::type
+            >::type strategy_type;
+
+        return dispatch::is_valid<Geometry>::apply(geometry, visitor, strategy_type());
+    }
+};
 
+} // namespace resolve_strategy
 
-namespace resolve_variant {
+namespace resolve_variant
+{
 
 template <typename Geometry>
 struct is_valid
 {
-    template <typename VisitPolicy>
-    static inline bool apply(Geometry const& geometry, VisitPolicy& visitor)
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Geometry const& geometry,
+                             VisitPolicy& visitor,
+                             Strategy const& strategy)
     {
         concepts::check<Geometry const>();
-        return dispatch::is_valid<Geometry>::apply(geometry, visitor);
+
+        return resolve_strategy::is_valid::apply(geometry, visitor, strategy);
     }
 };
 
 template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
 struct is_valid<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
 {
-    template <typename VisitPolicy>
+    template <typename VisitPolicy, typename Strategy>
     struct visitor : boost::static_visitor<bool>
     {
-        visitor(VisitPolicy& policy) : m_policy(policy) {}
+        visitor(VisitPolicy& policy, Strategy const& strategy)
+            : m_policy(policy)
+            , m_strategy(strategy)
+        {}
 
         template <typename Geometry>
         bool operator()(Geometry const& geometry) const
         {
-            return is_valid<Geometry>::apply(geometry, m_policy);
+            return is_valid<Geometry>::apply(geometry, m_policy, m_strategy);
         }
 
         VisitPolicy& m_policy;
+        Strategy const& m_strategy;
     };
 
-    template <typename VisitPolicy>
+    template <typename VisitPolicy, typename Strategy>
     static inline bool
     apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
-          VisitPolicy& policy_visitor)
+          VisitPolicy& policy_visitor,
+          Strategy const& strategy)
     {
-        return boost::apply_visitor(visitor<VisitPolicy>(policy_visitor),
+        return boost::apply_visitor(visitor<VisitPolicy, Strategy>(policy_visitor, strategy),
                                     geometry);
     }
 };
@@ -73,10 +114,12 @@ struct is_valid<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
 
 
 // Undocumented for now
-template <typename Geometry, typename VisitPolicy>
-inline bool is_valid(Geometry const& geometry, VisitPolicy& visitor)
+template <typename Geometry, typename VisitPolicy, typename Strategy>
+inline bool is_valid(Geometry const& geometry,
+                     VisitPolicy& visitor,
+                     Strategy const& strategy)
 {
-    return resolve_variant::is_valid<Geometry>::apply(geometry, visitor);
+    return resolve_variant::is_valid<Geometry>::apply(geometry, visitor, strategy);
 }
 
 
@@ -84,6 +127,29 @@ inline bool is_valid(Geometry const& geometry, VisitPolicy& visitor)
 \brief \brief_check{is valid (in the OGC sense)}
 \ingroup is_valid
 \tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{Is_valid}
+\param geometry \param_geometry
+\param strategy \param_strategy{is_valid}
+\return \return_check{is valid (in the OGC sense);
+furthermore, the following geometries are considered valid:
+multi-geometries with no elements,
+linear geometries containing spikes,
+areal geometries with duplicate (consecutive) points}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/is_valid.qbk]}
+*/
+template <typename Geometry, typename Strategy>
+inline bool is_valid(Geometry const& geometry, Strategy const& strategy)
+{
+    is_valid_default_policy<> visitor;
+    return resolve_variant::is_valid<Geometry>::apply(geometry, visitor, strategy);
+}
+
+/*!
+\brief \brief_check{is valid (in the OGC sense)}
+\ingroup is_valid
+\tparam Geometry \tparam_geometry
 \param geometry \param_geometry
 \return \return_check{is valid (in the OGC sense);
     furthermore, the following geometries are considered valid:
@@ -96,8 +162,7 @@ inline bool is_valid(Geometry const& geometry, VisitPolicy& visitor)
 template <typename Geometry>
 inline bool is_valid(Geometry const& geometry)
 {
-    is_valid_default_policy<> policy_visitor;
-    return geometry::is_valid(geometry, policy_visitor);
+    return is_valid(geometry, default_strategy());
 }
 
 
@@ -105,6 +170,33 @@ inline bool is_valid(Geometry const& geometry)
 \brief \brief_check{is valid (in the OGC sense)}
 \ingroup is_valid
 \tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{Is_valid}
+\param geometry \param_geometry
+\param failure An enumeration value indicating that the geometry is
+    valid or not, and if not valid indicating the reason why
+\param strategy \param_strategy{is_valid}
+\return \return_check{is valid (in the OGC sense);
+    furthermore, the following geometries are considered valid:
+    multi-geometries with no elements,
+    linear geometries containing spikes,
+    areal geometries with duplicate (consecutive) points}
+
+\qbk{distinguish,with failure value and strategy}
+\qbk{[include reference/algorithms/is_valid_with_failure.qbk]}
+*/
+template <typename Geometry, typename Strategy>
+inline bool is_valid(Geometry const& geometry, validity_failure_type& failure, Strategy const& strategy)
+{
+    failure_type_policy<> visitor;
+    bool result = resolve_variant::is_valid<Geometry>::apply(geometry, visitor, strategy);
+    failure = visitor.failure();
+    return result;
+}
+
+/*!
+\brief \brief_check{is valid (in the OGC sense)}
+\ingroup is_valid
+\tparam Geometry \tparam_geometry
 \param geometry \param_geometry
 \param failure An enumeration value indicating that the geometry is
     valid or not, and if not valid indicating the reason why
@@ -120,10 +212,7 @@ inline bool is_valid(Geometry const& geometry)
 template <typename Geometry>
 inline bool is_valid(Geometry const& geometry, validity_failure_type& failure)
 {
-    failure_type_policy<> policy_visitor;
-    bool result = geometry::is_valid(geometry, policy_visitor);
-    failure = policy_visitor.failure();
-    return result;
+    return is_valid(geometry, failure, default_strategy());
 }
 
 
@@ -131,28 +220,52 @@ inline bool is_valid(Geometry const& geometry, validity_failure_type& failure)
 \brief \brief_check{is valid (in the OGC sense)}
 \ingroup is_valid
 \tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{Is_valid}
 \param geometry \param_geometry
 \param message A string containing a message stating if the geometry
     is valid or not, and if not valid a reason why
+\param strategy \param_strategy{is_valid}
 \return \return_check{is valid (in the OGC sense);
     furthermore, the following geometries are considered valid:
     multi-geometries with no elements,
     linear geometries containing spikes,
     areal geometries with duplicate (consecutive) points}
 
-\qbk{distinguish,with message}
+\qbk{distinguish,with message and strategy}
 \qbk{[include reference/algorithms/is_valid_with_message.qbk]}
 */
-template <typename Geometry>
-inline bool is_valid(Geometry const& geometry, std::string& message)
+template <typename Geometry, typename Strategy>
+inline bool is_valid(Geometry const& geometry, std::string& message, Strategy const& strategy)
 {
     std::ostringstream stream;
-    failing_reason_policy<> policy_visitor(stream);
-    bool result = geometry::is_valid(geometry, policy_visitor);
+    failing_reason_policy<> visitor(stream);
+    bool result = resolve_variant::is_valid<Geometry>::apply(geometry, visitor, strategy);
     message = stream.str();
     return result;
 }
 
+/*!
+\brief \brief_check{is valid (in the OGC sense)}
+\ingroup is_valid
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\param message A string containing a message stating if the geometry
+    is valid or not, and if not valid a reason why
+\return \return_check{is valid (in the OGC sense);
+    furthermore, the following geometries are considered valid:
+    multi-geometries with no elements,
+    linear geometries containing spikes,
+    areal geometries with duplicate (consecutive) points}
+
+\qbk{distinguish,with message}
+\qbk{[include reference/algorithms/is_valid_with_message.qbk]}
+*/
+template <typename Geometry>
+inline bool is_valid(Geometry const& geometry, std::string& message)
+{
+    return is_valid(geometry, message, default_strategy());
+}
+
 
 }} // namespace boost::geometry
 
diff --git a/boost/geometry/algorithms/detail/is_valid/linear.hpp b/boost/geometry/algorithms/detail/is_valid/linear.hpp
index a49e077237..6bc6b86cf8 100644
--- a/boost/geometry/algorithms/detail/is_valid/linear.hpp
+++ b/boost/geometry/algorithms/detail/is_valid/linear.hpp
@@ -1,6 +1,6 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
 
 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
@@ -77,6 +77,14 @@ struct is_valid_linestring
         }
         return ! has_spikes<Linestring, closed>::apply(linestring, visitor);
     }
+
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Linestring const& linestring,
+                             VisitPolicy& visitor,
+                             Strategy const&)
+    {
+        return apply(linestring, visitor);
+    }
 };
 
 
@@ -142,9 +150,10 @@ private:
     };
 
 public:
-    template <typename VisitPolicy>
+    template <typename VisitPolicy, typename Strategy>
     static inline bool apply(MultiLinestring const& multilinestring,
-                             VisitPolicy& visitor)
+                             VisitPolicy& visitor,
+                             Strategy const&)
     {
         if (BOOST_GEOMETRY_CONDITION(
                 AllowEmptyMultiGeometries && boost::empty(multilinestring)))
diff --git a/boost/geometry/algorithms/detail/is_valid/multipolygon.hpp b/boost/geometry/algorithms/detail/is_valid/multipolygon.hpp
index 0025445c2c..84dacc57f1 100644
--- a/boost/geometry/algorithms/detail/is_valid/multipolygon.hpp
+++ b/boost/geometry/algorithms/detail/is_valid/multipolygon.hpp
@@ -1,6 +1,6 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
 
 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
@@ -43,6 +43,8 @@
 
 #include <boost/geometry/algorithms/dispatch/is_valid.hpp>
 
+#include <boost/geometry/strategies/intersection.hpp>
+
 
 namespace boost { namespace geometry
 {
@@ -109,10 +111,10 @@ private:
 
         geometry::partition
             <
-                geometry::model::box<typename point_type<MultiPolygon>::type>,
-                typename base::expand_box,
-                typename base::overlaps_box
-            >::apply(polygon_iterators, item_visitor);
+                geometry::model::box<typename point_type<MultiPolygon>::type>
+            >::apply(polygon_iterators, item_visitor,
+                     typename base::expand_box(),
+                     typename base::overlaps_box());
 
         if (item_visitor.items_overlap)
         {
@@ -235,23 +237,28 @@ private:
     }
 
 
-    template <typename VisitPolicy>
+    template <typename VisitPolicy, typename Strategy>
     struct per_polygon
     {
-        per_polygon(VisitPolicy& policy) : m_policy(policy) {}
+        per_polygon(VisitPolicy& policy, Strategy const& strategy)
+            : m_policy(policy)
+            , m_strategy(strategy)
+        {}
 
         template <typename Polygon>
         inline bool apply(Polygon const& polygon) const
         {
-            return base::apply(polygon, m_policy);
+            return base::apply(polygon, m_policy, m_strategy);
         }
 
         VisitPolicy& m_policy;
+        Strategy const& m_strategy;
     };
 public:
-    template <typename VisitPolicy>
+    template <typename VisitPolicy, typename Strategy>
     static inline bool apply(MultiPolygon const& multipolygon,
-                             VisitPolicy& visitor)
+                             VisitPolicy& visitor,
+                             Strategy const& strategy)
     {
         typedef debug_validity_phase<MultiPolygon> debug_phase;
 
@@ -266,11 +273,11 @@ public:
 
         if (! detail::check_iterator_range
                   <
-                      per_polygon<VisitPolicy>,
+                      per_polygon<VisitPolicy, Strategy>,
                       false // do not check for empty multipolygon (done above)
                   >::apply(boost::begin(multipolygon),
                            boost::end(multipolygon),
-                           per_polygon<VisitPolicy>(visitor)))
+                           per_polygon<VisitPolicy, Strategy>(visitor, strategy)))
         {
             return false;
         }
@@ -283,7 +290,7 @@ public:
 
         std::deque<typename has_valid_turns::turn_type> turns;
         bool has_invalid_turns =
-            ! has_valid_turns::apply(multipolygon, turns, visitor);
+            ! has_valid_turns::apply(multipolygon, turns, visitor, strategy);
         debug_print_turns(turns.begin(), turns.end());
 
         if (has_invalid_turns)
diff --git a/boost/geometry/algorithms/detail/is_valid/pointlike.hpp b/boost/geometry/algorithms/detail/is_valid/pointlike.hpp
index 51035f7a73..f77f7a35eb 100644
--- a/boost/geometry/algorithms/detail/is_valid/pointlike.hpp
+++ b/boost/geometry/algorithms/detail/is_valid/pointlike.hpp
@@ -1,6 +1,6 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
 
 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
@@ -36,8 +36,8 @@ namespace dispatch
 template <typename Point>
 struct is_valid<Point, point_tag>
 {
-    template <typename VisitPolicy>
-    static inline bool apply(Point const& point, VisitPolicy& visitor)
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Point const& point, VisitPolicy& visitor, Strategy const&)
     {
         boost::ignore_unused(visitor);
         return ! detail::is_valid::has_invalid_coordinate
@@ -56,9 +56,10 @@ struct is_valid<Point, point_tag>
 template <typename MultiPoint, bool AllowEmptyMultiGeometries>
 struct is_valid<MultiPoint, multi_point_tag, AllowEmptyMultiGeometries>
 {
-    template <typename VisitPolicy>
+    template <typename VisitPolicy, typename Strategy>
     static inline bool apply(MultiPoint const& multipoint,
-                             VisitPolicy& visitor)
+                             VisitPolicy& visitor,
+                             Strategy const&)
     {
         boost::ignore_unused(multipoint, visitor);
 
diff --git a/boost/geometry/algorithms/detail/is_valid/polygon.hpp b/boost/geometry/algorithms/detail/is_valid/polygon.hpp
index bbe8e8fc39..f7e22fb8d2 100644
--- a/boost/geometry/algorithms/detail/is_valid/polygon.hpp
+++ b/boost/geometry/algorithms/detail/is_valid/polygon.hpp
@@ -1,8 +1,9 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
 
 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
 
 // Licensed under the Boost Software License version 1.0.
 // http://www.boost.org/users/license.html
@@ -74,10 +75,13 @@ class is_valid_polygon
 protected:
     typedef debug_validity_phase<Polygon> debug_phase;
 
-    template <typename VisitPolicy>
+    template <typename VisitPolicy, typename Strategy>
     struct per_ring
     {
-        per_ring(VisitPolicy& policy) : m_policy(policy) {}
+        per_ring(VisitPolicy& policy, Strategy const& strategy)
+            : m_policy(policy)
+            , m_strategy(strategy)
+        {}
 
         template <typename Ring>
         inline bool apply(Ring const& ring) const
@@ -85,30 +89,34 @@ protected:
             return detail::is_valid::is_valid_ring
                 <
                     Ring, false, true
-                >::apply(ring, m_policy);
+                >::apply(ring, m_policy, m_strategy);
         }
 
         VisitPolicy& m_policy;
+        Strategy const& m_strategy;
     };
 
-    template <typename InteriorRings, typename VisitPolicy>
+    template <typename InteriorRings, typename VisitPolicy, typename Strategy>
     static bool has_valid_interior_rings(InteriorRings const& interior_rings,
-                                         VisitPolicy& visitor)
+                                         VisitPolicy& visitor,
+                                         Strategy const& strategy)
     {
         return
             detail::check_iterator_range
                 <
-                    per_ring<VisitPolicy>,
+                    per_ring<VisitPolicy, Strategy>,
                     true // allow for empty interior ring range
                 >::apply(boost::begin(interior_rings),
                          boost::end(interior_rings),
-                         per_ring<VisitPolicy>(visitor));
+                         per_ring<VisitPolicy, Strategy>(visitor, strategy));
     }
 
     struct has_valid_rings
     {
-        template <typename VisitPolicy>
-        static inline bool apply(Polygon const& polygon, VisitPolicy& visitor)
+        template <typename VisitPolicy, typename Strategy>
+        static inline bool apply(Polygon const& polygon,
+                                 VisitPolicy& visitor,
+                                 Strategy const& strategy)
         {
             typedef typename ring_type<Polygon>::type ring_type;
 
@@ -119,7 +127,7 @@ protected:
                      <
                          ring_type,
                          false // do not check self intersections
-                     >::apply(exterior_ring(polygon), visitor))
+                     >::apply(exterior_ring(polygon), visitor, strategy))
             {
                 return false;
             }
@@ -128,7 +136,8 @@ protected:
             debug_phase::apply(2);
 
             return has_valid_interior_rings(geometry::interior_rings(polygon),
-                                            visitor);
+                                            visitor,
+                                            strategy);
         }
     };
 
@@ -246,10 +255,8 @@ protected:
 
         geometry::partition
             <
-                geometry::model::box<typename point_type<Polygon>::type>,
-                expand_box,
-                overlaps_box
-            >::apply(ring_iterators, item_visitor);
+                geometry::model::box<typename point_type<Polygon>::type>
+            >::apply(ring_iterators, item_visitor, expand_box(), overlaps_box());
 
         if (item_visitor.items_overlap)
         {
@@ -346,10 +353,12 @@ protected:
     };
 
 public:
-    template <typename VisitPolicy>
-    static inline bool apply(Polygon const& polygon, VisitPolicy& visitor)
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Polygon const& polygon,
+                             VisitPolicy& visitor,
+                             Strategy const& strategy)
     {
-        if (! has_valid_rings::apply(polygon, visitor))
+        if (! has_valid_rings::apply(polygon, visitor, strategy))
         {
             return false;
         }
@@ -366,7 +375,7 @@ public:
 
         std::deque<typename has_valid_turns::turn_type> turns;
         bool has_invalid_turns
-            = ! has_valid_turns::apply(polygon, turns, visitor);
+            = ! has_valid_turns::apply(polygon, turns, visitor, strategy);
         debug_print_turns(turns.begin(), turns.end());
 
         if (has_invalid_turns)
diff --git a/boost/geometry/algorithms/detail/is_valid/ring.hpp b/boost/geometry/algorithms/detail/is_valid/ring.hpp
index 925c03a472..9ab68fdc48 100644
--- a/boost/geometry/algorithms/detail/is_valid/ring.hpp
+++ b/boost/geometry/algorithms/detail/is_valid/ring.hpp
@@ -1,6 +1,6 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
 
 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
@@ -101,26 +101,21 @@ struct ring_area_predicate<ResultType, true>
 template <typename Ring, bool IsInteriorRing>
 struct is_properly_oriented
 {
-    typedef typename point_type<Ring>::type point_type;
-
-    typedef typename strategy::area::services::default_strategy
-        <
-            typename cs_tag<point_type>::type,
-            point_type
-        >::type strategy_type;
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Ring const& ring, VisitPolicy& visitor,
+                             Strategy const& strategy)
+    {
+        boost::ignore_unused(visitor);
 
-    typedef detail::area::ring_area
-        <
-            order_as_direction<geometry::point_order<Ring>::value>::value,
-            geometry::closure<Ring>::value
-        > ring_area_type;
+        typedef typename point_type<Ring>::type point_type;
 
-    typedef typename default_area_result<Ring>::type area_result_type;
+        typedef detail::area::ring_area
+            <
+                order_as_direction<geometry::point_order<Ring>::value>::value,
+                geometry::closure<Ring>::value
+            > ring_area_type;
 
-    template <typename VisitPolicy>
-    static inline bool apply(Ring const& ring, VisitPolicy& visitor)
-    {
-        boost::ignore_unused(visitor);
+        typedef typename default_area_result<Ring>::type area_result_type;
 
         typename ring_area_predicate
             <
@@ -128,8 +123,11 @@ struct is_properly_oriented
             >::type predicate;
 
         // Check area
-        area_result_type const zero = area_result_type();
-        if (predicate(ring_area_type::apply(ring, strategy_type()), zero))
+        area_result_type const zero = 0;
+        area_result_type const area
+            = ring_area_type::apply(ring,
+                                    strategy.template get_area_strategy<point_type>());
+        if (predicate(area, zero))
         {
             return visitor.template apply<no_failure>();
         }
@@ -150,8 +148,9 @@ template
 >
 struct is_valid_ring
 {
-    template <typename VisitPolicy>
-    static inline bool apply(Ring const& ring, VisitPolicy& visitor)
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Ring const& ring, VisitPolicy& visitor,
+                             Strategy const& strategy)
     {
         // return invalid if any of the following condition holds:
         // (a) the ring's point coordinates are not invalid (e.g., NaN)
@@ -198,8 +197,8 @@ struct is_valid_ring
             && ! has_duplicates<Ring, closure>::apply(ring, visitor)
             && ! has_spikes<Ring, closure>::apply(ring, visitor)
             && (! CheckSelfIntersections
-                || has_valid_self_turns<Ring>::apply(ring, visitor))
-            && is_properly_oriented<Ring, IsInteriorRing>::apply(ring, visitor);
+                || has_valid_self_turns<Ring>::apply(ring, visitor, strategy))
+            && is_properly_oriented<Ring, IsInteriorRing>::apply(ring, visitor, strategy);
     }
 };
 
diff --git a/boost/geometry/algorithms/detail/is_valid/segment.hpp b/boost/geometry/algorithms/detail/is_valid/segment.hpp
index f92f73381f..30cbf7afdb 100644
--- a/boost/geometry/algorithms/detail/is_valid/segment.hpp
+++ b/boost/geometry/algorithms/detail/is_valid/segment.hpp
@@ -1,6 +1,6 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
 
 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
@@ -44,8 +44,8 @@ namespace dispatch
 template <typename Segment>
 struct is_valid<Segment, segment_tag>
 {
-    template <typename VisitPolicy>
-    static inline bool apply(Segment const& segment, VisitPolicy& visitor)
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Segment const& segment, VisitPolicy& visitor, Strategy const&)
     {
         boost::ignore_unused(visitor);