[Boost-commit] svn:boost r73177 - in trunk/boost/geometry: algorithms core multi/algorithms multi/core strategies strategies/agnostic strategies/cartesian strategies/concepts util

Subject: [Boost-commit] svn:boost r73177 - in trunk/boost/geometry: algorithms core multi/algorithms multi/core strategies strategies/agnostic strategies/cartesian strategies/concepts util
From: barend.gehrels_at_[hidden]
Date: 2011-07-17 08:26:03

Author: barendgehrels
Date: 2011-07-17 08:26:01 EDT (Sun, 17 Jul 2011)
New Revision: 73177
URL: http://svn.boost.org/trac/boost/changeset/73177

Log:
Added a "covered_by" algorithm (= within or on border)
Revised point-in-box, box-in-box, now with strategies
Therefore, revised within strategy.
Also adapted concept for within, and refactored getting parameters into parameter_type_of (also used by distance concept)
To avoid specifying default strategies again and again for all spherical coordinate systems, used the spherical_tag as the parent for spherical_polar_tag, spherical_equatorial_tag, geographic_tag

Added:
   trunk/boost/geometry/algorithms/covered_by.hpp   (contents, props changed)
   trunk/boost/geometry/multi/algorithms/covered_by.hpp   (contents, props changed)
   trunk/boost/geometry/strategies/agnostic/point_in_box_by_side.hpp   (contents, props changed)
   trunk/boost/geometry/strategies/cartesian/box_in_box.hpp   (contents, props changed)
   trunk/boost/geometry/strategies/cartesian/point_in_box.hpp   (contents, props changed)
   trunk/boost/geometry/strategies/covered_by.hpp   (contents, props changed)
   trunk/boost/geometry/util/parameter_type_of.hpp   (contents, props changed)
Text files modified: 
   trunk/boost/geometry/algorithms/within.hpp                         |   410 ++++++++------------------------------- 
   trunk/boost/geometry/core/tags.hpp                                 |    16 +                                       
   trunk/boost/geometry/multi/algorithms/within.hpp                   |    43 ++-                                     
   trunk/boost/geometry/multi/core/tags.hpp                           |     2                                         
   trunk/boost/geometry/strategies/agnostic/point_in_poly_winding.hpp |    41 ++-                                     
   trunk/boost/geometry/strategies/concepts/distance_concept.hpp      |    75 ------                                  
   trunk/boost/geometry/strategies/concepts/within_concept.hpp        |   255 ++++++++++++++++++++++--                
   trunk/boost/geometry/strategies/strategies.hpp                     |     3                                         
   trunk/boost/geometry/strategies/within.hpp                         |    23 +                                       
   9 files changed, 416 insertions(+), 452 deletions(-)

Added: trunk/boost/geometry/algorithms/covered_by.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/geometry/algorithms/covered_by.hpp	2011-07-17 08:26:01 EDT (Sun, 17 Jul 2011)
@@ -0,0 +1,206 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2011 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2011 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2011 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_COVERED_BY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_COVERED_BY_HPP
+
+
+#include <cstddef>
+
+
+#include <boost/geometry/algorithms/within.hpp>
+
+
+#include <boost/geometry/strategies/cartesian/point_in_box.hpp>
+#include <boost/geometry/strategies/cartesian/box_in_box.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Tag1,
+    typename Tag2,
+    typename Geometry1,
+    typename Geometry2,
+    typename Strategy
+>
+struct covered_by
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_OR_NOT_YET_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<Geometry1, Geometry2>)
+        );
+};
+
+
+template <typename Point, typename Box, typename Strategy>
+struct covered_by<point_tag, box_tag, Point, Box, Strategy>
+{
+    static inline bool apply(Point const& point, Box const& box, Strategy const& strategy)
+    {
+        return strategy.apply(point, box);
+    }
+};
+
+template <typename Box1, typename Box2, typename Strategy>
+struct covered_by<box_tag, box_tag, Box1, Box2, Strategy>
+{
+    static inline bool apply(Box1 const& box1, Box2 const& box2, Strategy const& strategy)
+    {
+        assert_dimension_equal<Box1, Box2>();
+        return strategy.apply(box1, box2);
+    }
+};
+
+
+
+template <typename Point, typename Ring, typename Strategy>
+struct covered_by<point_tag, ring_tag, Point, Ring, Strategy>
+{
+    static inline bool apply(Point const& point, Ring const& ring, Strategy const& strategy)
+    {
+        return detail::within::point_in_ring
+            <
+                Point,
+                Ring,
+                order_as_direction<geometry::point_order<Ring>::value>::value,
+                geometry::closure<Ring>::value,
+                Strategy
+            >::apply(point, ring) >= 0;
+    }
+};
+
+template <typename Point, typename Polygon, typename Strategy>
+struct covered_by<point_tag, polygon_tag, Point, Polygon, Strategy>
+{
+    static inline bool apply(Point const& point, Polygon const& polygon, Strategy const& strategy)
+    {
+        return detail::within::point_in_polygon
+        <
+            Point,
+            Polygon,
+            order_as_direction<geometry::point_order<Polygon>::value>::value,
+            geometry::closure<Polygon>::value,
+            Strategy
+        >::apply(point, polygon, strategy) >= 0;
+    }
+};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+/*!
+\brief \brief_check12{is inside or on border}
+\ingroup covered_by
+\details \details_check12{covered_by, is inside or on border}.
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param geometry1 geometry which might be covered_by the second geometry
+\param geometry2 geometry which might contain the first geometry
+\return true if geometry1 is completely contained covered_by geometry2,
+    else false
+\note The default strategy is used for covered_by detection
+
+ */
+template<typename Geometry1, typename Geometry2>
+inline bool covered_by(Geometry1 const& geometry1, Geometry2 const& geometry2)
+{
+    concept::check<Geometry1 const>();
+    concept::check<Geometry2 const>();
+    assert_dimension_equal<Geometry1, Geometry2>();
+
+    typedef typename point_type<Geometry1>::type point_type1;
+    typedef typename point_type<Geometry2>::type point_type2;
+
+    typedef typename strategy::covered_by::services::default_strategy
+        <
+            typename tag<Geometry1>::type,
+            typename tag<Geometry2>::type,
+            typename tag<Geometry1>::type,
+            typename tag_cast<typename tag<Geometry2>::type, areal_tag>::type,
+            typename tag_cast
+                <
+                    typename cs_tag<point_type1>::type, spherical_tag
+                >::type,
+            typename tag_cast
+                <
+                    typename cs_tag<point_type2>::type, spherical_tag
+                >::type,
+            Geometry1,
+            Geometry2
+        >::type strategy_type;
+
+    return dispatch::covered_by
+        <
+            typename tag<Geometry1>::type,
+            typename tag<Geometry2>::type,
+            Geometry1,
+            Geometry2,
+            strategy_type
+        >::apply(geometry1, geometry2, strategy_type());
+}
+
+/*!
+\brief \brief_check12{is inside or on border} \brief_strategy
+\ingroup covered_by
+\details \details_check12{covered_by, is inside or on border}, \brief_strategy. \details_strategy_reasons
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param geometry1 \param_geometry geometry which might be covered_by the second geometry
+\param geometry2 \param_geometry which might contain the first geometry
+\param strategy strategy to be used
+\return true if geometry1 is completely contained covered_by geometry2,
+    else false
+
+\qbk{distinguish,with strategy}
+
+*/
+template<typename Geometry1, typename Geometry2, typename Strategy>
+inline bool covered_by(Geometry1 const& geometry1, Geometry2 const& geometry2,
+        Strategy const& strategy)
+{
+	concept::within::check
+        <
+            typename tag<Geometry1>::type, 
+            typename tag<Geometry2>::type, 
+            typename tag_cast<typename tag<Geometry2>::type, areal_tag>::type,
+            Strategy
+        >();
+    concept::check<Geometry1 const>();
+    concept::check<Geometry2 const>();
+    assert_dimension_equal<Geometry1, Geometry2>();
+
+    return dispatch::covered_by
+        <
+            typename tag<Geometry1>::type,
+            typename tag<Geometry2>::type,
+            Geometry1,
+            Geometry2,
+            Strategy
+        >::apply(geometry1, geometry2, strategy);
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_COVERED_BY_HPP

Modified: trunk/boost/geometry/algorithms/within.hpp
==============================================================================
--- trunk/boost/geometry/algorithms/within.hpp	(original)
+++ trunk/boost/geometry/algorithms/within.hpp	2011-07-17 08:26:01 EDT (Sun, 17 Jul 2011)
@@ -31,6 +31,7 @@
 #include <boost/geometry/core/point_order.hpp>
 #include <boost/geometry/core/ring_type.hpp>
 #include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/tags.hpp>
 
 #include <boost/geometry/geometries/concepts/check.hpp>
 #include <boost/geometry/strategies/within.hpp>
@@ -49,201 +50,6 @@
 {
 
 
-struct within_state
-{
-    bool outside, inside, on_border;
-    inline within_state()
-        : outside(false)
-        , on_border(false)
-    {}
-
-    inline int code() const
-    {
-        // Note the order: 1) outside 2) on_border 3) inside
-        // If one dim. is outside, it IS outside, else
-        // if one dim is on border, it IS on border,
-        // if it only inside if inside=true and the rest is false
-        return outside ? -1
-            : on_border ? 0
-            : 1
-            ;
-    }
-
-};
-
-/*!
-    \brief Implementation for boxes
-    \ingroup boolean_relations
-    \note Should have strategy for e.g. Wrangel
- */
-template
-<
-    typename Point,
-    typename Box,
-    typename Strategy,
-    std::size_t Dimension,
-    std::size_t DimensionCount
->
-struct point_in_box_helper
-{
-    static inline void apply(Point const& p, Box const& b, Strategy const& s, within_state& state)
-    {
-        typename geometry::coordinate_type<Point>::type const v
-                    = get<Dimension>(p);
-        typename geometry::coordinate_type<Box>::type const b_min
-                    = get<min_corner, Dimension>(b);
-        typename geometry::coordinate_type<Box>::type const b_max
-                    = get<max_corner, Dimension>(b);
-                    
-        if (geometry::math::equals(v, b_min) 
-                || geometry::math::equals(v, b_max))
-        {
-            state.on_border = true;
-        }
-        else if (v < b_min || v > b_max)
-        {
-            state.outside = true;
-            return;
-        }
-        
-        point_in_box_helper
-            <
-                Point,
-                Box,
-                Strategy,
-                Dimension + 1,
-                DimensionCount
-            >::apply(p, b, s, state);
-    }
-};
-
-template
-<
-    typename Point,
-    typename Box,
-    typename Strategy,
-    std::size_t DimensionCount
->
-struct point_in_box_helper<Point, Box, Strategy, DimensionCount, DimensionCount>
-{
-    static inline void apply(Point const& , Box const& , Strategy const&, within_state& )
-    {
-    }
-};
-
-template
-<
-    typename Point,
-    typename Box,
-    typename Strategy
->
-struct point_in_box
-{
-    static inline int apply(Point const& point, Box const& box, Strategy const& strategy)
-    {
-        assert_dimension_equal<Point, Box>();
-        within_state state;
-        point_in_box_helper
-            <
-                Point, Box, Strategy, 
-                0, dimension<Point>::type::value
-            >::apply(point, box, strategy, state);
-        return state.code();
-    }
-};
-
-
-template
-<
-    typename Box1,
-    typename Box2,
-    typename Strategy,
-    std::size_t Dimension,
-    std::size_t DimensionCount
->
-struct box_in_box_helper
-{
-    static inline void apply(Box1 const& b_contained, Box2 const& b_containing,
-                Strategy const& strategy, within_state& state)
-    {
-        assert_dimension_equal<Box1, Box2>();
-
-        typename geometry::coordinate_type<Box1>::type const ced_min
-                    = get<min_corner, Dimension>(b_contained);
-        typename geometry::coordinate_type<Box1>::type const ced_max
-                    = get<max_corner, Dimension>(b_contained);
-        typename geometry::coordinate_type<Box2>::type const cing_min
-                    = get<min_corner, Dimension>(b_containing);
-        typename geometry::coordinate_type<Box2>::type const cing_max
-                    = get<max_corner, Dimension>(b_containing);
-
-        if (geometry::math::equals(ced_min, cing_min))
-        {
-            state.on_border = true;
-        }
-        else if (ced_min < cing_min)
-        {
-            state.outside = true;
-            return;
-        }
-
-        if (geometry::math::equals(ced_max, cing_max))
-        {
-            state.on_border = true;
-        }
-        else if (ced_max > cing_max)
-        {
-            state.outside = true;
-            return;
-        }
-
-        box_in_box_helper
-            <
-                Box1,
-                Box2,
-                Strategy,
-                Dimension + 1,
-                DimensionCount
-            >::apply(b_contained, b_containing, strategy, state);
-    }
-};
-
-template
-<
-    typename Box1,
-    typename Box2,
-    typename Strategy,
-    std::size_t DimensionCount
->
-struct box_in_box_helper<Box1, Box2, Strategy, DimensionCount, DimensionCount>
-{
-    static inline void apply(Box1 const& , Box2 const& , Strategy const&, within_state&)
-    {
-    }
-};
-
-template
-<
-    typename Box1,
-    typename Box2,
-    typename Strategy
->
-struct box_in_box
-{
-    static inline int apply(Box1 const& box1, Box2 const& box2, Strategy const& strategy)
-    {
-        assert_dimension_equal<Box1, Box2>();
-        within_state state;
-        box_in_box_helper
-            <
-                Box1, Box2, Strategy,
-                0, dimension<Box1>::type::value
-            >::apply(box1, box2, strategy, state);
-        return state.code();
-    }
-};
-
-
 template
 <
     typename Point,
@@ -254,7 +60,7 @@
 >
 struct point_in_ring
 {
-    BOOST_CONCEPT_ASSERT( (geometry::concept::WithinStrategy<Strategy>) );
+    BOOST_CONCEPT_ASSERT( (geometry::concept::WithinStrategyPolygonal<Strategy>) );
 
     static inline int apply(Point const& point, Ring const& ring,
             Strategy const& strategy)
@@ -294,7 +100,6 @@
 };
 
 
-
 // Polygon: in exterior ring, and if so, not within interior ring(s)
 template
 <
@@ -306,7 +111,7 @@
 >
 struct point_in_polygon
 {
-    BOOST_CONCEPT_ASSERT( (geometry::concept::WithinStrategy<Strategy>) );
+    BOOST_CONCEPT_ASSERT( (geometry::concept::WithinStrategyPolygonal<Strategy>) );
 
     static inline int apply(Point const& point, Polygon const& poly,
             Strategy const& strategy)
@@ -378,137 +183,60 @@
 
 template <typename Point, typename Box, typename Strategy>
 struct within<point_tag, box_tag, Point, Box, Strategy>
-    : detail::within::point_in_box
-            <
-                Point,
-                Box,
-                Strategy
-            >
-{};
+{
+    static inline bool apply(Point const& point, Box const& box, Strategy const& strategy)
+    {
+        return strategy.apply(point, box);
+    }
+};
 
 template <typename Box1, typename Box2, typename Strategy>
 struct within<box_tag, box_tag, Box1, Box2, Strategy>
-    : detail::within::box_in_box
-            <
-                Box1,
-                Box2,
-                Strategy
-            >
-{};
+{
+    static inline bool apply(Box1 const& box1, Box2 const& box2, Strategy const& strategy)
+    {
+        assert_dimension_equal<Box1, Box2>();
+        return strategy.apply(box1, box2);
+    }
+};
 
 
 
 template <typename Point, typename Ring, typename Strategy>
 struct within<point_tag, ring_tag, Point, Ring, Strategy>
-    : detail::within::point_in_ring
-        <
-            Point,
-            Ring,
-            order_as_direction<geometry::point_order<Ring>::value>::value,
-            geometry::closure<Ring>::value,
-            Strategy
-        >
-{};
+{
+    static inline bool apply(Point const& point, Ring const& ring, Strategy const& strategy)
+    {
+        return detail::within::point_in_ring
+            <
+                Point,
+                Ring,
+                order_as_direction<geometry::point_order<Ring>::value>::value,
+                geometry::closure<Ring>::value,
+                Strategy
+            >::apply(point, ring, strategy) == 1;
+    }
+};
 
 template <typename Point, typename Polygon, typename Strategy>
 struct within<point_tag, polygon_tag, Point, Polygon, Strategy>
-    : detail::within::point_in_polygon
-        <
-            Point,
-            Polygon,
-            order_as_direction<geometry::point_order<Polygon>::value>::value,
-            geometry::closure<Polygon>::value,
-            Strategy
-        >
-{};
-
-} // namespace dispatch
-#endif // DOXYGEN_NO_DISPATCH
-
-
-#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
-namespace strategy { namespace within
 {
-
-/// Strategy for box-in-box (not used but has to be present for default strategy)
-struct unused_strategy {};
-
-namespace services
-{
-
-// Specialize for box-in-areal (box-in-box). This is meant to do box-in-box
-// but will be catched by box-in-any-areal, which has to change later
-// (we might introduce another tag which is not "areal", derived by poly/ring/
-// multi_poly, but NOT by box, and use that here. E.g. "polygonal")
-// Using cartesian prevents spherical yet from compiling, which is good.
-template <typename Box1, typename Box2>
-struct default_strategy<box_tag, areal_tag, cartesian_tag, cartesian_tag, Box1, Box2>
-{
-    typedef unused_strategy type;
+    static inline bool apply(Point const& point, Polygon const& polygon, Strategy const& strategy)
+    {
+        return detail::within::point_in_polygon
+            <
+                Point,
+                Polygon,
+                order_as_direction<geometry::point_order<Polygon>::value>::value,
+                geometry::closure<Polygon>::value,
+                Strategy
+            >::apply(point, polygon, strategy) == 1;
+    }
 };
 
-} // namespace services
-
-}} // namespace strategy::within
-
-#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
-
-
-namespace detail
-{
-
-template<typename Geometry1, typename Geometry2>
-inline int within_code(Geometry1 const& geometry1, Geometry2 const& geometry2)
-{
-    concept::check<Geometry1 const>();
-    concept::check<Geometry2 const>();
-
-    typedef typename point_type<Geometry1>::type point_type1;
-    typedef typename point_type<Geometry2>::type point_type2;
-
-    typedef typename strategy::within::services::default_strategy
-        <
-            typename tag<Geometry1>::type,
-            typename tag_cast<typename tag<Geometry2>::type, areal_tag>::type,
-            typename cs_tag<point_type1>::type,
-            typename cs_tag<point_type2>::type,
-            point_type1,
-            point_type2
-        >::type strategy_type;
-
-    return dispatch::within
-        <
-            typename tag<Geometry1>::type,
-            typename tag<Geometry2>::type,
-            Geometry1,
-            Geometry2,
-            strategy_type
-        >::apply(geometry1, geometry2, strategy_type());
-}
-
-
-template<typename Geometry1, typename Geometry2, typename Strategy>
-inline int within_code(Geometry1 const& geometry1, Geometry2 const& geometry2,
-        Strategy const& strategy)
-{
-    // Always assume a point-in-polygon strategy here.
-    // Because for point-in-box, it makes no sense to specify one.
-    BOOST_CONCEPT_ASSERT( (geometry::concept::WithinStrategy<Strategy>) );
-
-    concept::check<Geometry1 const>();
-    concept::check<Geometry2 const>();
-
-    return dispatch::within
-        <
-            typename tag<Geometry1>::type,
-            typename tag<Geometry2>::type,
-            Geometry1,
-            Geometry2,
-            Strategy
-        >::apply(geometry1, geometry2, strategy);
-}
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
 
-}
 
 /*!
 \brief \brief_check12{is completely inside}
@@ -538,7 +266,37 @@
 {
     concept::check<Geometry1 const>();
     concept::check<Geometry2 const>();
-    return detail::within_code(geometry1, geometry2) == 1;
+    assert_dimension_equal<Geometry1, Geometry2>();
+
+    typedef typename point_type<Geometry1>::type point_type1;
+    typedef typename point_type<Geometry2>::type point_type2;
+
+    typedef typename strategy::within::services::default_strategy
+        <
+            typename tag<Geometry1>::type,
+            typename tag<Geometry2>::type,
+            typename tag<Geometry1>::type,
+            typename tag_cast<typename tag<Geometry2>::type, areal_tag>::type,
+            typename tag_cast
+                <
+                    typename cs_tag<point_type1>::type, spherical_tag
+                >::type,
+            typename tag_cast
+                <
+                    typename cs_tag<point_type2>::type, spherical_tag
+                >::type,
+            Geometry1,
+            Geometry2
+        >::type strategy_type;
+
+    return dispatch::within
+        <
+            typename tag<Geometry1>::type,
+            typename tag<Geometry2>::type,
+            Geometry1,
+            Geometry2,
+            strategy_type
+        >::apply(geometry1, geometry2, strategy_type());
 }
 
 /*!
@@ -573,13 +331,25 @@
 inline bool within(Geometry1 const& geometry1, Geometry2 const& geometry2,
         Strategy const& strategy)
 {
-    // Always assume a point-in-polygon strategy here.
-    // Because for point-in-box, it makes no sense to specify one.
-    BOOST_CONCEPT_ASSERT( (geometry::concept::WithinStrategy<Strategy>) );
-
+	concept::within::check
+        <
+            typename tag<Geometry1>::type, 
+            typename tag<Geometry2>::type, 
+            typename tag_cast<typename tag<Geometry2>::type, areal_tag>::type,
+            Strategy
+        >();
     concept::check<Geometry1 const>();
     concept::check<Geometry2 const>();
-    return detail::within_code(geometry1, geometry2, strategy) == 1;
+    assert_dimension_equal<Geometry1, Geometry2>();
+
+    return dispatch::within
+        <
+            typename tag<Geometry1>::type,
+            typename tag<Geometry2>::type,
+            Geometry1,
+            Geometry2,
+            Strategy
+        >::apply(geometry1, geometry2, strategy);
 }
 
 }} // namespace boost::geometry

Modified: trunk/boost/geometry/core/tags.hpp
==============================================================================
--- trunk/boost/geometry/core/tags.hpp	(original)
+++ trunk/boost/geometry/core/tags.hpp	2011-07-17 08:26:01 EDT (Sun, 17 Jul 2011)
@@ -20,18 +20,21 @@
 
 // Tags defining strategies linked to coordinate systems
 
+/// Tag used for casting spherical/geographic coordinate systems
+struct spherical_tag {};
+
 
 /// Tag indicating Cartesian coordinate system family (cartesian,epsg)
 struct cartesian_tag {};
 
 /// Tag indicating Spherical polar coordinate system family
-struct spherical_polar_tag {};
+struct spherical_polar_tag : spherical_tag {};
 
 /// Tag indicating Spherical equatorial coordinate system family
-struct spherical_equatorial_tag {};
+struct spherical_equatorial_tag : spherical_tag {};
 
 /// Tag indicating Geographic coordinate system family (geographic)
-struct geographic_tag {};
+struct geographic_tag : spherical_tag {};
 
 
 
@@ -53,6 +56,9 @@
 /// For areal types (polygon, multi_polygon, box, ring)
 struct areal_tag {};
 
+// Subset of areal types (polygon, multi_polygon, ring)
+struct polygonal_tag : areal_tag {}; 
+
 /// For volume types (also box (?), polyhedron)
 struct volumetric_tag {};
 
@@ -70,10 +76,10 @@
 struct linestring_tag : single_tag, linear_tag {};
 
 /// OGC Polygon identifying tag
-struct polygon_tag : single_tag, areal_tag {};
+struct polygon_tag : single_tag, polygonal_tag {};
 
 /// Convenience (linear) ring identifying tag
-struct ring_tag : single_tag, areal_tag {};
+struct ring_tag : single_tag, polygonal_tag {};
 
 /// Convenience 2D or 3D box (mbr / aabb) identifying tag
 struct box_tag : single_tag, areal_tag {};

Added: trunk/boost/geometry/multi/algorithms/covered_by.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/geometry/multi/algorithms/covered_by.hpp	2011-07-17 08:26:01 EDT (Sun, 17 Jul 2011)
@@ -0,0 +1,68 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2011 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2011 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2011 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_COVERED_BY_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_COVERED_BY_HPP
+
+
+#include <boost/geometry/multi/core/closure.hpp>
+#include <boost/geometry/multi/core/point_order.hpp>
+#include <boost/geometry/multi/core/tags.hpp>
+#include <boost/geometry/multi/algorithms/within.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Point, typename MultiPolygon, typename Strategy>
+struct covered_by<point_tag, multi_polygon_tag, Point, MultiPolygon, Strategy>
+{
+    static inline bool apply(Point const& point, 
+                MultiPolygon const& multi_polygon, Strategy const& strategy)
+    {
+        return detail::within::geometry_multi_within_code
+            <
+                Point,
+                MultiPolygon,
+                Strategy,
+                detail::within::point_in_polygon
+                        <
+                            Point,
+                            typename boost::range_value<MultiPolygon>::type,
+                            order_as_direction
+                                <
+                                    geometry::point_order<MultiPolygon>::value
+                                >::value,
+                            geometry::closure<MultiPolygon>::value,
+                            Strategy
+                        >
+            >::apply(point, multi_polygon, strategy) >= 0;
+    }
+};
+
+
+} // namespace dispatch
+
+
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_COVERED_BY_HPP

Modified: trunk/boost/geometry/multi/algorithms/within.hpp
==============================================================================
--- trunk/boost/geometry/multi/algorithms/within.hpp	(original)
+++ trunk/boost/geometry/multi/algorithms/within.hpp	2011-07-17 08:26:01 EDT (Sun, 17 Jul 2011)
@@ -37,7 +37,7 @@
     typename Strategy,
     typename Policy
 >
-struct geometry_in_multi
+struct geometry_multi_within_code
 {
     static inline int apply(Geometry const& geometry,
             MultiGeometry const& multi,
@@ -48,7 +48,8 @@
             it != boost::end(multi);
             ++it)
         {
-            // Geometry within a multi: true if within one of them
+            // Geometry coding on multi: 1 (within) if within one of them;
+            // 0 (touch) if on border of one of them
             int const code = Policy::apply(geometry, *it, strategy);
             if (code != -1)
             {
@@ -70,21 +71,29 @@
 
 template <typename Point, typename MultiPolygon, typename Strategy>
 struct within<point_tag, multi_polygon_tag, Point, MultiPolygon, Strategy>
-    : detail::within::geometry_in_multi
-        <
-            Point,
-            MultiPolygon,
-            Strategy,
-            detail::within::point_in_polygon
-                    <
-                        Point,
-                        typename boost::range_value<MultiPolygon>::type,
-                        order_as_direction<geometry::point_order<MultiPolygon>::value>::value,
-                        geometry::closure<MultiPolygon>::value,
-                        Strategy
-                    >
-        >
-{};
+{
+    static inline bool apply(Point const& point, 
+                MultiPolygon const& multi_polygon, Strategy const& strategy)
+    {
+        return detail::within::geometry_multi_within_code
+            <
+                Point,
+                MultiPolygon,
+                Strategy,
+                detail::within::point_in_polygon
+                        <
+                            Point,
+                            typename boost::range_value<MultiPolygon>::type,
+                            order_as_direction
+                                <
+                                    geometry::point_order<MultiPolygon>::value
+                                >::value,
+                            geometry::closure<MultiPolygon>::value,
+                            Strategy
+                        >
+            >::apply(point, multi_polygon, strategy) == 1;
+    }
+};
 
 } // namespace dispatch
 #endif // DOXYGEN_NO_DISPATCH

Modified: trunk/boost/geometry/multi/core/tags.hpp
==============================================================================
--- trunk/boost/geometry/multi/core/tags.hpp	(original)
+++ trunk/boost/geometry/multi/core/tags.hpp	2011-07-17 08:26:01 EDT (Sun, 17 Jul 2011)
@@ -27,7 +27,7 @@
 struct multi_linestring_tag : multi_tag, linear_tag {};
 
 /// OGC Multi polygon identifying tag
-struct multi_polygon_tag : multi_tag, areal_tag {};
+struct multi_polygon_tag : multi_tag, polygonal_tag {};
 
 /// OGC Geometry Collection identifying tag
 struct geometry_collection_tag : multi_tag {};

Added: trunk/boost/geometry/strategies/agnostic/point_in_box_by_side.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/geometry/strategies/agnostic/point_in_box_by_side.hpp	2011-07-17 08:26:01 EDT (Sun, 17 Jul 2011)
@@ -0,0 +1,151 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2011 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2011 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2011 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_POINT_IN_BOX_BY_SIDE_HPP
+#define BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_POINT_IN_BOX_BY_SIDE_HPP
+
+#include <boost/array.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/strategies/covered_by.hpp>
+#include <boost/geometry/strategies/within.hpp>
+
+
+namespace boost { namespace geometry { namespace strategy 
+{
+    
+namespace within
+{
+
+struct decide_within
+{
+    static inline bool apply(int side, bool& result)
+    {
+        if (side != 1)
+        {
+            result = false;
+            return false;
+        }
+        return true; // continue
+    }
+};
+
+struct decide_covered_by
+{
+    static inline bool apply(int side, bool& result)
+    {
+        if (side != 1)
+        {
+            result = side >= 0;
+            return false;
+        }
+        return true; // continue
+    }
+};
+
+
+template <typename Point, typename Box, typename Decide = decide_within>
+struct point_in_box_by_side
+{
+    typedef typename strategy::side::services::default_strategy
+    <
+        typename cs_tag<Box>::type
+    >::type side_strategy_type;
+
+    static inline bool apply(Point const& point, Box const& box)
+    {
+        // Create (counterclockwise) array of points, the fifth one closes it
+        // Every point should be on the LEFT side (=1), or ON the border (=0),
+        // So >= 1 or >= 0
+        boost::array<typename point_type<Box>::type, 5> bp;
+        geometry::detail::assign_box_corners_oriented<true>(box, bp);
+        bp[4] = bp[0];
+        
+        bool result = true;
+        side_strategy_type strategy;
+        boost::ignore_unused_variable_warning(strategy);
+        
+        for (int i = 1; i < 5; i++)
+        {
+            int const side = strategy.apply(point, bp[i - 1], bp[i]);
+            if (! Decide::apply(side, result))
+            {
+                return result;
+            }
+        }
+    
+        return result;
+    }
+};
+
+
+} // namespace within
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+namespace within { namespace services
+{
+
+template <typename Point, typename Box>
+struct default_strategy
+    <
+        point_tag, box_tag, 
+        point_tag, areal_tag, 
+        spherical_tag, spherical_tag, 
+        Point, Box
+    >
+{
+    typedef within::point_in_box_by_side
+                <
+					Point, Box, within::decide_within
+                > type;
+};
+
+
+
+}} // namespace within::services
+
+
+namespace covered_by { namespace services
+{
+
+
+template <typename Point, typename Box>
+struct default_strategy
+    <
+        point_tag, box_tag, 
+        point_tag, areal_tag, 
+        spherical_tag, spherical_tag, 
+        Point, Box
+    >
+{
+    typedef within::point_in_box_by_side
+                <
+                    Point, Box, within::decide_covered_by
+                > type;
+};
+
+
+}} // namespace covered_by::services
+
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}}} // namespace boost::geometry::strategy
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_POINT_IN_BOX_BY_SIDE_HPP

Modified: trunk/boost/geometry/strategies/agnostic/point_in_poly_winding.hpp
==============================================================================
--- trunk/boost/geometry/strategies/agnostic/point_in_poly_winding.hpp	(original)
+++ trunk/boost/geometry/strategies/agnostic/point_in_poly_winding.hpp	2011-07-17 08:26:01 EDT (Sun, 17 Jul 2011)
@@ -17,6 +17,7 @@
 #include <boost/geometry/util/select_calculation_type.hpp>
 
 #include <boost/geometry/strategies/side.hpp>
+#include <boost/geometry/strategies/covered_by.hpp>
 #include <boost/geometry/strategies/within.hpp>
 
 
@@ -181,23 +182,18 @@
 {
 
 // Register using "areal_tag" for ring, polygon, multi-polygon
-template <typename Point, typename PointOfSegment>
-struct default_strategy<point_tag, areal_tag, cartesian_tag, cartesian_tag, Point, PointOfSegment>
+template <typename AnyTag, typename Point, typename Geometry>
+struct default_strategy<point_tag, AnyTag, point_tag, areal_tag, cartesian_tag, cartesian_tag, Point, Geometry>
 {
-    typedef winding<Point, PointOfSegment> type;
+    typedef winding<Point, typename geometry::point_type<Geometry>::type> type;
 };
 
-template <typename Point, typename PointOfSegment>
-struct default_strategy<point_tag, areal_tag, spherical_polar_tag, spherical_polar_tag, Point, PointOfSegment>
+template <typename AnyTag, typename Point, typename Geometry>
+struct default_strategy<point_tag, AnyTag, point_tag, areal_tag, spherical_tag, spherical_tag, Point, Geometry>
 {
-    typedef winding<Point, PointOfSegment> type;
+    typedef winding<Point, typename geometry::point_type<Geometry>::type> type;
 };
 
-template <typename Point, typename PointOfSegment>
-struct default_strategy<point_tag, areal_tag, spherical_equatorial_tag, spherical_equatorial_tag, Point, PointOfSegment>
-{
-    typedef winding<Point, PointOfSegment> type;
-};
 
 } // namespace services
 
@@ -207,6 +203,29 @@
 }} // namespace strategy::within
 
 
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace strategy { namespace covered_by { namespace services
+{
+
+// Register using "areal_tag" for ring, polygon, multi-polygon
+template <typename AnyTag, typename Point, typename Geometry>
+struct default_strategy<point_tag, AnyTag, point_tag, areal_tag, cartesian_tag, cartesian_tag, Point, Geometry>
+{
+    typedef strategy::within::winding<Point, typename geometry::point_type<Geometry>::type> type;
+};
+
+template <typename AnyTag, typename Point, typename Geometry>
+struct default_strategy<point_tag, AnyTag, point_tag, areal_tag, spherical_tag, spherical_tag, Point, Geometry>
+{
+    typedef strategy::within::winding<Point, typename geometry::point_type<Geometry>::type> type;
+};
+
+
+}}} // namespace strategy::covered_by::services
+#endif
+
+
 }} // namespace boost::geometry
 
 

Added: trunk/boost/geometry/strategies/cartesian/box_in_box.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/geometry/strategies/cartesian/box_in_box.hpp	2011-07-17 08:26:01 EDT (Sun, 17 Jul 2011)
@@ -0,0 +1,176 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2011 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2011 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2011 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BOX_IN_BOX_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BOX_IN_BOX_HPP
+
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/strategies/covered_by.hpp>
+#include <boost/geometry/strategies/within.hpp>
+
+
+namespace boost { namespace geometry { namespace strategy 
+{
+    
+   
+namespace within
+{
+
+struct box_within_range
+{
+    template <typename BoxContainedValue, typename BoxContainingValue>
+    static inline bool apply(BoxContainedValue const& bed_min
+                , BoxContainedValue const& bed_max
+                , BoxContainingValue const& bing_min
+                , BoxContainingValue const& bing_max)
+    {
+        return bed_min > bing_min && bed_max < bing_max;
+    }
+};
+
+
+struct box_covered_by_range
+{
+    template <typename BoxContainedValue, typename BoxContainingValue>
+    static inline bool apply(BoxContainedValue const& bed_min
+                , BoxContainedValue const& bed_max
+                , BoxContainingValue const& bing_min
+                , BoxContainingValue const& bing_max)
+    {
+        return bed_min >= bing_min && bed_max <= bing_max;
+    }
+};
+
+
+template
+<
+    typename SubStrategy,
+    typename Box1,
+    typename Box2,
+    std::size_t Dimension,
+    std::size_t DimensionCount
+>
+struct relate_box_box_loop
+{
+    static inline bool apply(Box1 const& b_contained, Box2 const& b_containing)
+    {
+        assert_dimension_equal<Box1, Box2>();
+
+        if (! SubStrategy::apply(
+                    get<min_corner, Dimension>(b_contained), 
+                    get<max_corner, Dimension>(b_contained), 
+                    get<min_corner, Dimension>(b_containing), 
+                    get<max_corner, Dimension>(b_containing)
+                )
+            )
+        {
+            return false;
+        }
+
+        return relate_box_box_loop
+            <
+                SubStrategy,
+                Box1, Box2,
+                Dimension + 1, DimensionCount
+            >::apply(b_contained, b_containing);
+    }
+};
+
+template
+<
+    typename SubStrategy,
+    typename Box1,
+    typename Box2,
+    std::size_t DimensionCount
+>
+struct relate_box_box_loop<SubStrategy, Box1, Box2, DimensionCount, DimensionCount>
+{
+    static inline bool apply(Box1 const& , Box2 const& )
+    {
+        return true;
+    }
+};
+
+template
+<
+    typename Box1,
+    typename Box2,
+    typename SubStrategy = box_within_range
+>
+struct box_in_box
+{
+    static inline bool apply(Box1 const& box1, Box2 const& box2)
+    {
+        return relate_box_box_loop
+            <
+                SubStrategy, 
+                Box1, Box2, 0, dimension<Box1>::type::value
+            >::apply(box1, box2);
+    }
+};
+
+
+} // namespace within
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+namespace within { namespace services
+{
+
+template <typename BoxContained, typename BoxContaining>
+struct default_strategy
+    <
+        box_tag, box_tag, 
+        box_tag, areal_tag, 
+        cartesian_tag, cartesian_tag, 
+        BoxContained, BoxContaining
+    >
+{
+    typedef within::box_in_box<BoxContained, BoxContaining> type;
+};
+
+
+}} // namespace within::services
+
+namespace covered_by { namespace services
+{
+
+template <typename BoxContained, typename BoxContaining>
+struct default_strategy
+    <
+        box_tag, box_tag, 
+        box_tag, areal_tag, 
+        cartesian_tag, cartesian_tag, 
+        BoxContained, BoxContaining
+    >
+{
+    typedef within::box_in_box
+                <
+					BoxContained, BoxContaining,
+                    within::box_covered_by_range
+                > type;
+};
+
+}} // namespace covered_by::services
+
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}}} // namespace boost::geometry::strategy
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BOX_IN_BOX_HPP

Added: trunk/boost/geometry/strategies/cartesian/point_in_box.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/geometry/strategies/cartesian/point_in_box.hpp	2011-07-17 08:26:01 EDT (Sun, 17 Jul 2011)
@@ -0,0 +1,172 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2011 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2011 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2011 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_POINT_IN_BOX_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_POINT_IN_BOX_HPP
+
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/strategies/covered_by.hpp>
+#include <boost/geometry/strategies/within.hpp>
+
+
+namespace boost { namespace geometry { namespace strategy 
+{
+    
+namespace within
+{
+
+
+struct within_range
+{
+    template <typename Value1, typename Value2>
+    static inline bool apply(Value1 const& value, Value2 const& min_value, Value2 const& max_value)
+    {
+        return value > min_value && value < max_value;
+    }
+};
+
+
+struct covered_by_range
+{
+    template <typename Value1, typename Value2>
+    static inline bool apply(Value1 const& value, Value2 const& min_value, Value2 const& max_value)
+    {
+        return value >= min_value && value <= max_value;
+    }
+};
+
+
+template
+<
+    typename SubStrategy,
+    typename Point,
+    typename Box,
+    std::size_t Dimension,
+    std::size_t DimensionCount
+>
+struct relate_point_box_loop
+{
+    static inline bool apply(Point const& point, Box const& box)
+    {
+        if (! SubStrategy::apply(get<Dimension>(point), 
+				    get<min_corner, Dimension>(box), 
+                    get<max_corner, Dimension>(box))
+            )
+        {
+            return false;
+        }
+        
+        return relate_point_box_loop
+            <
+                SubStrategy,
+                Point, Box,
+                Dimension + 1, DimensionCount
+            >::apply(point, box);
+    }
+};
+
+
+template
+<
+    typename SubStrategy,
+    typename Point,
+    typename Box,
+    std::size_t DimensionCount
+>
+struct relate_point_box_loop<SubStrategy, Point, Box, DimensionCount, DimensionCount>
+{
+    static inline bool apply(Point const& , Box const& )
+    {
+        return true;
+    }
+};
+
+
+template
+<
+    typename Point,
+    typename Box,
+    typename SubStrategy = within_range
+>
+struct point_in_box
+{
+    static inline bool apply(Point const& point, Box const& box)
+    {
+        return relate_point_box_loop
+            <
+                SubStrategy,
+                Point, Box, 
+                0, dimension<Point>::type::value
+            >::apply(point, box);
+    }
+};
+
+
+} // namespace within
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+namespace within { namespace services
+{
+
+template <typename Point, typename Box>
+struct default_strategy
+    <
+        point_tag, box_tag, 
+        point_tag, areal_tag, 
+        cartesian_tag, cartesian_tag, 
+        Point, Box
+    >
+{
+    typedef within::point_in_box<Point, Box> type; 
+};
+
+
+}} // namespace within::services
+
+
+namespace covered_by { namespace services
+{
+
+
+template <typename Point, typename Box>
+struct default_strategy
+    <
+        point_tag, box_tag, 
+        point_tag, areal_tag, 
+        cartesian_tag, cartesian_tag, 
+        Point, Box
+    >
+{
+    typedef within::point_in_box
+                <
+					Point, Box,
+                    within::covered_by_range
+                > type;
+};
+
+
+}} // namespace covered_by::services
+
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}}} // namespace boost::geometry::strategy
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_POINT_IN_BOX_HPP

Modified: trunk/boost/geometry/strategies/concepts/distance_concept.hpp
==============================================================================
--- trunk/boost/geometry/strategies/concepts/distance_concept.hpp	(original)
+++ trunk/boost/geometry/strategies/concepts/distance_concept.hpp	2011-07-17 08:26:01 EDT (Sun, 17 Jul 2011)
@@ -19,13 +19,7 @@
 
 #include <boost/concept_check.hpp>
 
-#include <boost/function_types/function_arity.hpp>
-#include <boost/function_types/is_member_function_pointer.hpp>
-#include <boost/function_types/parameter_types.hpp>
-#include <boost/mpl/at.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/plus.hpp>
-#include <boost/type_traits.hpp>
+#include <boost/geometry/util/parameter_type_of.hpp>
 
 #include <boost/geometry/geometries/concepts/point_concept.hpp>
 #include <boost/geometry/geometries/segment.hpp>
@@ -50,40 +44,15 @@
         template <typename ApplyMethod>
         static void apply(ApplyMethod const&)
         {
-            namespace ft = boost::function_types;
-            typedef typename ft::parameter_types
-                <
-                    ApplyMethod
-                >::type parameter_types;
-
-            typedef typename boost::mpl::if_
-                <
-                    ft::is_member_function_pointer<ApplyMethod>,
-                    boost::mpl::int_<1>,
-                    boost::mpl::int_<0>
-                >::type base_index;
-
             // 1: inspect and define both arguments of apply
-            typedef typename boost::remove_reference
+            typedef typename parameter_type_of
                 <
-                    typename boost::mpl::at
-                        <
-                            parameter_types,
-                            base_index
-                        >::type
+                    ApplyMethod, 0
                 >::type ptype1;
 
-            typedef typename boost::remove_reference
+            typedef typename parameter_type_of
                 <
-                    typename boost::mpl::at
-                        <
-                            parameter_types,
-                            typename boost::mpl::plus
-                                <
-                                    base_index,
-                                    boost::mpl::int_<1>
-                                >::type
-                        >::type
+                    ApplyMethod, 1
                 >::type ptype2;
 
             // 2) check if apply-arguments fulfill point concept
@@ -177,40 +146,14 @@
         template <typename ApplyMethod>
         static void apply(ApplyMethod const&)
         {
-            namespace ft = boost::function_types;
-            typedef typename ft::parameter_types
-                <
-                    ApplyMethod
-                >::type parameter_types;
-
-            typedef typename boost::mpl::if_
-                <
-                    ft::is_member_function_pointer<ApplyMethod>,
-                    boost::mpl::int_<1>,
-                    boost::mpl::int_<0>
-                >::type base_index;
-
-            // 1: inspect and define both arguments of apply
-            typedef typename boost::remove_reference
+            typedef typename parameter_type_of
                 <
-                    typename boost::mpl::at
-                        <
-                            parameter_types,
-                            base_index
-                        >::type
+                    ApplyMethod, 0
                 >::type ptype;
 
-            typedef typename boost::remove_reference
+            typedef typename parameter_type_of
                 <
-                    typename boost::mpl::at
-                        <
-                            parameter_types,
-                            typename boost::mpl::plus
-                                <
-                                    base_index,
-                                    boost::mpl::int_<1>
-                                >::type
-                        >::type
+                    ApplyMethod, 1
                 >::type sptype;
 
             // 2) check if apply-arguments fulfill point concept

Modified: trunk/boost/geometry/strategies/concepts/within_concept.hpp
==============================================================================
--- trunk/boost/geometry/strategies/concepts/within_concept.hpp	(original)
+++ trunk/boost/geometry/strategies/concepts/within_concept.hpp	2011-07-17 08:26:01 EDT (Sun, 17 Jul 2011)
@@ -17,6 +17,9 @@
 
 
 #include <boost/concept_check.hpp>
+#include <boost/function_types/result_type.hpp>
+
+#include <boost/geometry/util/parameter_type_of.hpp>
 
 
 namespace boost { namespace geometry { namespace concept
@@ -24,57 +27,265 @@
 
 
 /*!
-    \brief Checks strategy for within (point-in-polygon)
-    \ingroup within
+\brief Checks strategy for within (point-in-polygon)
+\ingroup within
 */
 template <typename Strategy>
-class WithinStrategy
+class WithinStrategyPolygonal
 {
 #ifndef DOXYGEN_NO_CONCEPT_MEMBERS
 
-    // 1) must define state_type,
+    // 1) must define state_type
     typedef typename Strategy::state_type state_type;
 
-    // 2) must define point_type (of "point" in poly)
-    typedef typename Strategy::point_type point_type;
+    struct checker
+    {
+        template <typename ApplyMethod, typename ResultMethod>
+        static void apply(ApplyMethod const&, ResultMethod const& )
+        {
+            typedef typename parameter_type_of
+                <
+                    ApplyMethod, 0
+                >::type point_type;
+            typedef typename parameter_type_of
+                <
+                    ApplyMethod, 1
+                >::type segment_point_type;
+
+            // CHECK: apply-arguments should both fulfill point concept
+            BOOST_CONCEPT_ASSERT
+                (
+                    (concept::ConstPoint<point_type>)
+                );
+
+            BOOST_CONCEPT_ASSERT
+                (
+                    (concept::ConstPoint<segment_point_type>)
+                );
+
+            // CHECK: return types (result: int, apply: bool)
+            BOOST_MPL_ASSERT_MSG
+                (
+                    (boost::is_same
+                        <
+                            bool, typename boost::function_types::result_type<ApplyMethod>::type
+                        >::type::value),
+                    WRONG_RETURN_TYPE_OF_APPLY
+                    , (bool)
+                );
+            BOOST_MPL_ASSERT_MSG
+                (
+                    (boost::is_same
+                        <
+                            int, typename boost::function_types::result_type<ResultMethod>::type
+                        >::type::value),
+                    WRONG_RETURN_TYPE_OF_RESULT
+                    , (int)
+                );
+
+
+            // CHECK: calling method apply and result
+            Strategy const* str;
+            state_type* st;
+            point_type const* p;
+            segment_point_type const* sp;
+
+            bool b = str->apply(*p, *sp, *sp, *st);
+            int r = str->result(*st);
 
-    // 3) must define point_type, of polygon (segments)
-    typedef typename Strategy::segment_point_type spoint_type;
+            boost::ignore_unused_variable_warning(r);
+            boost::ignore_unused_variable_warning(b);
+            boost::ignore_unused_variable_warning(str);
+        }
+    };
+
+
+public :
+    BOOST_CONCEPT_USAGE(WithinStrategyPolygonal)
+    {
+        checker::apply(&Strategy::apply, &Strategy::result);
+    }
+#endif
+};
 
+template <typename Strategy>
+class WithinStrategyPointBox
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
 
-    struct check_methods
+    struct checker
     {
-        static void apply()
+        template <typename ApplyMethod>
+        static void apply(ApplyMethod const&)
         {
-            Strategy const* str;
+            typedef typename parameter_type_of
+                <
+                    ApplyMethod, 0
+                >::type point_type;
+            typedef typename parameter_type_of
+                <
+                    ApplyMethod, 1
+                >::type box_type;
+
+            // CHECK: apply-arguments should fulfill point/box concept
+            BOOST_CONCEPT_ASSERT
+                (
+                    (concept::ConstPoint<point_type>)
+                );
+
+            BOOST_CONCEPT_ASSERT
+                (
+                    (concept::ConstBox<box_type>)
+                );
+
+            // CHECK: return types (apply: bool)
+            BOOST_MPL_ASSERT_MSG
+                (
+                    (boost::is_same
+                        <
+                            bool, 
+                            typename boost::function_types::result_type<ApplyMethod>::type
+                        >::type::value),
+                    WRONG_RETURN_TYPE
+                    , (bool)
+                );
 
-            state_type* st;
+
+            // CHECK: calling method apply
+            Strategy const* str;
             point_type const* p;
-            spoint_type const* sp;
+            box_type const* bx;
 
-            // 4) must implement a method apply
-            //    having a point, two segment-points, and state
-            str->apply(*p, *sp, *sp, *st);
+            bool b = str->apply(*p, *bx);
 
-            // 5) must implement a method result returning int
-            int r = str->result(*st);
+            boost::ignore_unused_variable_warning(b);
+            boost::ignore_unused_variable_warning(str);
+        }
+    };
 
-            boost::ignore_unused_variable_warning(r);
+
+public :
+    BOOST_CONCEPT_USAGE(WithinStrategyPointBox)
+    {
+        checker::apply(&Strategy::apply);
+    }
+#endif
+};
+
+template <typename Strategy>
+class WithinStrategyBoxBox
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+
+    struct checker
+    {
+        template <typename ApplyMethod>
+        static void apply(ApplyMethod const&)
+        {
+            typedef typename parameter_type_of
+                <
+                    ApplyMethod, 0
+                >::type box_type1;
+            typedef typename parameter_type_of
+                <
+                    ApplyMethod, 1
+                >::type box_type2;
+
+            // CHECK: apply-arguments should both fulfill box concept
+            BOOST_CONCEPT_ASSERT
+                (
+                    (concept::ConstBox<box_type1>)
+                );
+
+            BOOST_CONCEPT_ASSERT
+                (
+                    (concept::ConstBox<box_type2>)
+                );
+
+            // CHECK: return types (apply: bool)
+            BOOST_MPL_ASSERT_MSG
+                (
+                    (boost::is_same
+                        <
+                            bool, 
+                            typename boost::function_types::result_type<ApplyMethod>::type
+                        >::type::value),
+                    WRONG_RETURN_TYPE
+                    , (bool)
+                );
+
+
+            // CHECK: calling method apply
+            Strategy const* str;
+            box_type1 const* b1;
+            box_type2 const* b2;
+
+            bool b = str->apply(*b1, *b2);
+
+            boost::ignore_unused_variable_warning(b);
             boost::ignore_unused_variable_warning(str);
         }
     };
 
 
 public :
-    BOOST_CONCEPT_USAGE(WithinStrategy)
+    BOOST_CONCEPT_USAGE(WithinStrategyBoxBox)
     {
-        check_methods::apply();
+        checker::apply(&Strategy::apply);
     }
 #endif
 };
 
+// So now: boost::geometry::concept::within
+namespace within 
+{ 
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename FirstTag, typename SecondTag, typename CastedTag, typename Strategy>
+struct check_within
+{};
+
+
+template <typename AnyTag, typename Strategy>
+struct check_within<point_tag, AnyTag, areal_tag, Strategy>
+{
+    BOOST_CONCEPT_ASSERT( (WithinStrategyPolygonal<Strategy>) );
+};
+
+
+template <typename Strategy>
+struct check_within<point_tag, box_tag, areal_tag, Strategy>
+{
+    BOOST_CONCEPT_ASSERT( (WithinStrategyPointBox<Strategy>) );
+};
+
+template <typename Strategy>
+struct check_within<box_tag, box_tag, areal_tag, Strategy>
+{
+    BOOST_CONCEPT_ASSERT( (WithinStrategyBoxBox<Strategy>) );
+};
+
+
+} // namespace dispatch
+#endif
+
+
+/*!
+\brief Checks, in compile-time, the concept of any within-strategy
+\ingroup concepts
+*/
+template <typename FirstTag, typename SecondTag, typename CastedTag, typename Strategy>
+inline void check()
+{
+    dispatch::check_within<FirstTag, SecondTag, CastedTag, Strategy> c;
+    boost::ignore_unused_variable_warning(c);
+}
+
 
+}}}} // namespace boost::geometry::concept::within
 
-}}} // namespace boost::geometry::concept
 
 #endif // BOOST_GEOMETRY_STRATEGIES_CONCEPTS_WITHIN_CONCEPT_HPP

Added: trunk/boost/geometry/strategies/covered_by.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/geometry/strategies/covered_by.hpp	2011-07-17 08:26:01 EDT (Sun, 17 Jul 2011)
@@ -0,0 +1,72 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2011 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2011 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2011 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_COVERED_BY_HPP
+#define BOOST_GEOMETRY_STRATEGIES_COVERED_BY_HPP
+
+#include <boost/mpl/assert.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace covered_by
+{
+
+
+namespace services
+{
+
+/*!
+\brief Traits class binding a covered_by determination strategy to a coordinate system
+\ingroup covered_by
+\tparam TagContained tag (possibly casted) of point-type
+\tparam TagContained tag (possibly casted) of (possibly) containing type
+\tparam CsTagContained tag of coordinate system of point-type
+\tparam CsTagContaining tag of coordinate system of (possibly) containing type
+\tparam Geometry geometry-type of input (often point, or box)
+\tparam GeometryContaining geometry-type of input (possibly) containing type
+*/
+template
+<
+    typename TagContained,
+    typename TagContaining,
+    typename CastedTagContained,
+    typename CastedTagContaining,
+    typename CsTagContained,
+    typename CsTagContaining,
+    typename GeometryContained,
+    typename GeometryContaining
+>
+struct default_strategy
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_TYPES
+            , (types<GeometryContained, GeometryContaining>)
+        );
+};
+
+
+} // namespace services
+
+
+}} // namespace strategy::covered_by
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_COVERED_BY_HPP
+

Modified: trunk/boost/geometry/strategies/strategies.hpp
==============================================================================
--- trunk/boost/geometry/strategies/strategies.hpp	(original)
+++ trunk/boost/geometry/strategies/strategies.hpp	2011-07-17 08:26:01 EDT (Sun, 17 Jul 2011)
@@ -28,10 +28,12 @@
 #include <boost/geometry/strategies/within.hpp>
 
 #include <boost/geometry/strategies/cartesian/area_surveyor.hpp>
+#include <boost/geometry/strategies/cartesian/box_in_box.hpp>
 #include <boost/geometry/strategies/cartesian/centroid_bashein_detmer.hpp>
 #include <boost/geometry/strategies/cartesian/centroid_weighted_length.hpp>
 #include <boost/geometry/strategies/cartesian/distance_pythagoras.hpp>
 #include <boost/geometry/strategies/cartesian/distance_projected_point.hpp>
+#include <boost/geometry/strategies/cartesian/point_in_box.hpp>
 #include <boost/geometry/strategies/cartesian/point_in_poly_franklin.hpp>
 #include <boost/geometry/strategies/cartesian/point_in_poly_crossings_multiply.hpp>
 #include <boost/geometry/strategies/cartesian/side_by_triangle.hpp>
@@ -43,6 +45,7 @@
 #include <boost/geometry/strategies/spherical/ssf.hpp>
 
 #include <boost/geometry/strategies/agnostic/hull_graham_andrew.hpp>
+#include <boost/geometry/strategies/agnostic/point_in_box_by_side.hpp>
 #include <boost/geometry/strategies/agnostic/point_in_poly_winding.hpp>
 #include <boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp>
 

Modified: trunk/boost/geometry/strategies/within.hpp
==============================================================================
--- trunk/boost/geometry/strategies/within.hpp	(original)
+++ trunk/boost/geometry/strategies/within.hpp	2011-07-17 08:26:01 EDT (Sun, 17 Jul 2011)
@@ -16,7 +16,6 @@
 
 #include <boost/mpl/assert.hpp>
 
-#include <boost/geometry/strategies/tags.hpp>
 
 namespace boost { namespace geometry
 {
@@ -29,28 +28,32 @@
 {
 
 /*!
-    \brief Traits class binding a within determination strategy to a coordinate system
-    \ingroup within
-    \tparam CsTagContained tag of coordinate system of point-type
-    \tparam CsTagContained tag of coordinate system of segment-type
-    \tparam Point point-type of input points
-    \tparam PointContaining point-type of input segment-points
+\brief Traits class binding a within determination strategy to a coordinate system
+\ingroup within
+\tparam TagContained tag (possibly casted) of point-type
+\tparam TagContained tag (possibly casted) of (possibly) containing type
+\tparam CsTagContained tag of coordinate system of point-type
+\tparam CsTagContaining tag of coordinate system of (possibly) containing type
+\tparam Geometry geometry-type of input (often point, or box)
+\tparam GeometryContaining geometry-type of input (possibly) containing type
 */
 template
 <
     typename TagContained,
     typename TagContaining,
+    typename CastedTagContained,
+    typename CastedTagContaining,
     typename CsTagContained,
     typename CsTagContaining,
-    typename Point,
-    typename PointContaining
+    typename GeometryContained,
+    typename GeometryContaining
 >
 struct default_strategy
 {
     BOOST_MPL_ASSERT_MSG
         (
             false, NOT_IMPLEMENTED_FOR_THIS_TYPES
-            , (types<Point, PointContaining>)
+            , (types<GeometryContained, GeometryContaining>)
         );
 };
 

Added: trunk/boost/geometry/util/parameter_type_of.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/geometry/util/parameter_type_of.hpp	2011-07-17 08:26:01 EDT (Sun, 17 Jul 2011)
@@ -0,0 +1,75 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2011 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2011 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2011 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_UTIL_PARAMETER_TYPE_OF_HPP
+#define BOOST_GEOMETRY_UTIL_PARAMETER_TYPE_OF_HPP
+
+
+#include <boost/function_types/function_arity.hpp>
+#include <boost/function_types/is_member_function_pointer.hpp>
+#include <boost/function_types/parameter_types.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/plus.hpp>
+#include <boost/type_traits.hpp>
+
+
+namespace boost { namespace geometry
+{ 
+
+
+/*!
+\brief Meta-function selecting a parameter type of a (member) function, by index
+\ingroup utility
+ */
+template <typename Method, std::size_t Index>
+struct parameter_type_of
+{
+    typedef typename boost::function_types::parameter_types
+        <
+            Method
+        >::type parameter_types;
+
+    typedef typename boost::mpl::if_
+        <
+            boost::function_types::is_member_function_pointer<Method>,
+            boost::mpl::int_<1>,
+            boost::mpl::int_<0>
+        >::type base_index_type;
+        
+    typedef typename boost::mpl::if_c
+        <
+            Index == 0,
+            base_index_type,
+            typename boost::mpl::plus
+                <
+                    base_index_type,
+                    boost::mpl::int_<Index>
+                >::type
+        >::type indexed_type;
+
+    typedef typename boost::remove_reference
+        <
+            typename boost::mpl::at
+                <
+                    parameter_types,
+                    indexed_type
+                >::type
+        >::type type;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_UTIL_PARAMETER_TYPE_OF_HPP