From 91d461100c294e882d2682aed708b36bac0e8e87 Mon Sep 17 00:00:00 2001
From: Menelaos Karavelas <menelaos.karavelas@gmail.com>
Date: Fri, 16 May 2014 14:17:48 +0300
Subject: [PATCH 01/22] [test][length] do not test the variant-related code if
 GEOMETRY_TEST_DEBUG is defined (the variant-related code does not compile
 when GEOMETRY_TEST_DEBUG is defined)

---
 test/algorithms/test_length.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/algorithms/test_length.hpp b/test/algorithms/test_length.hpp
index 713479d76..485c38056 100644
--- a/test/algorithms/test_length.hpp
+++ b/test/algorithms/test_length.hpp
@@ -44,7 +44,9 @@ void test_geometry(std::string const& wkt, double expected_length)
     Geometry geometry;
     bg::read_wkt(wkt, geometry);
     test_length(geometry, expected_length);
+#if !defined(GEOMETRY_TEST_DEBUG)
     test_length(boost::variant<Geometry>(geometry), expected_length);
+#endif
 }
 
 template <typename Geometry>

From b992ddf185023bf78e3c4eac1cc5e91b832f7d10 Mon Sep 17 00:00:00 2001
From: Menelaos Karavelas <menelaos.karavelas@gmail.com>
Date: Fri, 16 May 2014 14:24:32 +0300
Subject: [PATCH 02/22] [test][perimeter] do not test the variant-related code
 if GEOMETRY_TEST_DEBUG is defined (the variant-related code does not compile
 when GEOMETRY_TEST_DEBUG is defined); replace bg::perimeter_result
 (non-existing) by bg::default_lentgh_result (error produced when compiling
 with -DGEOMETRY_TEST_DEBUG)

---
 test/algorithms/test_perimeter.hpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/algorithms/test_perimeter.hpp b/test/algorithms/test_perimeter.hpp
index 7680e9860..74f04648a 100644
--- a/test/algorithms/test_perimeter.hpp
+++ b/test/algorithms/test_perimeter.hpp
@@ -29,7 +29,7 @@ void test_perimeter(Geometry const& geometry, long double expected_perimeter)
     std::ostringstream out;
     out << typeid(typename bg::coordinate_type<Geometry>::type).name()
         << std::endl
-        << typeid(typename bg::perimeter_result<Geometry>::type).name()
+        << typeid(typename bg::default_length_result<Geometry>::type).name()
         << std::endl
         << "perimeter : " << bg::perimeter(geometry)
         << std::endl;
@@ -48,7 +48,9 @@ void test_geometry(std::string const& wkt, double expected_perimeter)
     boost::variant<Geometry> v(geometry);
 
     test_perimeter(geometry, expected_perimeter);
+#if !defined(GEOMETRY_TEST_DEBUG)
     test_perimeter(v, expected_perimeter);
+#endif
 }
 
 template <typename Geometry>

From 422c6c7129e618fde5636c5006b6f35ed5f7fa20 Mon Sep 17 00:00:00 2001
From: Barend Gehrels <barend@xs4all.nl>
Date: Fri, 16 May 2014 23:00:13 +0200
Subject: [PATCH 03/22] [doc] Added Samuel and fixed some doc issues for
 distance

---
 doc/doxy/Doxyfile | 11 ++++++++---
 doc/geometry.qbk  |  1 +
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/doc/doxy/Doxyfile b/doc/doxy/Doxyfile
index 8c6ec4b8d..c64ecaa9a 100644
--- a/doc/doxy/Doxyfile
+++ b/doc/doxy/Doxyfile
@@ -57,7 +57,6 @@ ALIASES                = qbk{1}="\xmlonly <qbk>\1</qbk> \endxmlonly" \
 			tparam_radius="numeric type for radius (of sphere, earth)" \
 			tparam_container="container type, for example std::vector, std::deque" \
 			tparam_dimension_required="Dimension, this template parameter is required. Should contain \\[0 .. n-1\\] for an n-dimensional geometry" \
-			tparam_first_point="first point type" \
 			tparam_functor="Function or class with operator()" \
 			tparam_output_collection="output collection, either a multi-geometry, or a std::vector<Geometry> / std::deque<Geometry> etc" \
 			tparam_geometry="Any type fulfilling a Geometry Concept" \
@@ -67,8 +66,10 @@ ALIASES                = qbk{1}="\xmlonly <qbk>\1</qbk> \endxmlonly" \
 			tparam_out{1}="A valid output iterator type, accepting geometries of \1 Concept" \
 			tparam_point="Any type fulfilling a Point Concept" \
 			tparam_range_point="Any type fulfilling a Range Concept where it range_value type fulfills the Point Concept" \
-			tparam_first_point="point type" \
+			tparam_first_point="first point type" \
+			tparam_first_box="first box type" \
 			tparam_second_point="second point type" \
+			tparam_second_box="second box type" \
 			tparam_segment_point="segment point type" \
 			tparam_strategy{1}="Any type fulfilling a \1 Strategy Concept" \
 			tparam_strategy_overlay="Compound strategy for segment intersection" \
@@ -176,9 +177,13 @@ WARN_LOGFILE           =
 INPUT                  = . .. ../../../../boost/geometry/core \
 			../../../../boost/geometry/algorithms \
 			../../../../boost/geometry/algorithms/detail \
-			../../../../boost/geometry/algorithms/detail/overlay \
+			../../../../boost/geometry/algorithms/detail/distance \
 			../../../../boost/geometry/algorithms/detail/equals \
+			../../../../boost/geometry/algorithms/detail/overlay \
+			../../../../boost/geometry/algorithms/detail/relate \
 			../../../../boost/geometry/algorithms/detail/sections \
+			../../../../boost/geometry/algorithms/detail/turns \
+			../../../../boost/geometry/algorithms/detail/within \
 			../../../../boost/geometry/arithmetic \
 			../../../../boost/geometry/geometries/concepts \
 			../../../../boost/geometry/geometries \
diff --git a/doc/geometry.qbk b/doc/geometry.qbk
index 7ff1d6512..d57e3cfaa 100644
--- a/doc/geometry.qbk
+++ b/doc/geometry.qbk
@@ -113,6 +113,7 @@ Boost.Geometry contains contributions by:
 * Federico Fern\u00E1ndez (preliminary version of R-tree spatial index)
 * Karsten Ahnert (patch for cross-track distance)
 * Mats Taraldsvik (documentation: adapting a legacy model)
+* Samuel Debionne (variant support for distance)
 
 [include imports.qbk]
 

From d0cf100a654759436f026783dad0ffc528d1b080 Mon Sep 17 00:00:00 2001
From: Adam Wulkiewicz <adam.wulkiewicz@gmail.com>
Date: Sat, 17 May 2014 14:10:34 +0200
Subject: [PATCH 04/22] [get_turns][relate][test][index] Fix unused variable
 warnings.

In the rtree/pack_create replace (void)variable to boost::ignore_unused_variable_warning().
---
 .../detail/overlay/get_turn_info_for_endpoint.hpp    |  6 ++++--
 .../detail/overlay/get_turn_info_helpers.hpp         |  2 +-
 .../algorithms/detail/overlay/get_turn_info_la.hpp   | 12 +++++++-----
 .../algorithms/detail/relate/linear_areal.hpp        |  9 +++------
 .../algorithms/detail/relate/linear_linear.hpp       | 11 ++++-------
 .../geometry/algorithms/detail/relate/result.hpp     |  2 +-
 .../geometry/index/detail/rtree/pack_create.hpp      |  2 +-
 test/algorithms/assign.cpp                           |  2 +-
 test/algorithms/test_convex_hull.hpp                 |  2 +-
 9 files changed, 23 insertions(+), 25 deletions(-)

diff --git a/include/boost/geometry/algorithms/detail/overlay/get_turn_info_for_endpoint.hpp b/include/boost/geometry/algorithms/detail/overlay/get_turn_info_for_endpoint.hpp
index cd07e784a..e7df458fa 100644
--- a/include/boost/geometry/algorithms/detail/overlay/get_turn_info_for_endpoint.hpp
+++ b/include/boost/geometry/algorithms/detail/overlay/get_turn_info_for_endpoint.hpp
@@ -394,8 +394,8 @@ struct get_turn_info_for_endpoint
              typename TurnInfo,
              typename IntersectionInfo
     >
-    static inline bool handle_internal(Point1 const& i1, Point1 const& j1, Point1 const& /*k1*/,
-                                       Point2 const& i2, Point2 const& j2, Point2 const& k2,
+    static inline bool handle_internal(Point1 const& /*i1*/, Point1 const& /*j1*/, Point1 const& /*k1*/,
+                                       Point2 const& i2, Point2 const& j2, Point2 const& /*k2*/,
                                        RobustPoint1 const& ri1, RobustPoint1 const& rj1, RobustPoint1 const& /*rk1*/,
                                        RobustPoint2 const& ri2, RobustPoint2 const& rj2, RobustPoint2 const& rk2,
                                        bool first1, bool last1, bool first2, bool last2,
@@ -403,6 +403,8 @@ struct get_turn_info_for_endpoint
                                        IntersectionInfo const& inters, int ip_index,
                                        operation_type & op1, operation_type & op2)
     {
+        boost::ignore_unused_variable_warning(i2);
+        boost::ignore_unused_variable_warning(j2);
         boost::ignore_unused_variable_warning(ip_index);
         boost::ignore_unused_variable_warning(tp_model);
 
diff --git a/include/boost/geometry/algorithms/detail/overlay/get_turn_info_helpers.hpp b/include/boost/geometry/algorithms/detail/overlay/get_turn_info_helpers.hpp
index 6b3c54d5f..3f0d5da1f 100644
--- a/include/boost/geometry/algorithms/detail/overlay/get_turn_info_helpers.hpp
+++ b/include/boost/geometry/algorithms/detail/overlay/get_turn_info_helpers.hpp
@@ -160,7 +160,7 @@ public:
     
     intersection_info_base(Point1 const& pi, Point1 const& pj, Point1 const& pk,
                            Point2 const& qi, Point2 const& qj, Point2 const& qk,
-                           no_rescale_policy const& robust_policy)
+                           no_rescale_policy const& /*robust_policy*/)
         : m_side_calc(pi, pj, pk, qi, qj, qk)
     {}
 
diff --git a/include/boost/geometry/algorithms/detail/overlay/get_turn_info_la.hpp b/include/boost/geometry/algorithms/detail/overlay/get_turn_info_la.hpp
index 9556dbfaa..374c82082 100644
--- a/include/boost/geometry/algorithms/detail/overlay/get_turn_info_la.hpp
+++ b/include/boost/geometry/algorithms/detail/overlay/get_turn_info_la.hpp
@@ -446,7 +446,7 @@ struct get_turn_info_linear_areal
               typename OutIt>
     static inline bool append_collinear_spikes(TurnInfo & tp,
                                                IntersectionInfo const& inters,
-                                               bool is_p_last, bool is_q_last,
+                                               bool is_p_last, bool /*is_q_last*/,
                                                method_type method, append_version_c version,
                                                OutIt out)
     {
@@ -489,7 +489,7 @@ struct get_turn_info_linear_areal
               typename OutIt>
     static inline bool append_opposite_spikes(TurnInfo & tp,
                                               IntersectionInfo const& inters,
-                                              bool is_p_last, bool is_q_last,
+                                              bool is_p_last, bool /*is_q_last*/,
                                               OutIt out)
     {
         bool is_p_spike = ( Version == append_touches ?
@@ -635,10 +635,10 @@ struct get_turn_info_linear_areal
               typename IntersectionInfo,
               typename OutputIterator>
     static inline bool get_turn_info_for_endpoint(
-                            Point1 const& pi, Point1 const& pj, Point1 const& pk,
-                            Point2 const& qi, Point2 const& qj, Point2 const& qk,
+                            Point1 const& pi, Point1 const& /*pj*/, Point1 const& /*pk*/,
+                            Point2 const& qi, Point2 const& /*qj*/, Point2 const& /*qk*/,
                             bool is_p_first, bool is_p_last,
-                            bool is_q_first, bool is_q_last,
+                            bool /*is_q_first*/, bool is_q_last,
                             TurnInfo const& tp_model,
                             IntersectionInfo const& inters,
                             method_type /*method*/,
@@ -659,6 +659,8 @@ struct get_turn_info_linear_areal
         if ( !is_p_first && !is_p_last )
             return false;
 
+// TODO: is_q_last could probably be replaced by false and removed from parameters
+
         linear_intersections intersections(pi, qi, inters.result(), is_p_last, is_q_last);
         linear_intersections::ip_info const& ip0 = intersections.template get<0>();
         linear_intersections::ip_info const& ip1 = intersections.template get<1>();
diff --git a/include/boost/geometry/algorithms/detail/relate/linear_areal.hpp b/include/boost/geometry/algorithms/detail/relate/linear_areal.hpp
index 0bf667eb2..26750de3b 100644
--- a/include/boost/geometry/algorithms/detail/relate/linear_areal.hpp
+++ b/include/boost/geometry/algorithms/detail/relate/linear_areal.hpp
@@ -464,14 +464,11 @@ struct linear_areal
                   typename Geometry,
                   typename OtherGeometry,
                   typename BoundaryChecker>
-        void apply(Result & res,
-                   TurnIt first, TurnIt it, TurnIt last,
+        void apply(Result & res, TurnIt it,
                    Geometry const& geometry,
                    OtherGeometry const& other_geometry,
                    BoundaryChecker const& boundary_checker)
         {
-            //BOOST_ASSERT( it != last );
-
             overlay::operation_type op = it->operations[op_id].operation;
 
             if ( op != overlay::operation_union
@@ -769,7 +766,7 @@ struct linear_areal
         void apply(Result & res,
                    TurnIt first, TurnIt last,
                    Geometry const& geometry,
-                   OtherGeometry const& other_geometry,
+                   OtherGeometry const& /*other_geometry*/,
                    BoundaryChecker const& boundary_checker)
         {
             //BOOST_ASSERT( first != last );
@@ -966,7 +963,7 @@ struct linear_areal
 
         for ( TurnIt it = first ; it != last ; ++it )
         {
-            analyser.apply(res, first, it, last,
+            analyser.apply(res, it,
                            geometry, other_geometry,
                            boundary_checker);
 
diff --git a/include/boost/geometry/algorithms/detail/relate/linear_linear.hpp b/include/boost/geometry/algorithms/detail/relate/linear_linear.hpp
index fc424fff5..3476a4178 100644
--- a/include/boost/geometry/algorithms/detail/relate/linear_linear.hpp
+++ b/include/boost/geometry/algorithms/detail/relate/linear_linear.hpp
@@ -257,15 +257,12 @@ struct linear_linear
                   typename OtherGeometry,
                   typename BoundaryChecker,
                   typename OtherBoundaryChecker>
-        void apply(Result & res,
-                   TurnIt first, TurnIt it, TurnIt last,
+        void apply(Result & res, TurnIt it,
                    Geometry const& geometry,
                    OtherGeometry const& other_geometry,
                    BoundaryChecker const& boundary_checker,
                    OtherBoundaryChecker const& other_boundary_checker)
         {
-            //BOOST_ASSERT( it != last );
-
             overlay::operation_type op = it->operations[op_id].operation;
 
             segment_identifier const& seg_id = it->operations[op_id].seg_id;
@@ -563,7 +560,7 @@ struct linear_linear
                    Geometry const& geometry,
                    OtherGeometry const& /*other_geometry*/,
                    BoundaryChecker const& boundary_checker,
-                   OtherBoundaryChecker const& other_boundary_checker)
+                   OtherBoundaryChecker const& /*other_boundary_checker*/)
         {
             //BOOST_ASSERT( first != last );
 
@@ -621,7 +618,7 @@ struct linear_linear
                                 Geometry const& geometry,
                                 OtherGeometry const& other_geometry,
                                 BoundaryChecker const& boundary_checker,
-                                OtherBoundaryChecker const& other_boundary_checker,
+                                OtherBoundaryChecker const& /*other_boundary_checker*/,
                                 bool first_in_range)
         {
             typename detail::single_geometry_return_type<Geometry const>::type
@@ -747,7 +744,7 @@ struct linear_linear
 
         for ( TurnIt it = first ; it != last ; ++it )
         {
-            analyser.apply(res, first, it, last,
+            analyser.apply(res, it,
                            geometry, other_geometry,
                            boundary_checker, other_boundary_checker);
 
diff --git a/include/boost/geometry/algorithms/detail/relate/result.hpp b/include/boost/geometry/algorithms/detail/relate/result.hpp
index 1064246e4..0479a6440 100644
--- a/include/boost/geometry/algorithms/detail/relate/result.hpp
+++ b/include/boost/geometry/algorithms/detail/relate/result.hpp
@@ -911,7 +911,7 @@ struct static_check_dispatch
             return el == mask_el;
         }
         // else
-        static inline bool apply_dispatch(char el, integral_constant<int, 3>)
+        static inline bool apply_dispatch(char /*el*/, integral_constant<int, 3>)
         {
             return true;
         }
diff --git a/include/boost/geometry/index/detail/rtree/pack_create.hpp b/include/boost/geometry/index/detail/rtree/pack_create.hpp
index 232f4654f..e3ac16aef 100644
--- a/include/boost/geometry/index/detail/rtree/pack_create.hpp
+++ b/include/boost/geometry/index/detail/rtree/pack_create.hpp
@@ -294,7 +294,7 @@ private:
     inline static
     subtree_elements_counts calculate_subtree_elements_counts(std::size_t elements_count, parameters_type const& parameters, size_type & leafs_level)
     {
-        (void)parameters;
+        boost::ignore_unused_variable_warning(parameters);
 
         subtree_elements_counts res(1, 1);
         leafs_level = 0;
diff --git a/test/algorithms/assign.cpp b/test/algorithms/assign.cpp
index 52d935f93..a64f4010d 100644
--- a/test/algorithms/assign.cpp
+++ b/test/algorithms/assign.cpp
@@ -38,7 +38,7 @@ void check_geometry(Geometry const& geometry, std::string const& expected)
 }
 
 template <typename Geometry, typename Points>
-void check_assign_points(Points const& points, std::string const& expected)
+void check_assign_points(Points const& points, std::string const& /*expected*/)
 {
     Geometry geometry;
     bg::assign_points(geometry, points);
diff --git a/test/algorithms/test_convex_hull.hpp b/test/algorithms/test_convex_hull.hpp
index edf4db48b..a11b42dd7 100644
--- a/test/algorithms/test_convex_hull.hpp
+++ b/test/algorithms/test_convex_hull.hpp
@@ -27,7 +27,7 @@
 
 template <typename Geometry, typename Hull>
 void check_convex_hull(Geometry const& geometry, Hull const& hull,
-                      std::size_t size_original, std::size_t size_hull,
+                      std::size_t /*size_original*/, std::size_t size_hull,
                       double expected_area, bool reverse)
 {
     std::size_t n = bg::num_points(hull);

From 5007f1debba988a77d50659fe024c50ffd448e3c Mon Sep 17 00:00:00 2001
From: Barend Gehrels <barend@xs4all.nl>
Date: Sat, 17 May 2014 21:09:07 +0200
Subject: [PATCH 05/22] [extensions][dissolve] repaired dissolve w.r.t. turn
 changes

---
 .../extensions/algorithms/detail/overlay/dissolver.hpp     | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/include/boost/geometry/extensions/algorithms/detail/overlay/dissolver.hpp b/include/boost/geometry/extensions/algorithms/detail/overlay/dissolver.hpp
index 7d36d6dd2..ac4fdb40c 100644
--- a/include/boost/geometry/extensions/algorithms/detail/overlay/dissolver.hpp
+++ b/include/boost/geometry/extensions/algorithms/detail/overlay/dissolver.hpp
@@ -125,7 +125,12 @@ class plusmin_policy
         //negative = true;
 
         typedef typename geometry::point_type<Geometry2>::type point_type;
-        typedef overlay::turn_info<point_type> turn_info;
+
+        typedef overlay::turn_info
+            <
+                point_type,
+                typename segment_ratio_type<point_type, RescalePolicy>::type
+            > turn_info;
         std::deque<turn_info> turns;
 
         // Get (and stop on) any intersection

From dee255ad5e24aa71c4ae32ecb44b4994fabb440b Mon Sep 17 00:00:00 2001
From: Barend Gehrels <barend@xs4all.nl>
Date: Sun, 18 May 2014 00:02:43 +0200
Subject: [PATCH 06/22] [extensions][dissolve] added extra unit tests for
 cw/ccw check

---
 extensions/test/algorithms/dissolve.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/extensions/test/algorithms/dissolve.cpp b/extensions/test/algorithms/dissolve.cpp
index 46fae52d0..2c6da16d8 100644
--- a/extensions/test/algorithms/dissolve.cpp
+++ b/extensions/test/algorithms/dissolve.cpp
@@ -273,6 +273,13 @@ void test_all()
         "POLYGON((5 0,2.5 9,9.5 3.5,0.5 3.5,7.5 9,5 0))",
         0, 11, 25.6158412);
 
+    // CCW polygons should turn CW after dissolve
+    test_one<polygon, polygon>("cw",
+        "POLYGON((2 8,8 8,8 0,0 0,0 6,4 6,4 4,2 4,2 8))",
+        0, 7, 60);
+    test_one<polygon, polygon>("ccw",
+        "POLYGON((2 8,2 4,4 4,4 6,0 6,0 0,8 0,8 8,2 8))",
+        0, 12, 64); // TODO: should have the same, 7, 60. The polygon is dissolved (splitted) but the extra polygon is still on top of the other
 
     // Multi-geometries
     {

From c4ca605bab126ef5d5047ec540c6b3386e9ca022 Mon Sep 17 00:00:00 2001
From: Adam Wulkiewicz <adam.wulkiewicz@gmail.com>
Date: Sun, 18 May 2014 00:20:36 +0200
Subject: [PATCH 07/22] [overlay][relate][within][test] Fix unused variable
 warnings.

---
 .../algorithms/detail/overlay/get_intersection_points.hpp     | 4 ++--
 include/boost/geometry/algorithms/detail/relate/result.hpp    | 4 ++--
 .../geometry/algorithms/detail/within/point_in_geometry.hpp   | 4 +++-
 include/boost/geometry/algorithms/for_each.hpp                | 2 +-
 test/algorithms/test_envelope.hpp                             | 4 ++--
 5 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/include/boost/geometry/algorithms/detail/overlay/get_intersection_points.hpp b/include/boost/geometry/algorithms/detail/overlay/get_intersection_points.hpp
index 3e27a0490..d9c423ca4 100644
--- a/include/boost/geometry/algorithms/detail/overlay/get_intersection_points.hpp
+++ b/include/boost/geometry/algorithms/detail/overlay/get_intersection_points.hpp
@@ -38,8 +38,8 @@ struct get_turn_without_info
 {
     template <typename RobustPolicy, typename OutputIterator>
     static inline OutputIterator apply(
-                Point1 const& pi, Point1 const& pj, Point1 const& pk,
-                Point2 const& qi, Point2 const& qj, Point2 const& qk,
+                Point1 const& pi, Point1 const& pj, Point1 const& /*pk*/,
+                Point2 const& qi, Point2 const& qj, Point2 const& /*qk*/,
                 bool /*is_p_first*/, bool /*is_p_last*/,
                 bool /*is_q_first*/, bool /*is_q_last*/,
                 TurnInfo const& ,
diff --git a/include/boost/geometry/algorithms/detail/relate/result.hpp b/include/boost/geometry/algorithms/detail/relate/result.hpp
index 0479a6440..1bcb5275d 100644
--- a/include/boost/geometry/algorithms/detail/relate/result.hpp
+++ b/include/boost/geometry/algorithms/detail/relate/result.hpp
@@ -823,7 +823,7 @@ template <typename Last, char D, field F1, field F2>
 struct static_may_update_sequence<Last, Last, D, F1, F2>
 {
     template <typename Matrix>
-    static inline bool apply(Matrix const& matrix)
+    static inline bool apply(Matrix const& /*matrix*/)
     {
         return false;
     }
@@ -943,7 +943,7 @@ template <typename Last>
 struct static_check_sequence<Last, Last>
 {
     template <typename Matrix>
-    static inline bool apply(Matrix const& matrix)
+    static inline bool apply(Matrix const& /*matrix*/)
     {
         return false;
     }
diff --git a/include/boost/geometry/algorithms/detail/within/point_in_geometry.hpp b/include/boost/geometry/algorithms/detail/within/point_in_geometry.hpp
index 36ac44d36..a3841496f 100644
--- a/include/boost/geometry/algorithms/detail/within/point_in_geometry.hpp
+++ b/include/boost/geometry/algorithms/detail/within/point_in_geometry.hpp
@@ -37,15 +37,17 @@ namespace boost { namespace geometry {
 #ifndef DOXYGEN_NO_DETAIL
 namespace detail { namespace within {
 
+// TODO: is this needed?
 inline int check_result_type(int result)
 {
     return result;
 }
 
 template <typename T>
-inline void check_result_type(T result)
+inline T check_result_type(T result)
 {
     BOOST_ASSERT(false);
+    return result;
 }
 
 template <typename Point, typename Range, typename Strategy> inline
diff --git a/include/boost/geometry/algorithms/for_each.hpp b/include/boost/geometry/algorithms/for_each.hpp
index 24d38d3d8..2da04674c 100644
--- a/include/boost/geometry/algorithms/for_each.hpp
+++ b/include/boost/geometry/algorithms/for_each.hpp
@@ -54,7 +54,7 @@ struct fe_point_per_point
 struct fe_point_per_segment
 {
     template <typename Point, typename Functor>
-    static inline void apply(Point& , Functor& f)
+    static inline void apply(Point& , Functor& /*f*/)
     {
         // TODO: if non-const, we should extract the points from the segment
         // and call the functor on those two points
diff --git a/test/algorithms/test_envelope.hpp b/test/algorithms/test_envelope.hpp
index cc19fb9dc..bf00d1282 100644
--- a/test/algorithms/test_envelope.hpp
+++ b/test/algorithms/test_envelope.hpp
@@ -36,8 +36,8 @@ struct check_result<Box, 2>
                 ctype
             >::type type;
 
-    static void apply(Box const& b, const type& x1, const type& y1, const type& z1,
-                const type& x2, const type& y2, const type& z2)
+    static void apply(Box const& b, const type& x1, const type& y1, const type& /*z1*/,
+                const type& x2, const type& y2, const type& /*z2*/)
     {
         BOOST_CHECK_CLOSE((bg::get<bg::min_corner, 0>(b)), x1, 0.001);
         BOOST_CHECK_CLOSE((bg::get<bg::min_corner, 1>(b)), y1, 0.001);

From d6326c634351673dcaefe4cb77c657a8c8959289 Mon Sep 17 00:00:00 2001
From: Adam Wulkiewicz <adam.wulkiewicz@gmail.com>
Date: Sun, 18 May 2014 16:08:48 +0200
Subject: [PATCH 08/22] [index/example] Add the visualization of knn Box/Box
 and Seg/Box to glut_vis example

---
 index/example/glut_vis.cpp | 57 ++++++++++++++++++++++++++++++++------
 1 file changed, 49 insertions(+), 8 deletions(-)

diff --git a/index/example/glut_vis.cpp b/index/example/glut_vis.cpp
index ee74a69fa..6402f886d 100644
--- a/index/example/glut_vis.cpp
+++ b/index/example/glut_vis.cpp
@@ -58,7 +58,7 @@ LS search_linestring;
 LS search_path;
 
 enum query_mode_type {
-    qm_knn, qm_c, qm_d, qm_i, qm_o, qm_w, qm_nc, qm_nd, qm_ni, qm_no, qm_nw, qm_all, qm_ri, qm_pi, qm_mpi, qm_si, qm_lsi, qm_path
+    qm_knn, qm_knnb, qm_knns, qm_c, qm_d, qm_i, qm_o, qm_w, qm_nc, qm_nd, qm_ni, qm_no, qm_nw, qm_all, qm_ri, qm_pi, qm_mpi, qm_si, qm_lsi, qm_path
 } query_mode = qm_knn;
 
 bool search_valid = false;
@@ -68,15 +68,46 @@ void query_knn()
     float x = ( rand() % 1000 ) / 10.0f;
     float y = ( rand() % 1000 ) / 10.0f;
 
-    search_point = P(x, y);
     nearest_boxes.clear();
-    found_count = t.query(
-        bgi::nearest(search_point, count),
-        std::back_inserter(nearest_boxes)
-        );
+
+    if ( query_mode == qm_knn )
+    {
+        search_point = P(x, y);
+        found_count = t.query(
+                bgi::nearest(search_point, count),
+                std::back_inserter(nearest_boxes)
+            );
+    }
+    else if ( query_mode == qm_knnb )
+    {
+        float w = 5 + ( rand() % 1000 ) / 200.0f;
+        float h = 5 + ( rand() % 1000 ) / 200.0f;
+        search_box = B(P(x - w, y - h), P(x + w, y + h));
+        found_count = t.query(
+                bgi::nearest(search_box, count),
+                std::back_inserter(nearest_boxes)
+            );
+    }
+    else if ( query_mode == qm_knns )
+    {
+        int signx = rand() % 2 ? 1 : -1;
+        int signy = rand() % 2 ? 1 : -1;
+        float w = (10 + ( rand() % 1000 ) / 100.0f) * signx;
+        float h = (10 + ( rand() % 1000 ) / 100.0f) * signy;
+        search_segment = S(P(x - w, y - h), P(x + w, y + h));
+        found_count = t.query(
+                bgi::nearest(search_segment, count),
+                std::back_inserter(nearest_boxes)
+            );
+    }
+    else
+    {
+        BOOST_ASSERT(false);
+    }
 
     if ( found_count > 0 )
     {
+// TODO: print the correct indexable!
         std::cout << "search point: ";
         bgi::detail::utilities::print_indexable(std::cout, search_point);
         std::cout << "\nfound: ";
@@ -419,7 +450,7 @@ void search()
 {
     namespace d = bgi::detail;
 
-    if ( query_mode == qm_knn )
+    if ( query_mode == qm_knn || query_mode == qm_knnb || query_mode == qm_knns )
         query_knn();
     else if ( query_mode == qm_c )
         query< d::spatial_predicate<B, d::covered_by_tag, false> >();
@@ -575,10 +606,14 @@ void render_scene(void)
 
     if ( search_valid )
     {
-        glColor3f(1.0f, 0.5f, 0.0f);
+        glColor3f(0.0f, 0.0f, 1.0f);
 
         if ( query_mode == qm_knn )
             draw_knn_area(0, 0);
+        else if ( query_mode == qm_knnb )
+            draw_box(search_box);
+        else if ( query_mode == qm_knns )
+            draw_segment(search_segment);
         else if ( query_mode == qm_ri )
             draw_ring(search_ring);
         else if ( query_mode == qm_pi )
@@ -594,6 +629,8 @@ void render_scene(void)
         else
             draw_box(search_box);
 
+        glColor3f(1.0f, 0.5f, 0.0f);
+
         for ( size_t i = 0 ; i < nearest_boxes.size() ; ++i )
             bgi::detail::utilities::gl_draw_indexable(
                 nearest_boxes[i],
@@ -760,6 +797,10 @@ void keyboard(unsigned char key, int /*x*/, int /*y*/)
         {
             if ( current_line == "knn" )
                 query_mode = qm_knn;
+            else if ( current_line == "knnb" )
+                query_mode = qm_knnb;
+            else if ( current_line == "knns" )
+                query_mode = qm_knns;
             else if ( current_line == "c" )
                 query_mode = qm_c;
             else if ( current_line == "d" )

From c51cdc4bb9d9d84aaba33de1784f4581b61de6bf Mon Sep 17 00:00:00 2001
From: Adam Wulkiewicz <adam.wulkiewicz@gmail.com>
Date: Sun, 18 May 2014 19:29:16 +0200
Subject: [PATCH 09/22] [doc][example] Update the knn queries section in docs.
 Improve knn query visualization in glut_vis.

---
 doc/html/img/index/rtree/knn_box_box.png | Bin 0 -> 2189 bytes
 doc/html/img/index/rtree/knn_pt_box.png  | Bin 0 -> 2174 bytes
 doc/html/img/index/rtree/knn_seg_box.png | Bin 0 -> 2304 bytes
 doc/index/rtree/query.qbk                |  13 ++++++-----
 index/example/glut_vis.cpp               |  27 +++++++++++++++--------
 5 files changed, 26 insertions(+), 14 deletions(-)
 create mode 100644 doc/html/img/index/rtree/knn_box_box.png
 create mode 100644 doc/html/img/index/rtree/knn_pt_box.png
 create mode 100644 doc/html/img/index/rtree/knn_seg_box.png

diff --git a/doc/html/img/index/rtree/knn_box_box.png b/doc/html/img/index/rtree/knn_box_box.png
new file mode 100644
index 0000000000000000000000000000000000000000..6f70f884dee76c5be27710b57546c5ca33e2a162
GIT binary patch
literal 2189
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
R^$64|@O1TaS?83{1OSl*9W(#{

literal 0
HcmV?d00001

diff --git a/doc/html/img/index/rtree/knn_pt_box.png b/doc/html/img/index/rtree/knn_pt_box.png
new file mode 100644
index 0000000000000000000000000000000000000000..af9c14874009511314cf553ddc45c35f4d848ba9
GIT binary patch
literal 2174
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

literal 0
HcmV?d00001

diff --git a/doc/html/img/index/rtree/knn_seg_box.png b/doc/html/img/index/rtree/knn_seg_box.png
new file mode 100644
index 0000000000000000000000000000000000000000..13288d1ac4fb5d368c929d525feada689d279736
GIT binary patch
literal 2304
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

literal 0
HcmV?d00001

diff --git a/doc/index/rtree/query.qbk b/doc/index/rtree/query.qbk
index 7f76d7054..cbca27787 100644
--- a/doc/index/rtree/query.qbk
+++ b/doc/index/rtree/query.qbk
@@ -91,15 +91,18 @@ All spatial predicates may be negated, e.g.:
 
 [h4 Nearest neighbours queries]
 
-Nearest neighbours queries returns `__value__`s which are closest to some point in space.
-The example of k-NN query is presented below. 5 `__value__`s nearest to the point are orange.
+Nearest neighbours queries returns `__value__`s which are closest to some Geometry.
+The examples of k-NN queries are presented below. 5 `__value__`s nearest to the Geometry are orange.
 
-[$img/index/rtree/knn.png]
+[table
+[[nearest(Point)] [nearest(Box)] [nearest(Segment)]]
+[[[$img/index/rtree/knn_pt_box.png]] [[$img/index/rtree/knn_box_box.png]] [[$img/index/rtree/knn_seg_box.png]]]
+]
 
 To perform the knn query one must pass the nearest predicate generated by the
 `nearest()` function defined in `boost::geometry::index` namespace.
-The following query returns `k` `__value__`s closest to some point in space.
-For non-point `__indexable__`s the shortest distance is calculated.
+The following query returns `k` `__value__`s closest to some Point in space.
+For non-point `__indexable__`s the shortest distance is calculated using `bg::comparable_distance()` function.
 
  std::vector<__value__> returned_values;
  __point__ pt(...);
diff --git a/index/example/glut_vis.cpp b/index/example/glut_vis.cpp
index 6402f886d..755f4d300 100644
--- a/index/example/glut_vis.cpp
+++ b/index/example/glut_vis.cpp
@@ -80,8 +80,8 @@ void query_knn()
     }
     else if ( query_mode == qm_knnb )
     {
-        float w = 5 + ( rand() % 1000 ) / 200.0f;
-        float h = 5 + ( rand() % 1000 ) / 200.0f;
+        float w = 2 + ( rand() % 1000 ) / 500.0f;
+        float h = 2 + ( rand() % 1000 ) / 500.0f;
         search_box = B(P(x - w, y - h), P(x + w, y + h));
         found_count = t.query(
                 bgi::nearest(search_box, count),
@@ -490,18 +490,27 @@ void search()
     search_valid = true;
 }
 
+void draw_point(P const& p)
+{
+    float x = boost::geometry::get<0>(p);
+    float y = boost::geometry::get<1>(p);
+    float z = bgi::detail::rtree::utilities::view<RTree>(t).depth();
+
+    glBegin(GL_QUADS);
+    glVertex3f(x+1, y, z);
+    glVertex3f(x, y+1, z);
+    glVertex3f(x-1, y, z);
+    glVertex3f(x, y-1, z);
+    glEnd();
+}
+
 void draw_knn_area(float min_distance, float max_distance)
 {
     float x = boost::geometry::get<0>(search_point);
     float y = boost::geometry::get<1>(search_point);
     float z = bgi::detail::rtree::utilities::view<RTree>(t).depth();
 
-    // search point
-    glBegin(GL_TRIANGLES);
-    glVertex3f(x, y, z);
-    glVertex3f(x + 1, y, z);
-    glVertex3f(x + 1, y + 1, z);
-    glEnd();
+    draw_point(search_point);
 
     // search min circle
 
@@ -606,7 +615,7 @@ void render_scene(void)
 
     if ( search_valid )
     {
-        glColor3f(0.0f, 0.0f, 1.0f);
+        glColor3f(1.0f, 0.25f, 0.0f);
 
         if ( query_mode == qm_knn )
             draw_knn_area(0, 0);

From 82304fdeef7657520f1be93cb7a8068b58f2ba6b Mon Sep 17 00:00:00 2001
From: Adam Wulkiewicz <adam.wulkiewicz@gmail.com>
Date: Sun, 18 May 2014 19:39:38 +0200
Subject: [PATCH 10/22] [doc] Fix quickref.xml to support new parameter name of
 nearest(). Also improve the knn examples info.

---
 doc/index/rtree/query.qbk | 2 +-
 doc/quickref.xml          | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/index/rtree/query.qbk b/doc/index/rtree/query.qbk
index cbca27787..db90db102 100644
--- a/doc/index/rtree/query.qbk
+++ b/doc/index/rtree/query.qbk
@@ -95,7 +95,7 @@ Nearest neighbours queries returns `__value__`s which are closest to some Geomet
 The examples of k-NN queries are presented below. 5 `__value__`s nearest to the Geometry are orange.
 
 [table
-[[nearest(Point)] [nearest(Box)] [nearest(Segment)]]
+[[nearest(Point, k)] [nearest(Box, k)] [nearest(Segment, k)]]
 [[[$img/index/rtree/knn_pt_box.png]] [[$img/index/rtree/knn_box_box.png]] [[$img/index/rtree/knn_seg_box.png]]]
 ]
 
diff --git a/doc/quickref.xml b/doc/quickref.xml
index fff476c40..9e20847d3 100644
--- a/doc/quickref.xml
+++ b/doc/quickref.xml
@@ -741,7 +741,7 @@
 	 <member><link linkend="geometry.reference.spatial_indexes.group__predicates.overlaps_geometry_const___">overlaps(Geometry const &amp;)</link></member>
 	 <member><link linkend="geometry.reference.spatial_indexes.group__predicates.within_geometry_const___">within(Geometry const &amp;)</link></member>
 	 <member><link linkend="geometry.reference.spatial_indexes.group__predicates.satisfies_unarypredicate_const___">satisfies(UnaryPredicate const &amp;)</link></member>
-	 <member><link linkend="geometry.reference.spatial_indexes.group__predicates.nearest_point_const____unsigned_">nearest(Point const &amp;, unsigned)</link></member>
+	 <member><link linkend="geometry.reference.spatial_indexes.group__predicates.nearest_geometry_const____unsigned_">nearest(Geometry const &amp;, unsigned)</link></member>
     </simplelist>
    </entry>
    <!--entry valign="top">

From 949691799f67ff8b42f53ab96449b1515e50edd3 Mon Sep 17 00:00:00 2001
From: Menelaos Karavelas <menelaos.karavelas@gmail.com>
Date: Mon, 19 May 2014 01:38:39 +0300
Subject: [PATCH 11/22] [distance] fix bug in point-box distance computation in
 range-to-segment/box code

---
 .../algorithms/detail/distance/range_to_segment_or_box.hpp      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/geometry/algorithms/detail/distance/range_to_segment_or_box.hpp b/include/boost/geometry/algorithms/detail/distance/range_to_segment_or_box.hpp
index e1d113ff3..56ff37616 100644
--- a/include/boost/geometry/algorithms/detail/distance/range_to_segment_or_box.hpp
+++ b/include/boost/geometry/algorithms/detail/distance/range_to_segment_or_box.hpp
@@ -132,7 +132,7 @@ private:
             comparable_return_type cd_min =
                 strategy.apply(point, box_points[0], box_points[3]);
 
-            for (unsigned int i = 0; i < 2; ++i)
+            for (unsigned int i = 0; i < 3; ++i)
             {
                 comparable_return_type cd =
                     strategy.apply(point, box_points[i], box_points[i+1]);

From ba8d1b471d7f47ec8a08abd760ce9f5d8fcca806 Mon Sep 17 00:00:00 2001
From: Adam Wulkiewicz <adam.wulkiewicz@gmail.com>
Date: Mon, 19 May 2014 01:10:36 +0200
Subject: [PATCH 12/22] [index][example] Improve the rtree visualization.

Add support for rtrees storing Points and Segments.
Add the support for Segments in print_indexable() and gl_draw_indexable() index utilities.
---
 .../index/detail/rtree/utilities/gl_draw.hpp  |  62 +-
 .../index/detail/rtree/utilities/print.hpp    |  16 +
 index/example/glut_vis.cpp                    | 590 ++++++++++++------
 3 files changed, 456 insertions(+), 212 deletions(-)

diff --git a/include/boost/geometry/index/detail/rtree/utilities/gl_draw.hpp b/include/boost/geometry/index/detail/rtree/utilities/gl_draw.hpp
index 9b5e4d035..84201b6af 100644
--- a/include/boost/geometry/index/detail/rtree/utilities/gl_draw.hpp
+++ b/include/boost/geometry/index/detail/rtree/utilities/gl_draw.hpp
@@ -11,6 +11,8 @@
 #ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_GL_DRAW_HPP
 #define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_GL_DRAW_HPP
 
+#include <boost/mpl/assert.hpp>
+
 namespace boost { namespace geometry { namespace index { namespace detail {
 
 namespace utilities {
@@ -26,8 +28,16 @@ struct gl_draw_point<Point, 2>
 {
     static inline void apply(Point const& p, typename coordinate_type<Point>::type z)
     {
-        glBegin(GL_POINT);
-        glVertex3f(geometry::get<0>(p), geometry::get<1>(p), z);
+        typename coordinate_type<Point>::type const& x = geometry::get<0>(p);
+        typename coordinate_type<Point>::type const& y = geometry::get<1>(p);
+        /*glBegin(GL_POINT);
+        glVertex3f(x, y, z);
+        glEnd();*/
+        glBegin(GL_QUADS);
+        glVertex3f(x+1, y, z);
+        glVertex3f(x, y+1, z);
+        glVertex3f(x-1, y, z);
+        glVertex3f(x, y-1, z);
         glEnd();
     }
 };
@@ -50,32 +60,42 @@ struct gl_draw_box<Box, 2>
     }
 };
 
+template <typename Segment, size_t Dimension>
+struct gl_draw_segment
+{};
+
+template <typename Segment>
+struct gl_draw_segment<Segment, 2>
+{
+    static inline void apply(Segment const& s, typename coordinate_type<Segment>::type z)
+    {
+        glBegin(GL_LINES);
+        glVertex3f(geometry::get<0, 0>(s), geometry::get<0, 1>(s), z);
+        glVertex3f(geometry::get<1, 0>(s), geometry::get<1, 1>(s), z);
+        glEnd();
+    }
+};
+
 template <typename Indexable, typename Tag>
 struct gl_draw_indexable
 {
+    BOOST_MPL_ASSERT_MSG((false), NOT_IMPLEMENTED_FOR_THIS_TAG, (Tag));
 };
 
-template <typename Indexable>
-struct gl_draw_indexable<Indexable, box_tag>
-{
-    static const size_t dimension = geometry::dimension<Indexable>::value;
+template <typename Box>
+struct gl_draw_indexable<Box, box_tag>
+    : gl_draw_box<Box, geometry::dimension<Box>::value>
+{};
 
-    static inline void apply(Indexable const& i, typename coordinate_type<Indexable>::type z)
-    {
-        gl_draw_box<Indexable, dimension>::apply(i, z);
-    }
-};
+template <typename Point>
+struct gl_draw_indexable<Point, point_tag>
+    : gl_draw_point<Point, geometry::dimension<Point>::value>
+{};
 
-template <typename Indexable>
-struct gl_draw_indexable<Indexable, point_tag>
-{
-    static const size_t dimension = geometry::dimension<Indexable>::value;
-
-    static inline void apply(Indexable const& i, typename coordinate_type<Indexable>::type z)
-    {
-        gl_draw_point<Indexable, dimension>::apply(i, z);
-    }
-};
+template <typename Segment>
+struct gl_draw_indexable<Segment, segment_tag>
+    : gl_draw_segment<Segment, geometry::dimension<Segment>::value>
+{};
 
 } // namespace dispatch
 
diff --git a/include/boost/geometry/index/detail/rtree/utilities/print.hpp b/include/boost/geometry/index/detail/rtree/utilities/print.hpp
index 452471061..4c42659c6 100644
--- a/include/boost/geometry/index/detail/rtree/utilities/print.hpp
+++ b/include/boost/geometry/index/detail/rtree/utilities/print.hpp
@@ -66,6 +66,7 @@ struct print_corner<Box, Corner, 1>
 template <typename Indexable, typename Tag>
 struct print_indexable
 {
+    BOOST_MPL_ASSERT_MSG((false), NOT_IMPLEMENTED_FOR_THIS_TAG, (Tag));
 };
 
 template <typename Indexable>
@@ -96,6 +97,21 @@ struct print_indexable<Indexable, point_tag>
     }
 };
 
+template <typename Indexable>
+struct print_indexable<Indexable, segment_tag>
+{
+    static const size_t dimension = geometry::dimension<Indexable>::value;
+
+    static inline void apply(std::ostream &os, Indexable const& i)
+    {
+        os << '(';
+        print_corner<Indexable, 0, dimension>::apply(os, i);
+        os << ")-(";
+        print_corner<Indexable, 1, dimension>::apply(os, i);
+        os << ')';
+    }
+};
+
 } // namespace dispatch
 
 template <typename Indexable> inline
diff --git a/index/example/glut_vis.cpp b/index/example/glut_vis.cpp
index 755f4d300..865ac08b9 100644
--- a/index/example/glut_vis.cpp
+++ b/index/example/glut_vis.cpp
@@ -1,7 +1,7 @@
 // Boost.Geometry Index
-// Additional tests
+// OpenGL visualization
 
-// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
 
 // Use, modification and distribution is subject to the Boost Software License,
 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -26,29 +26,164 @@
 #include <boost/geometry/index/detail/rtree/utilities/are_levels_ok.hpp>
 #include <boost/geometry/index/detail/rtree/utilities/statistics.hpp>
 
+#include <boost/variant.hpp>
+
+#define ENABLE_POINTS_AND_SEGMENTS
+
 namespace bg = boost::geometry;
 namespace bgi = bg::index;
 
+// used types
+
 typedef bg::model::point<float, 2, boost::geometry::cs::cartesian> P;
 typedef bg::model::box<P> B;
-//bgi::rtree<B> t(2, 1);
 typedef bg::model::linestring<P> LS;
 typedef bg::model::segment<P> S;
 typedef bg::model::ring<P> R;
 typedef bg::model::polygon<P> Poly;
 typedef bg::model::multi_polygon<Poly> MPoly;
 
-typedef bgi::rtree<
-    B,
-    bgi::rstar<4, 2>
-> RTree;
-RTree t;
-std::vector<B> vect;
+// containers variant
+
+template <typename V>
+struct containers
+{
+    bgi::rtree< V, bgi::rstar<4, 2> > tree;
+    std::vector<V> values;
+    std::vector<V> result;
+};
+
+boost::variant<
+    containers<B>
+#ifdef ENABLE_POINTS_AND_SEGMENTS
+  , containers<P>
+  , containers<S>
+#endif
+> cont;
+
+// visitors
+
+template <typename Pred>
+struct query_v : boost::static_visitor<size_t>
+{
+    Pred m_pred;
+    query_v(Pred const& pred) : m_pred(pred) {}
+
+    template <typename C>
+    size_t operator()(C & c) const
+    {
+        c.result.clear();
+        return c.tree.query(m_pred, std::back_inserter(c.result));
+    }
+};
+template <typename Cont, typename Pred>
+inline size_t query(Cont & cont, Pred const& pred)
+{
+    return boost::apply_visitor(query_v<Pred>(pred), cont);
+}
+
+struct print_result_v : boost::static_visitor<>
+{
+    template <typename C>
+    void operator()(C & c) const
+    {
+        for ( size_t i = 0 ; i < c.result.size() ; ++i )
+        {
+            bgi::detail::utilities::print_indexable(std::cout, c.result[i]);
+            std::cout << '\n';
+        }
+    }
+};
+template <typename Cont>
+inline void print_result(Cont const& cont)
+{
+    boost::apply_visitor(print_result_v(), cont);
+}
+
+struct bounds_v : boost::static_visitor<B>
+{
+    template <typename C>
+    B operator()(C & c) const
+    {
+        return c.tree.bounds();
+    }
+};
+template <typename Cont>
+inline B bounds(Cont const& cont)
+{
+    return boost::apply_visitor(bounds_v(), cont);
+}
+
+struct depth_v : boost::static_visitor<size_t>
+{
+    template <typename C>
+    size_t operator()(C & c) const
+    {
+        return get(c.tree);
+    }
+    template <typename RTree>
+    static size_t get(RTree const& t)
+    {
+        return bgi::detail::rtree::utilities::view<RTree>(t).depth();
+    }
+};
+template <typename Cont>
+inline size_t depth(Cont const& cont)
+{
+    return boost::apply_visitor(depth_v(), cont);
+}
+
+struct draw_tree_v : boost::static_visitor<>
+{
+    template <typename C>
+    void operator()(C & c) const
+    {
+        bgi::detail::rtree::utilities::gl_draw(c.tree);
+    }
+};
+template <typename Cont>
+inline void draw_tree(Cont const& cont)
+{
+    return boost::apply_visitor(draw_tree_v(), cont);
+}
+
+struct draw_result_v : boost::static_visitor<>
+{
+    template <typename C>
+    void operator()(C & c) const
+    {
+        for ( size_t i = 0 ; i < c.result.size() ; ++i )
+        {
+            bgi::detail::utilities::gl_draw_indexable(c.result[i], depth_v::get(c.tree));
+        }
+    }
+};
+template <typename Cont>
+inline void draw_result(Cont const& cont)
+{
+    return boost::apply_visitor(draw_result_v(), cont);
+}
+
+struct print_tree_v : boost::static_visitor<>
+{
+    template <typename C>
+    void operator()(C & c) const
+    {
+        bgi::detail::rtree::utilities::print(std::cout, c.tree);        
+    }
+};
+template <typename Cont>
+inline void print_tree(Cont const& cont)
+{
+    return boost::apply_visitor(print_tree_v(), cont);
+}
+
+// globals used in querying
 
 size_t found_count = 0;
-P search_point;
 size_t count = 5;
-std::vector<B> nearest_boxes;
+
+P search_point;
 B search_box;
 R search_ring;
 Poly search_poly;
@@ -63,30 +198,24 @@ enum query_mode_type {
 
 bool search_valid = false;
 
+// various queries
+
 void query_knn()
 {
     float x = ( rand() % 1000 ) / 10.0f;
     float y = ( rand() % 1000 ) / 10.0f;
 
-    nearest_boxes.clear();
-
     if ( query_mode == qm_knn )
     {
         search_point = P(x, y);
-        found_count = t.query(
-                bgi::nearest(search_point, count),
-                std::back_inserter(nearest_boxes)
-            );
+        found_count = query(cont, bgi::nearest(search_point, count));
     }
     else if ( query_mode == qm_knnb )
     {
         float w = 2 + ( rand() % 1000 ) / 500.0f;
         float h = 2 + ( rand() % 1000 ) / 500.0f;
         search_box = B(P(x - w, y - h), P(x + w, y + h));
-        found_count = t.query(
-                bgi::nearest(search_box, count),
-                std::back_inserter(nearest_boxes)
-            );
+        found_count = query(cont, bgi::nearest(search_box, count));
     }
     else if ( query_mode == qm_knns )
     {
@@ -95,10 +224,7 @@ void query_knn()
         float w = (10 + ( rand() % 1000 ) / 100.0f) * signx;
         float h = (10 + ( rand() % 1000 ) / 100.0f) * signy;
         search_segment = S(P(x - w, y - h), P(x + w, y + h));
-        found_count = t.query(
-                bgi::nearest(search_segment, count),
-                std::back_inserter(nearest_boxes)
-            );
+        found_count = query(cont, bgi::nearest(search_segment, count));
     }
     else
     {
@@ -107,20 +233,33 @@ void query_knn()
 
     if ( found_count > 0 )
     {
-// TODO: print the correct indexable!
-        std::cout << "search point: ";
-        bgi::detail::utilities::print_indexable(std::cout, search_point);
-        std::cout << "\nfound: ";
-        for ( size_t i = 0 ; i < nearest_boxes.size() ; ++i )
+        if ( query_mode == qm_knn )
         {
-            bgi::detail::utilities::print_indexable(std::cout, nearest_boxes[i]);
-            std::cout << '\n';
+            std::cout << "search point: ";
+            bgi::detail::utilities::print_indexable(std::cout, search_point);
         }
+        else if ( query_mode == qm_knnb )
+        {
+            std::cout << "search box: ";
+            bgi::detail::utilities::print_indexable(std::cout, search_box);
+        }
+        else if ( query_mode == qm_knns )
+        {
+            std::cout << "search segment: ";
+            bgi::detail::utilities::print_indexable(std::cout, search_segment);
+        }
+        else
+        {
+            BOOST_ASSERT(false);
+        }
+        std::cout << "\nfound: ";
+        print_result(cont);
     }
     else
         std::cout << "nearest not found\n";
 }
 
+#ifndef ENABLE_POINTS_AND_SEGMENTS
 void query_path()
 {
     float x = ( rand() % 1000 ) / 10.0f;
@@ -136,11 +275,7 @@ void query_path()
         search_path[2 * i + 1] = P(x+w, yy);
     }
         
-    nearest_boxes.clear();
-    found_count = t.query(
-        bgi::detail::path<LS>(search_path, count),
-        std::back_inserter(nearest_boxes)
-        );
+    found_count = query(cont, bgi::detail::path<LS>(search_path, count));
 
     if ( found_count > 0 )
     {
@@ -148,15 +283,12 @@ void query_path()
         BOOST_FOREACH(P const& p, search_path)
             bgi::detail::utilities::print_indexable(std::cout, p);
         std::cout << "\nfound: ";
-        for ( size_t i = 0 ; i < nearest_boxes.size() ; ++i )
-        {
-            bgi::detail::utilities::print_indexable(std::cout, nearest_boxes[i]);
-            std::cout << '\n';
-        }
+        print_result(cont);
     }
     else
         std::cout << "values on path not found\n";
 }
+#endif
 
 template <typename Predicate>
 void query()
@@ -169,26 +301,20 @@ void query()
         float h = 10 + ( rand() % 1000 ) / 100.0f;
 
         search_box = B(P(x - w, y - h), P(x + w, y + h));
-        nearest_boxes.clear();
-        found_count = t.query(Predicate(search_box), std::back_inserter(nearest_boxes) );
     }
     else
     {
-        search_box = t.bounds();
-        nearest_boxes.clear();
-        found_count = t.query(Predicate(search_box), std::back_inserter(nearest_boxes) );
+        search_box = bounds(cont);
     }
 
+    found_count = query(cont, Predicate(search_box));
+
     if ( found_count > 0 )
     {
         std::cout << "search box: ";
         bgi::detail::utilities::print_indexable(std::cout, search_box);
         std::cout << "\nfound: ";
-        for ( size_t i = 0 ; i < nearest_boxes.size() ; ++i )
-        {
-            bgi::detail::utilities::print_indexable(std::cout, nearest_boxes[i]);
-            std::cout << '\n';
-        }
+        print_result(cont);
     }
     else
         std::cout << "boxes not found\n";
@@ -221,8 +347,7 @@ void query_ring()
     search_ring.push_back(P(x - w, y - h/2));
     search_ring.push_back(P(x - w, y - h));
         
-    nearest_boxes.clear();
-    found_count = t.query(Predicate(search_ring), std::back_inserter(nearest_boxes) );
+    found_count = query(cont, Predicate(search_ring));
     
     if ( found_count > 0 )
     {
@@ -233,11 +358,7 @@ void query_ring()
             std::cout << ' ';
         }
         std::cout << "\nfound: ";
-        for ( size_t i = 0 ; i < nearest_boxes.size() ; ++i )
-        {
-            bgi::detail::utilities::print_indexable(std::cout, nearest_boxes[i]);
-            std::cout << '\n';
-        }
+        print_result(cont);
     }
     else
         std::cout << "boxes not found\n";
@@ -277,8 +398,7 @@ void query_poly()
     search_poly.inners()[0].push_back(P(x - w/2, y + h/2));
     search_poly.inners()[0].push_back(P(x - w/2, y - h/2));
 
-    nearest_boxes.clear();
-    found_count = t.query(Predicate(search_poly), std::back_inserter(nearest_boxes) );
+    found_count = query(cont, Predicate(search_poly));
 
     if ( found_count > 0 )
     {
@@ -289,11 +409,7 @@ void query_poly()
             std::cout << ' ';
         }
         std::cout << "\nfound: ";
-        for ( size_t i = 0 ; i < nearest_boxes.size() ; ++i )
-        {
-            bgi::detail::utilities::print_indexable(std::cout, nearest_boxes[i]);
-            std::cout << '\n';
-        }
+        print_result(cont);
     }
     else
         std::cout << "boxes not found\n";
@@ -349,9 +465,8 @@ void query_multi_poly()
     search_multi_poly[2].outer().push_back(P(x + 6*w/5, y + 2*h));
     search_multi_poly[2].outer().push_back(P(x + 6*w/5, y + 6*h/5));
 
-    nearest_boxes.clear();
-    found_count = t.query(Predicate(search_multi_poly), std::back_inserter(nearest_boxes) );
-
+    found_count = query(cont, Predicate(search_multi_poly));
+    
     if ( found_count > 0 )
     {
         std::cout << "search multi_poly[0] outer: ";
@@ -361,11 +476,7 @@ void query_multi_poly()
             std::cout << ' ';
         }
         std::cout << "\nfound: ";
-        for ( size_t i = 0 ; i < nearest_boxes.size() ; ++i )
-        {
-            bgi::detail::utilities::print_indexable(std::cout, nearest_boxes[i]);
-            std::cout << '\n';
-        }
+        print_result(cont);
     }
     else
         std::cout << "boxes not found\n";
@@ -386,9 +497,8 @@ void query_segment()
     boost::geometry::set<1, 0>(search_segment, x + w);
     boost::geometry::set<1, 1>(search_segment, y + h);
 
-    nearest_boxes.clear();
-    found_count = t.query(Predicate(search_segment), std::back_inserter(nearest_boxes) );
-
+    found_count = query(cont, Predicate(search_segment));
+    
     if ( found_count > 0 )
     {
         std::cout << "search segment: ";
@@ -396,11 +506,7 @@ void query_segment()
         bgi::detail::utilities::print_indexable(std::cout, P(x+w, y+h));
 
         std::cout << "\nfound: ";
-        for ( size_t i = 0 ; i < nearest_boxes.size() ; ++i )
-        {
-            bgi::detail::utilities::print_indexable(std::cout, nearest_boxes[i]);
-            std::cout << '\n';
-        }
+        print_result(cont);
     }
     else
         std::cout << "boxes not found\n";
@@ -424,9 +530,8 @@ void query_linestring()
         search_linestring.push_back(P(xx, yy));
     }
 
-    nearest_boxes.clear();
-    found_count = t.query(Predicate(search_linestring), std::back_inserter(nearest_boxes) );
-
+    found_count = query(cont, Predicate(search_linestring));
+    
     if ( found_count > 0 )
     {
         std::cout << "search linestring: ";
@@ -436,44 +541,46 @@ void query_linestring()
             std::cout << ' ';
         }
         std::cout << "\nfound: ";
-        for ( size_t i = 0 ; i < nearest_boxes.size() ; ++i )
-        {
-            bgi::detail::utilities::print_indexable(std::cout, nearest_boxes[i]);
-            std::cout << '\n';
-        }
+        print_result(cont);
     }
     else
         std::cout << "boxes not found\n";
 }
 
+// the function running the correct query based on the query_mode
+
 void search()
 {
     namespace d = bgi::detail;
 
     if ( query_mode == qm_knn || query_mode == qm_knnb || query_mode == qm_knns )
         query_knn();
-    else if ( query_mode == qm_c )
-        query< d::spatial_predicate<B, d::covered_by_tag, false> >();
     else if ( query_mode == qm_d )
         query< d::spatial_predicate<B, d::disjoint_tag, false> >();
     else if ( query_mode == qm_i )
         query< d::spatial_predicate<B, d::intersects_tag, false> >();
+    else if ( query_mode == qm_nd )
+        query< d::spatial_predicate<B, d::disjoint_tag, true> >();
+    else if ( query_mode == qm_ni )
+        query< d::spatial_predicate<B, d::intersects_tag, true> >();
+    else if ( query_mode == qm_all )
+        query< d::spatial_predicate<B, d::intersects_tag, false> >();
+#ifdef ENABLE_POINTS_AND_SEGMENTS
+    else
+        std::cout << "query disabled\n";
+#else
+    else if ( query_mode == qm_c )
+        query< d::spatial_predicate<B, d::covered_by_tag, false> >();
     else if ( query_mode == qm_o )
         query< d::spatial_predicate<B, d::overlaps_tag, false> >();
     else if ( query_mode == qm_w )
         query< d::spatial_predicate<B, d::within_tag, false> >();
     else if ( query_mode == qm_nc )
         query< d::spatial_predicate<B, d::covered_by_tag, true> >();
-    else if ( query_mode == qm_nd )
-        query< d::spatial_predicate<B, d::disjoint_tag, true> >();
-    else if ( query_mode == qm_ni )
-        query< d::spatial_predicate<B, d::intersects_tag, true> >();
     else if ( query_mode == qm_no )
         query< d::spatial_predicate<B, d::overlaps_tag, true> >();
     else if ( query_mode == qm_nw )
         query< d::spatial_predicate<B, d::within_tag, true> >();
-    else if ( query_mode == qm_all )
-        query< d::spatial_predicate<B, d::intersects_tag, false> >();
     else if ( query_mode == qm_ri )
         query_ring< d::spatial_predicate<R, d::intersects_tag, false> >();
     else if ( query_mode == qm_pi )
@@ -486,15 +593,18 @@ void search()
         query_linestring< d::spatial_predicate<LS, d::intersects_tag, false> >();
     else if ( query_mode == qm_path )
         query_path();
+#endif
 
     search_valid = true;
 }
 
+// various drawing functions
+
 void draw_point(P const& p)
 {
     float x = boost::geometry::get<0>(p);
     float y = boost::geometry::get<1>(p);
-    float z = bgi::detail::rtree::utilities::view<RTree>(t).depth();
+    float z = depth(cont);
 
     glBegin(GL_QUADS);
     glVertex3f(x+1, y, z);
@@ -508,7 +618,7 @@ void draw_knn_area(float min_distance, float max_distance)
 {
     float x = boost::geometry::get<0>(search_point);
     float y = boost::geometry::get<1>(search_point);
-    float z = bgi::detail::rtree::utilities::view<RTree>(t).depth();
+    float z = depth(cont);
 
     draw_point(search_point);
 
@@ -535,7 +645,7 @@ void draw_linestring(LS const& ls)
     {
         float x = boost::geometry::get<0>(p);
         float y = boost::geometry::get<1>(p);
-        float z = bgi::detail::rtree::utilities::view<RTree>(t).depth();
+        float z = depth(cont);
         glVertex3f(x, y, z);
     }
 
@@ -548,7 +658,7 @@ void draw_segment(S const& s)
     float y1 = boost::geometry::get<0, 1>(s);
     float x2 = boost::geometry::get<1, 0>(s);
     float y2 = boost::geometry::get<1, 1>(s);
-    float z = bgi::detail::rtree::utilities::view<RTree>(t).depth();
+    float z = depth(cont);
 
     glBegin(GL_LINES);
     glVertex3f(x1, y1, z);
@@ -563,7 +673,7 @@ void draw_box(Box const& box)
     float y1 = boost::geometry::get<bg::min_corner, 1>(box);
     float x2 = boost::geometry::get<bg::max_corner, 0>(box);
     float y2 = boost::geometry::get<bg::max_corner, 1>(box);
-    float z = bgi::detail::rtree::utilities::view<RTree>(t).depth();
+    float z = depth(cont);
 
     // search box
     glBegin(GL_LINE_LOOP);
@@ -577,7 +687,7 @@ void draw_box(Box const& box)
 template <typename Range>
 void draw_ring(Range const& range)
 {
-    float z = bgi::detail::rtree::utilities::view<RTree>(t).depth();
+    float z = depth(cont);
 
     // search box
     glBegin(GL_LINE_LOOP);
@@ -607,11 +717,13 @@ void draw_multi_polygon(MultiPolygon const& multi_polygon)
         draw_polygon(p);
 }
 
+// render the scene -> tree, if searching data available also the query geometry and result
+
 void render_scene(void)
 {
     glClear(GL_COLOR_BUFFER_BIT);
 
-    bgi::detail::rtree::utilities::gl_draw(t);
+    draw_tree(cont);
 
     if ( search_valid )
     {
@@ -640,10 +752,7 @@ void render_scene(void)
 
         glColor3f(1.0f, 0.5f, 0.0f);
 
-        for ( size_t i = 0 ; i < nearest_boxes.size() ; ++i )
-            bgi::detail::utilities::gl_draw_indexable(
-                nearest_boxes[i],
-                bgi::detail::rtree::utilities::view<RTree>(t).depth());
+        draw_result(cont);
     }
 
     glFlush();
@@ -680,49 +789,100 @@ void resize(int w, int h)
     srand(1);
 }
 
+// randomize various indexables
+
+inline void rand_val(B & b)
+{
+    float x = ( rand() % 100 );
+    float y = ( rand() % 100 );
+    float w = ( rand() % 2 ) + 1;
+    float h = ( rand() % 2 ) + 1;
+    b = B(P(x - w, y - h),P(x + w, y + h));
+}
+inline void rand_val(P & p)
+{
+    float x = ( rand() % 100 );
+    float y = ( rand() % 100 );
+    p = P(x, y);
+}
+inline void rand_val(S & s)
+{
+    float x = ( rand() % 100 );
+    float y = ( rand() % 100 );
+    float w = ( rand() % 2 + 1) * (rand() % 2 ? 1.0f : -1.0f);
+    float h = ( rand() % 2 + 1) * (rand() % 2 ? 1.0f : -1.0f);
+    s = S(P(x - w, y - h),P(x + w, y + h));
+}
+
+// more higher-level visitors
+
+struct insert_random_value_v : boost::static_visitor<>
+{
+    template <typename V>
+    void operator()(containers<V> & c) const
+    {
+        V v;
+        rand_val(v);
+        
+        boost::geometry::index::insert(c.tree, v);
+        c.values.push_back(v);
+
+        std::cout << "inserted: ";
+        bgi::detail::utilities::print_indexable(std::cout, v);
+        std::cout << '\n';
+
+        std::cout << ( bgi::detail::rtree::utilities::are_boxes_ok(c.tree) ? "boxes OK\n" : "WRONG BOXES!\n" );
+        std::cout << ( bgi::detail::rtree::utilities::are_levels_ok(c.tree) ? "levels OK\n" : "WRONG LEVELS!\n" );
+        std::cout << "\n";
+    }
+};
+template <typename Cont>
+inline void insert_random_value(Cont & cont)
+{
+    return boost::apply_visitor(insert_random_value_v(), cont);
+}
+
+struct remove_random_value_v : boost::static_visitor<>
+{
+    template <typename V>
+    void operator()(containers<V> & c) const
+    {
+        if ( c.values.empty() )
+            return;
+
+        size_t i = rand() % c.values.size();
+        V v = c.values[i];
+
+        c.tree.remove(v);
+        c.values.erase(c.values.begin() + i);
+
+        std::cout << "removed: ";
+        bgi::detail::utilities::print_indexable(std::cout, v);
+        std::cout << '\n';
+
+        std::cout << ( bgi::detail::rtree::utilities::are_boxes_ok(c.tree) ? "boxes OK\n" : "WRONG BOXES!\n" );
+        std::cout << ( bgi::detail::rtree::utilities::are_levels_ok(c.tree) ? "levels OK\n" : "WRONG LEVELS!\n" );
+        std::cout << "\n";
+    }
+};
+template <typename Cont>
+inline void remove_random_value(Cont & cont)
+{
+    return boost::apply_visitor(remove_random_value_v(), cont);
+}
+
+// handle mouse input
+
 void mouse(int button, int state, int /*x*/, int /*y*/)
 {
     if ( button == GLUT_LEFT_BUTTON && state == GLUT_DOWN )
     {
-        float x = ( rand() % 100 );
-        float y = ( rand() % 100 );
-        float w = ( rand() % 2 ) + 1;
-        float h = ( rand() % 2 ) + 1;
-
-        B b(P(x - w, y - h),P(x + w, y + h));
-
-        boost::geometry::index::insert(t, b);
-        vect.push_back(b);
-
-        std::cout << "inserted: ";
-        bgi::detail::utilities::print_indexable(std::cout, b);
-        std::cout << '\n';
-
-        std::cout << ( bgi::detail::rtree::utilities::are_boxes_ok(t) ? "boxes OK\n" : "WRONG BOXES!\n" );
-        std::cout << ( bgi::detail::rtree::utilities::are_levels_ok(t) ? "levels OK\n" : "WRONG LEVELS!\n" );
-        std::cout << "\n";
-
+        insert_random_value(cont);
         search_valid = false;
     }
     else if ( button == GLUT_RIGHT_BUTTON && state == GLUT_DOWN )
     {
-        if ( vect.empty() )
-            return;
-
-        size_t i = rand() % vect.size();
-        B b = vect[i];
-
-        bgi::remove(t, b);
-        vect.erase(vect.begin() + i);
-
-        std::cout << "removed: ";
-        bgi::detail::utilities::print_indexable(std::cout, b);
-        std::cout << '\n';
-
-        std::cout << ( bgi::detail::rtree::utilities::are_boxes_ok(t) ? "boxes OK\n" : "WRONG BOXES!\n" );
-        std::cout << ( bgi::detail::rtree::utilities::are_levels_ok(t) ? "levels OK\n" : "WRONG LEVELS!\n" );
-        std::cout << "\n";
-
+        remove_random_value(cont);
         search_valid = false;
     }
     else if ( button == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN )
@@ -733,71 +893,117 @@ void mouse(int button, int state, int /*x*/, int /*y*/)
     glutPostRedisplay();
 }
 
+// more higher-level visitors
+
+struct insert_random_values_v : boost::static_visitor<>
+{
+    template <typename V>
+    void operator()(containers<V> & c) const
+    {
+        for ( size_t i = 0 ; i < 35 ; ++i )
+        {
+            V v;
+            rand_val(v);
+
+            c.tree.insert(v);
+            c.values.push_back(v);
+
+            std::cout << "inserted: ";
+            bgi::detail::utilities::print_indexable(std::cout, v);
+            std::cout << '\n';
+        }
+
+        std::cout << ( bgi::detail::rtree::utilities::are_boxes_ok(c.tree) ? "boxes OK\n" : "WRONG BOXES!\n" );
+        std::cout << ( bgi::detail::rtree::utilities::are_levels_ok(c.tree) ? "levels OK\n" : "WRONG LEVELS!\n" );
+        std::cout << "\n";
+    }
+};
+template <typename Cont>
+inline void insert_random_values(Cont & cont)
+{
+    return boost::apply_visitor(insert_random_values_v(), cont);
+}
+
+struct bulk_insert_random_values_v : boost::static_visitor<>
+{
+    template <typename V>
+    void operator()(containers<V> & c) const
+    {
+        c.values.clear();
+
+        for ( size_t i = 0 ; i < 35 ; ++i )
+        {
+            V v;
+            rand_val(v);
+
+            c.values.push_back(v);
+
+            std::cout << "inserted: ";
+            bgi::detail::utilities::print_indexable(std::cout, v);
+            std::cout << '\n';
+        }
+
+        create(c.tree, c.values);
+
+        std::cout << ( bgi::detail::rtree::utilities::are_boxes_ok(c.tree) ? "boxes OK\n" : "WRONG BOXES!\n" );
+        std::cout << ( bgi::detail::rtree::utilities::are_levels_ok(c.tree) ? "levels OK\n" : "WRONG LEVELS!\n" );
+        std::cout << "\n";
+    }
+
+    template <typename Tree, typename Values>
+    void create(Tree & tree, Values const& values) const
+    {
+        Tree t(values);
+        tree = boost::move(t);
+    }
+};
+template <typename Cont>
+inline void bulk_insert_random_values(Cont & cont)
+{
+    return boost::apply_visitor(bulk_insert_random_values_v(), cont);
+}
+
+// handle keyboard input
+
 std::string current_line;
 
 void keyboard(unsigned char key, int /*x*/, int /*y*/)
 {
     if ( key == '\r' || key == '\n' )
     {
-        if ( current_line == "t" )
+        if ( current_line == "storeb" )
+        {
+            cont = containers<B>();
+            glutPostRedisplay();
+        }
+#ifdef ENABLE_POINTS_AND_SEGMENTS
+        else if ( current_line == "storep" )
+        {
+            cont = containers<P>();
+            glutPostRedisplay();
+        }
+        else if ( current_line == "stores" )
+        {
+            cont = containers<S>();
+            glutPostRedisplay();
+        }
+#endif
+        else if ( current_line == "t" )
         {
             std::cout << "\n";
-            bgi::detail::rtree::utilities::print(std::cout, t);
+            print_tree(cont);
             std::cout << "\n";
         }
         else if ( current_line == "rand" )
         {
-            for ( size_t i = 0 ; i < 35 ; ++i )
-            {
-                float x = ( rand() % 100 );
-                float y = ( rand() % 100 );
-                float w = ( rand() % 2 ) + 1;
-                float h = ( rand() % 2 ) + 1;
-
-                B b(P(x - w, y - h),P(x + w, y + h));
-
-                boost::geometry::index::insert(t, b);
-                vect.push_back(b);
-
-                std::cout << "inserted: ";
-                bgi::detail::utilities::print_indexable(std::cout, b);
-                std::cout << '\n';
-            }
-
-            std::cout << ( bgi::detail::rtree::utilities::are_boxes_ok(t) ? "boxes OK\n" : "WRONG BOXES!\n" );
-            std::cout << ( bgi::detail::rtree::utilities::are_levels_ok(t) ? "levels OK\n" : "WRONG LEVELS!\n" );
-            std::cout << "\n";
-
+            insert_random_values(cont);
             search_valid = false;
 
             glutPostRedisplay();
         }
         else if ( current_line == "bulk" )
         {
-            vect.clear();
-
-            for ( size_t i = 0 ; i < 35 ; ++i )
-            {
-                float x = ( rand() % 100 );
-                float y = ( rand() % 100 );
-                float w = ( rand() % 2 ) + 1;
-                float h = ( rand() % 2 ) + 1;
-
-                B b(P(x - w, y - h),P(x + w, y + h));
-                vect.push_back(b);
-
-                std::cout << "inserted: ";
-                bgi::detail::utilities::print_indexable(std::cout, b);
-                std::cout << '\n';
-            }
-
-            RTree t2(vect);
-            t = boost::move(t2);
-
-            std::cout << ( bgi::detail::rtree::utilities::are_boxes_ok(t) ? "boxes OK\n" : "WRONG BOXES!\n" );
-            std::cout << ( bgi::detail::rtree::utilities::are_levels_ok(t) ? "levels OK\n" : "WRONG LEVELS!\n" );
-            std::cout << "\n";
-
+            bulk_insert_random_values(cont);
             search_valid = false;
 
             glutPostRedisplay();
@@ -859,6 +1065,8 @@ void keyboard(unsigned char key, int /*x*/, int /*y*/)
     }
 }
 
+// main function
+
 int main(int argc, char **argv)
 {
     glutInit(&argc, argv);

From 92b0491b221483022711061034f56f6df7f65be4 Mon Sep 17 00:00:00 2001
From: Adam Wulkiewicz <adam.wulkiewicz@gmail.com>
Date: Mon, 19 May 2014 01:44:32 +0200
Subject: [PATCH 13/22] [doc] Add info about Segments Indexables and more
 pictures.

---
 doc/html/img/index/rtree/rtree_pt.png            | Bin 0 -> 2643 bytes
 .../img/index/rtree/rtree_pt_disjoint_box.png    | Bin 0 -> 2857 bytes
 .../img/index/rtree/rtree_pt_intersects_box.png  | Bin 0 -> 2817 bytes
 doc/html/img/index/rtree/rtree_pt_knn_box.png    | Bin 0 -> 2749 bytes
 doc/html/img/index/rtree/rtree_pt_knn_pt.png     | Bin 0 -> 2744 bytes
 doc/html/img/index/rtree/rtree_pt_knn_seg.png    | Bin 0 -> 3033 bytes
 doc/html/img/index/rtree/rtree_seg.png           | Bin 0 -> 3495 bytes
 .../img/index/rtree/rtree_seg_disjoint_box.png   | Bin 0 -> 3629 bytes
 .../img/index/rtree/rtree_seg_intersects_box.png | Bin 0 -> 3703 bytes
 doc/html/img/index/rtree/rtree_seg_knn_box.png   | Bin 0 -> 3625 bytes
 doc/html/img/index/rtree/rtree_seg_knn_pt.png    | Bin 0 -> 3576 bytes
 doc/html/img/index/rtree/rtree_seg_knn_seg.png   | Bin 0 -> 3805 bytes
 doc/index/rtree/creation.qbk                     |  14 +++++++++++---
 doc/index/rtree/query.qbk                        |   7 +++++++
 14 files changed, 18 insertions(+), 3 deletions(-)
 create mode 100644 doc/html/img/index/rtree/rtree_pt.png
 create mode 100644 doc/html/img/index/rtree/rtree_pt_disjoint_box.png
 create mode 100644 doc/html/img/index/rtree/rtree_pt_intersects_box.png
 create mode 100644 doc/html/img/index/rtree/rtree_pt_knn_box.png
 create mode 100644 doc/html/img/index/rtree/rtree_pt_knn_pt.png
 create mode 100644 doc/html/img/index/rtree/rtree_pt_knn_seg.png
 create mode 100644 doc/html/img/index/rtree/rtree_seg.png
 create mode 100644 doc/html/img/index/rtree/rtree_seg_disjoint_box.png
 create mode 100644 doc/html/img/index/rtree/rtree_seg_intersects_box.png
 create mode 100644 doc/html/img/index/rtree/rtree_seg_knn_box.png
 create mode 100644 doc/html/img/index/rtree/rtree_seg_knn_pt.png
 create mode 100644 doc/html/img/index/rtree/rtree_seg_knn_seg.png

diff --git a/doc/html/img/index/rtree/rtree_pt.png b/doc/html/img/index/rtree/rtree_pt.png
new file mode 100644
index 0000000000000000000000000000000000000000..8c3f5807efbdbdf3b547ec1238465578e007c2a4
GIT binary patch
literal 2643
zcmeAS@N?(olHy`uVBq!ia0y~yU^olH9Bd2>4AOhPWHK-?uqAoByD<C*!3BGlPiA0X
z;4JWnEM{Qf76xHPhFNnY7#JAXOFVsD+3&Fmi3@2oS*&trU|^8V42dXl&d<$F%`0I5
z0q3IB#FEq$h4Rdj3<Y;j-+&aoRCWdi&h4Hqjv*Dd-rn6E^w>b6?P2_xWhYcsg}XGS
zyKLPo&BZi5b!h^-o@Og|{zT@+BkVUPtv&qPbk<x}VQEkPX(^GRp`o0LON!-ou(Vvr
z;8=K3z-h5!i<>h?ZySR3WcJg?MzhYZdKJb}^Y8Z*=gJ8`bNpr|tu!wZn7H%Alc)E$
z?z>|BImyLKaAxQAPs!gdR@8pEn*Qoa#+iE;zAly7%lYc@p0!_>9-8&mqBQ^Go(b2d
zUw?Kw<Z?ll^w}D-=|{61S-lP1G-r07P@0h1p0(cP{g;ggE5zK=lz#nOZ78x#;P$Wo
ztKYfsJ#D--wZQ4u+pyPOQ&v2-_mW&{bNbryf7i`sEn}YaL-<zy_Ne~l^DcVbyY_3H
zQS7V#%$F2=`+i<7x_>X^zx)KYOpE#@igHUkGwo7O{4Dl&&f8QeK5_3RxzbtZpKZE0
z``B;BC5kUiC6t@p=DPG9KH|}AQkkk2v{uJ`%{3+Iy+3F9J4!7%sg=4vfA^oruw%8q
zoR=hi(Mir!`}<F1Y2~lKB40e08+8fKHaWM?erxrt?RRgdPDxo4y1drCFz)-acdsJP
zmgRXE-?TmJk=^*K?~zR17n$dmG+Ym7oOty8z|kEZpKa5!UEY^$NdD**^7y&+`bVnY
z7net+s2zS5J>gm1VNT23`TZOB|FhM+^hL&&d!PDD-q)T*eK+Oii%Wi)&T`4+#^fo7
ztAwQbK34sm$d-ADdvW@|C7fk;ESbxuCaGlBT(#HFK7Vepw&S_$3cg~OzO1Z|ozGCJ
z=ezJ}nw`p)%30fvws}l$Guifa{p(lR`j=`lCc1{Y{C>l7>4<*s+nR+|_VOlIZO`tU
zd-T@^!AnaNd%tSLzg$-LCHkpM<y?nZKbF4yTI@7I?V5tG)TJB$=B&$pHGwU2f?Hqq
zt8<HUJ(^8CE`R-guh3Wak^=9gj=Qt0mN-f+*_mYll6m~_^+dMJ3CBKxDYi_IMl`Zb
zffu9^gLISvnS(}hE?r)>wOs!a$eS_m?{=GbG@Hb>T5SEWuKJS_@1+#ovz6w8n@yXm
zjg~mh%2~4WjhfL0b!Vw1C!J>H+p>b}iTEZ0a#%A+CxYRO#bIoj6ToisU3Te?O?@j!
z!`J_%-+yX@+_h1J5#*Uy|5qCveS3Qj$dk){?$3{_?*pl;+b5T)H09XUb=Et*FMogC
z?(tdMBlFbDB|k&F_?Ex_9{Ml#_30J;m4@-ptrx7hCVENX?2k(`f}3~#tIL17Q(gP0
zXXf5&{!0qItIykuPjn5fv^{z@uJhi@+p}-X3#@*+*4<5N3Fou87n@%DJ+L*p6k#$e
z#{K-W<oW3!o{P%aN8gn)Gv|E2;xT!<N!4=p_b+=)JSNXE`Tk6ERcYx<%~?@amlV!U
zx#VM1Rkqja>ph#+n^G68b<?t4{sw>hEavvaS(*2eikk0jo1<svotyUb@~Zo`f|nG0
zCtQlzp7MI;o4!dW-$dLx*Q&sKsYTy6;kf&(JV~ovlABE?_spAn-}!Nt+nuK$CoZ$q
zb2Fc~EdA)aN&8ke{yw)u*;k@ob4%^HTUCZ%ZF>Vxoz{vsJTCWeQ`)LD5g+^SF}yYl
z)Lm!g$xb@GwK#YF=XBeZYsDvfC3CG`UBj(A*ZttHb!_Xx{<29-IJW+Y+0J>}Uq|Wh
z`giZI$LD{F-Bb6^-s`t~+dFe6GZhcxi_i13EaYCb&aa+j)RQiMJjcMp_~CQ;opC=T
zZD&9IImPx;i|W~s{m)k{m9+K{Za3Lie;$$)9)ESXSJvC<GHc;yMNO~I+?o5*KkF$i
zuWWq%li@kD5TnQC>UnRz{N4BLW6gAr$D0mHtens9;W2C3&;E6v6^}mtE@!=MQ|@Px
zB^%!~o)=E>nzDc9`_82=x9r-JX}82{x0J%!2D#g}&y-94_~<8DJx^ywwVc~|wl6m}
zPptFHIDXp3!+6PYJ@;Rhjb4+pC$MF5T>5ePtZ*mDX~FY%`>QDNUQ*~y<!?5*!n|bV
z`MY~rL5X(R-iHdjj<XbP%^<1!21t3c2@5E7g5*(i8^<LDUgRuQsMh?oF59Eo#L~O?
z@3(AF%6?f9^ZIqaiO1y4Cas!p?n`!=cud}Ha_x7oBJZUqI=%wOou!s^`byot^JbCr
z9?!#Z=Y+j3Z_BQ~9`t_8iJU**CoAz@>QU=GyYBC`-M@vGc!tjM+x@M)2UK!PrA|nj
z)wAvJvd4dJN@rPJ>Y4w#n)!2*-ldj*$Mh!(-WTmM@d&QIH*xRB)o;(nv1IO9VsP{=
zhe)Yl=7eQ?9||1mVsM(!c0}s+^A<I$ynyc}^SxZZ-}@<X>g;ZwxX1^)ubhv6|KCvm
z*y+Of@5jz&Jo)V|0m@XJi6&ahijt4~<YJD0dj6v4_2aQp?$@_EuDiH&CimgR=Zd2a
zhplDWzb@PV^<%%|rqRVy(i8q#oj=W5?0<Ofq~$J~iVj|X@#N`_rT?p}e!Y-PE}D1f
zvx(n&Pz7XG_%%lG(uKom6L;r7cav%|(fxWlaIdS>l9Nj1_s{j3uw>qn=DQ@YWaa}a
zg|i$Vw=P?ieWUl-+8w@MOTLIQ&Mx11CZT;_Sk{SITGOi;wmf~-dD&&%>e88uObpjf
zl-jk->+MyO#crK(_t!05z0}3gQ~0Qq=IuWb!KF9P=PbEX`)JCNV*kmnG|v0B>Z<?y
zd1SW9WBZ*mPiycmj`V0YnWGL$4+2XZrJ77UK*bx!r3=i;prZD<Cpc{>@P3@TJoN9X
zkDk}&De@MIe)ZoOzjfa=qv^kFZ%ts!e3WZY{j~n7)g=YruIo3yuBue^`m*ky>@tsL
zlbGk$nYXeVE*dX+Xca9do;jiIbxvi>5=W_Z#+O<I%i0~KsuH?)+zFnc;A?j2!?~a(
zj#6;$j$6Sq6nGb>vt&+C`~2BOYRN;Jo#zgEPComG^^!twcZz9!qlw33t(#}!6?iZ0
z@Cf@X?$K<bC(UQ805WxnqtvrZi}Mzba!s~9{C-@H(L*?Q&)#g2%n52we^g!1_}F3M
zF*%`TZ}t_9qkOYHCYK%ls1z~Zt=VKw`Z-6bC5j%+CMwC9)B3%aC<b~iUbSl1O^)kt
z`m>MlJw2GYQ)l}9^7Q&^@%ERWT2w2feyn)2k<UpodFP5%?|PrzDX2+Nj_+rEF?XNI
ziYwQah|aoa_3Xu}O_S5k{E$djKa#GNZ_;vP8oM5&V%bmrWj7ig@A_TK0&3fNy85}S
Ib4q9e0043fcK`qY

literal 0
HcmV?d00001

diff --git a/doc/html/img/index/rtree/rtree_pt_disjoint_box.png b/doc/html/img/index/rtree/rtree_pt_disjoint_box.png
new file mode 100644
index 0000000000000000000000000000000000000000..e82275f1a27b49ab6ebf5731ae3fdf1b2016d504
GIT binary patch
literal 2857
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

literal 0
HcmV?d00001

diff --git a/doc/html/img/index/rtree/rtree_pt_intersects_box.png b/doc/html/img/index/rtree/rtree_pt_intersects_box.png
new file mode 100644
index 0000000000000000000000000000000000000000..46baf009b50c7017fa45e3b4a9aeea2f29b0770b
GIT binary patch
literal 2817
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

literal 0
HcmV?d00001

diff --git a/doc/html/img/index/rtree/rtree_pt_knn_box.png b/doc/html/img/index/rtree/rtree_pt_knn_box.png
new file mode 100644
index 0000000000000000000000000000000000000000..237de694c00905c530530c363ac47d389d6535d9
GIT binary patch
literal 2749
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

literal 0
HcmV?d00001

diff --git a/doc/html/img/index/rtree/rtree_pt_knn_pt.png b/doc/html/img/index/rtree/rtree_pt_knn_pt.png
new file mode 100644
index 0000000000000000000000000000000000000000..55d0a2d381d0e9821640f84fd55b67d49e34ee18
GIT binary patch
literal 2744
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

literal 0
HcmV?d00001

diff --git a/doc/html/img/index/rtree/rtree_pt_knn_seg.png b/doc/html/img/index/rtree/rtree_pt_knn_seg.png
new file mode 100644
index 0000000000000000000000000000000000000000..fc3e13811069855c86aaa80424dc88b91edc7b90
GIT binary patch
literal 3033
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

literal 0
HcmV?d00001

diff --git a/doc/html/img/index/rtree/rtree_seg.png b/doc/html/img/index/rtree/rtree_seg.png
new file mode 100644
index 0000000000000000000000000000000000000000..080433318e450d50828d35b56a7dd0e171e393b4
GIT binary patch
literal 3495
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
KKbLh*2~7YZTao+#

literal 0
HcmV?d00001

diff --git a/doc/html/img/index/rtree/rtree_seg_disjoint_box.png b/doc/html/img/index/rtree/rtree_seg_disjoint_box.png
new file mode 100644
index 0000000000000000000000000000000000000000..72cc1e71a9b76b396d46b71166d50e4005dd39ba
GIT binary patch
literal 3629
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
YzWK-HuUj07;y}GNPgg&ebxsLQ08{bsl>h($

literal 0
HcmV?d00001

diff --git a/doc/html/img/index/rtree/rtree_seg_intersects_box.png b/doc/html/img/index/rtree/rtree_seg_intersects_box.png
new file mode 100644
index 0000000000000000000000000000000000000000..b6135eedaec74fb9b2bd38c032bdd69cbc689c44
GIT binary patch
literal 3703
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
HDWM4fSM&n)

literal 0
HcmV?d00001

diff --git a/doc/html/img/index/rtree/rtree_seg_knn_box.png b/doc/html/img/index/rtree/rtree_seg_knn_box.png
new file mode 100644
index 0000000000000000000000000000000000000000..251117688cd5bc397f3fd1fe7748cc77d3ea555d
GIT binary patch
literal 3625
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

literal 0
HcmV?d00001

diff --git a/doc/html/img/index/rtree/rtree_seg_knn_pt.png b/doc/html/img/index/rtree/rtree_seg_knn_pt.png
new file mode 100644
index 0000000000000000000000000000000000000000..8def785020351d38a155c1d4990de934c4ff9e4e
GIT binary patch
literal 3576
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

literal 0
HcmV?d00001

diff --git a/doc/html/img/index/rtree/rtree_seg_knn_seg.png b/doc/html/img/index/rtree/rtree_seg_knn_seg.png
new file mode 100644
index 0000000000000000000000000000000000000000..68891d68534192551e583f7df45d01db057b70d3
GIT binary patch
literal 3805
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
Y{bs*>{`JB4G*B<o)78&qol`;+01d`8mjD0&

literal 0
HcmV?d00001

diff --git a/doc/index/rtree/creation.qbk b/doc/index/rtree/creation.qbk
index 0cb5d998b..6ea609b08 100644
--- a/doc/index/rtree/creation.qbk
+++ b/doc/index/rtree/creation.qbk
@@ -30,13 +30,20 @@ __rtree__ has 5 parameters but only 2 are required:
 
 __rtree__ may store `__value__`s of any type as long as passed function objects know how to interpret those `__value__`s, that is
 extract an `__indexable__` that the __rtree__ can handle and compare `__value__`s.
+The `__indexable__` is a type adapted to Point, Box or Segment concept.
+The examples of rtrees storing `__value__`s translatable to various `__indexable__`s are presented below.
+
+[table
+[[rtree<Point, ...>] [rtree<Box, ...>] [rtree<Segment, ...>]]
+[[[$img/index/rtree/rtree_pt.png]] [[$img/index/rtree/rstar.png]] [[$img/index/rtree/rtree_seg.png]]]
+]
 
 By default function objects `index::indexable<Value>` and `index::equal_to<Value>` are defined for some typically used `__value__`
 types which may be stored without defining any additional classes. By default the rtree may store pure `__indexable__`s, pairs
 and tuples. In the case of those two collection types, the `__indexable__` must be the first stored type.
 
-* `__indexable__ = __point__ | __box__`
-* `__value__ = Indexable | std::pair<__indexable__, T> | tuple<__indexable__, ...>`
+* `__indexable__ = __point__ | __box__ | Segment`
+* `__value__ = Indexable | std::pair<__indexable__, T> | boost::tuple<__indexable__, ...> [ | std::tuple<__indexable__, ...> ]`
 
 By default `boost::tuple<...>` is supported on all compilers. If the compiler supports C++11 tuples and variadic templates
 then `std::tuple<...>` may be used "out of the box" as well.
@@ -46,6 +53,7 @@ Examples of default `__value__` types:
  geometry::model::point<...>
  geometry::model::point_xy<...>
  geometry::model::box<...>
+ geometry::model::segment<...>
  std::pair<geometry::model::box<...>, unsigned>
  boost::tuple<geometry::model::point<...>, int, float>
 
@@ -55,7 +63,7 @@ The predefined `index::indexable<Value>` returns const reference to the `__index
 
 The predefined `index::equal_to<Value>`:
 
-* for `__point__` and `__box__` - compares `__value__`s with geometry::equals().
+* for `__point__`, `__box__` and `Segment` - compares `__value__`s with geometry::equals().
 * for `std::pair<...>` - compares both components of the `__value__`. The first value stored in the pair is compared before the second one.
   If the value stored in the pair is a Geometry, `geometry::equals()` is used. For other types it uses `operator==()`.
 * for `tuple<...>` - compares all components of the `__value__`. If the component is a `Geometry`, `geometry::equals()`
diff --git a/doc/index/rtree/query.qbk b/doc/index/rtree/query.qbk
index db90db102..940e9b8c3 100644
--- a/doc/index/rtree/query.qbk
+++ b/doc/index/rtree/query.qbk
@@ -73,6 +73,11 @@ Examples of some basic queries may be found in the tables below. The query regio
 [[[$img/index/rtree/intersects_ring.png]] [[$img/index/rtree/intersects_poly.png]] [[$img/index/rtree/intersects_mpoly.png]] [[$img/index/rtree/intersects_segment.png]] [[$img/index/rtree/intersects_linestring.png]]]
 ]
 
+[table
+[[intersects(Box)] [disjoint(Box)] [intersects(Box)] [disjoint(Box)]]
+[[[$img/index/rtree/rtree_pt_intersects_box.png]] [[$img/index/rtree/rtree_pt_disjoint_box.png]] [[$img/index/rtree/rtree_seg_intersects_box.png]] [[$img/index/rtree/rtree_seg_disjoint_box.png]]]
+]
+
 Spatial predicates are generated by functions defined in `boost::geometry::index` namespace.
 
  rt.query(index::contains(box), std::back_inserter(result));
@@ -97,6 +102,8 @@ The examples of k-NN queries are presented below. 5 `__value__`s nearest to the
 [table
 [[nearest(Point, k)] [nearest(Box, k)] [nearest(Segment, k)]]
 [[[$img/index/rtree/knn_pt_box.png]] [[$img/index/rtree/knn_box_box.png]] [[$img/index/rtree/knn_seg_box.png]]]
+[[[$img/index/rtree/rtree_pt_knn_pt.png]] [[$img/index/rtree/rtree_pt_knn_box.png]] [[$img/index/rtree/rtree_pt_knn_seg.png]]]
+[[[$img/index/rtree/rtree_seg_knn_pt.png]] [[$img/index/rtree/rtree_seg_knn_box.png]] [[$img/index/rtree/rtree_seg_knn_seg.png]]]
 ]
 
 To perform the knn query one must pass the nearest predicate generated by the

From 2df9ea51fed5d32e50879c21bea9a2cd11f97213 Mon Sep 17 00:00:00 2001
From: Adam Wulkiewicz <adam.wulkiewicz@gmail.com>
Date: Mon, 19 May 2014 01:56:06 +0200
Subject: [PATCH 14/22] [doc/index] Updated example rtree pack creation time,
 after optimization.

---
 doc/index/introduction.qbk | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/index/introduction.qbk b/doc/index/introduction.qbk
index cb7bcf1d3..8e20ff903 100644
--- a/doc/index/introduction.qbk
+++ b/doc/index/introduction.qbk
@@ -51,7 +51,7 @@ The examples of structures of trees created by use of different algorithms and e
 [table
 [[]                         [Linear algorithm] [Quadratic algorithm] [R*-tree] [Packing algorithm]]
 [[*Example structure*]      [[$img/index/rtree/linear.png]] [[$img/index/rtree/quadratic.png]] [[$img/index/rtree/rstar.png]] [[$img/index/rtree/bulk.png]]]
-[[*1M Values inserts*]      [1.76s] [2.47s] [6.19s] [1.67s]]
+[[*1M Values inserts*]      [1.76s] [2.47s] [6.19s] [0.64s]]
 [[*100k spatial queries*]   [2.21s] [0.51s] [0.12s] [0.07s]]
 [[*100k knn queries*]       [6.37s] [2.09s] [0.64s] [0.52s]]
 ]

From 862743176c8ee580c1d72bafbda6f72ef6953f1d Mon Sep 17 00:00:00 2001
From: Adam Wulkiewicz <adam.wulkiewicz@gmail.com>
Date: Mon, 19 May 2014 02:17:27 +0200
Subject: [PATCH 15/22] [doc/index] Compact the new knn query pictures. Add knn
 code snippet.

---
 doc/index/rtree/query.qbk | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/doc/index/rtree/query.qbk b/doc/index/rtree/query.qbk
index 940e9b8c3..4f7d3ffb2 100644
--- a/doc/index/rtree/query.qbk
+++ b/doc/index/rtree/query.qbk
@@ -102,19 +102,30 @@ The examples of k-NN queries are presented below. 5 `__value__`s nearest to the
 [table
 [[nearest(Point, k)] [nearest(Box, k)] [nearest(Segment, k)]]
 [[[$img/index/rtree/knn_pt_box.png]] [[$img/index/rtree/knn_box_box.png]] [[$img/index/rtree/knn_seg_box.png]]]
-[[[$img/index/rtree/rtree_pt_knn_pt.png]] [[$img/index/rtree/rtree_pt_knn_box.png]] [[$img/index/rtree/rtree_pt_knn_seg.png]]]
-[[[$img/index/rtree/rtree_seg_knn_pt.png]] [[$img/index/rtree/rtree_seg_knn_box.png]] [[$img/index/rtree/rtree_seg_knn_seg.png]]]
+]
+[table
+[[nearest(Point, k)] [nearest(Box, k)] [nearest(Segment, k)] [nearest(Point, k)] [nearest(Box, k)] [nearest(Segment, k)]]
+[[[$img/index/rtree/rtree_pt_knn_pt.png]] [[$img/index/rtree/rtree_pt_knn_box.png]] [[$img/index/rtree/rtree_pt_knn_seg.png]]
+ [[$img/index/rtree/rtree_seg_knn_pt.png]] [[$img/index/rtree/rtree_seg_knn_box.png]] [[$img/index/rtree/rtree_seg_knn_seg.png]]]
 ]
 
 To perform the knn query one must pass the nearest predicate generated by the
 `nearest()` function defined in `boost::geometry::index` namespace.
-The following query returns `k` `__value__`s closest to some Point in space.
 For non-point `__indexable__`s the shortest distance is calculated using `bg::comparable_distance()` function.
+The following query returns `k` `__value__`s closest to some Point in space.
 
  std::vector<__value__> returned_values;
- __point__ pt(...);
+ __point__ pt(/*...*/);
  rt.query(bgi::nearest(pt, k), std::back_inserter(returned_values));
 
+The same way different query Geometries can be used:
+
+ __box__ box(/*...*/);
+ rt.query(bgi::nearest(box, k), std::back_inserter(returned_values));
+
+ Segment seg(/*...*/);
+ rt.query(bgi::nearest(seg, k), std::back_inserter(returned_values));
+
 [h4 User-defined unary predicate]
 
 The user may pass a `UnaryPredicate` - function, function object or lambda expression taking const reference to Value and returning bool.

From 42105b5f82d7246161f1e541b8567586e101ea4b Mon Sep 17 00:00:00 2001
From: Menelaos Karavelas <menelaos.karavelas@gmail.com>
Date: Mon, 19 May 2014 16:41:14 +0300
Subject: [PATCH 16/22] [test][distance L/A] add two seg-box test cases
 provided by Adam Wulkiewicz

---
 test/algorithms/distance_linear_areal.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/test/algorithms/distance_linear_areal.cpp b/test/algorithms/distance_linear_areal.cpp
index a15117729..79774b0d0 100644
--- a/test/algorithms/distance_linear_areal.cpp
+++ b/test/algorithms/distance_linear_areal.cpp
@@ -226,6 +226,16 @@ void test_distance_segment_box(Strategy const& strategy)
     typedef test_distance_of_geometries<B, S> tester;
     typedef test_distance_of_geometries<B, IS> itester;
 
+    // 1st example by Adam Wulkiewicz
+    tester::apply("BOX(5 51,42 96)",
+                  "SEGMENT(6.6799994 95.260002,35.119999 56.340004)",
+                  0, 0, strategy);
+
+    // 2nd example by Adam Wulkiewicz
+    tester::apply("BOX(51 55,94 100)",
+                  "SEGMENT(92.439995 50.130001,59.959999 80.870003)",
+                  0, 0, strategy);
+
     // segments that intersect the box
     tester::apply("box(0 0,1 1)",
                   "segment(-1 0.5,0.5 0.75)",

From 678ecd1541ffe56978154a67ca4d659c18cb1794 Mon Sep 17 00:00:00 2001
From: Menelaos Karavelas <menelaos.karavelas@gmail.com>
Date: Mon, 19 May 2014 16:42:07 +0300
Subject: [PATCH 17/22] [test][distance] in the case of the segment-box
 combination, also test output with respect to the generic algorithm that
 first checks for intersection, and if that fails, checks all possible
 point-segment combinations of the segment and and the box

---
 test/algorithms/test_distance_common.hpp | 140 +++++++++++++++++++++++
 1 file changed, 140 insertions(+)

diff --git a/test/algorithms/test_distance_common.hpp b/test/algorithms/test_distance_common.hpp
index a3b000e67..e7205f78c 100644
--- a/test/algorithms/test_distance_common.hpp
+++ b/test/algorithms/test_distance_common.hpp
@@ -426,6 +426,146 @@ struct test_distance_of_geometries
     }
 };
 
+//========================================================================
+
+template <typename Box, typename Segment>
+struct test_distance_of_geometries
+<
+    Box, Segment,
+    94 /* box */, 92 /* segment */
+>
+{
+    template
+    <
+        typename DistanceType,
+        typename ComparableDistanceType,
+        typename Strategy
+    >
+    static inline
+    void apply(std::string const& wkt_box,
+               std::string const& wkt_segment,
+               DistanceType const& expected_distance,
+               ComparableDistanceType const& expected_comparable_distance,
+               Strategy const& strategy)
+    {
+        test_distance_of_geometries
+            <
+                Segment, Box, 92, 94
+            >::apply(wkt_segment,
+                     wkt_box,
+                     expected_distance,
+                     expected_comparable_distance,
+                     strategy);
+    }
+};
+
+
+template <typename Segment, typename Box>
+struct test_distance_of_geometries
+<
+    Segment, Box,
+    92 /* segment */, 94 /* box */
+>
+    : public test_distance_of_geometries<Segment, Box, 0, 0>
+{
+    typedef test_distance_of_geometries<Segment, Box, 0, 0> base;
+
+    template
+    <
+        typename DistanceType,
+        typename ComparableDistanceType,
+        typename Strategy
+    >
+    static inline
+    void apply(std::string const& wkt_segment,
+               std::string const& wkt_box,
+               DistanceType const& expected_distance,
+               ComparableDistanceType const& expected_comparable_distance,
+               Strategy const& strategy)
+    {
+        Segment segment = from_wkt<Segment>(wkt_segment);
+        Box box = from_wkt<Box>(wkt_box);
+        apply(segment,
+              box,
+              expected_distance,
+              expected_comparable_distance,
+              strategy);
+    }
+
+
+    template
+    <
+        typename DistanceType,
+        typename ComparableDistanceType,
+        typename Strategy
+    >
+    static inline
+    void apply(Segment const& segment,
+               Box const& box,
+               DistanceType const& expected_distance,
+               ComparableDistanceType const& expected_comparable_distance,
+               Strategy const& strategy)
+    {
+        typedef typename bg::strategy::distance::services::return_type
+            <
+                Strategy, Segment, Box
+            >::type distance_result_type;
+
+        typedef typename bg::strategy::distance::services::comparable_type
+            <
+                Strategy
+            >::type comparable_strategy;
+
+        typedef typename bg::strategy::distance::services::return_type
+            <
+                comparable_strategy, Segment, Box
+            >::type comparable_distance_result_type;
+
+
+        base::apply(segment, box, expected_distance,
+                    expected_comparable_distance, strategy);
+
+        comparable_strategy cstrategy =
+            bg::strategy::distance::services::get_comparable
+                <
+                    Strategy
+                >::apply(strategy);
+
+        distance_result_type distance_generic =
+            bg::detail::distance::segment_to_box_2D_generic
+                <
+                    Segment, Box, Strategy
+                >::apply(segment, box, strategy);
+
+        comparable_distance_result_type comparable_distance_generic =
+            bg::detail::distance::segment_to_box_2D_generic
+                <
+                    Segment, Box, comparable_strategy
+                >::apply(segment, box, cstrategy);
+
+
+        check_equal
+            <
+                distance_result_type
+            >::apply(distance_generic, expected_distance);
+
+        check_equal
+            <
+                comparable_distance_result_type
+            >::apply(comparable_distance_generic, expected_comparable_distance);
+
+#ifdef GEOMETRY_TEST_DEBUG
+        std::cout << "... testing with naive seg-box distance algorithm..."
+                  << std::endl;
+        std::cout << "distance (generic algorithm) = "
+                  << distance_generic << " ; "
+                  << "comp. distance (generic algorithm) = "            
+                  << comparable_distance_generic
+                  << std::endl;
+        std::cout << std::endl << std::endl;
+#endif
+    }
+};
 
 //========================================================================
 

From bacf060256885b58e25c5f59332de674d02a2ed7 Mon Sep 17 00:00:00 2001
From: Menelaos Karavelas <menelaos.karavelas@gmail.com>
Date: Mon, 19 May 2014 16:44:27 +0300
Subject: [PATCH 18/22] [distance] modify the point-to-range code so that a
 container/range of points can be passed as an argument (e.g., a vector of
 points)

---
 .../detail/distance/point_to_geometry.hpp     | 21 ++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/include/boost/geometry/algorithms/detail/distance/point_to_geometry.hpp b/include/boost/geometry/algorithms/detail/distance/point_to_geometry.hpp
index 7b89dcad1..a46f1fe7d 100644
--- a/include/boost/geometry/algorithms/detail/distance/point_to_geometry.hpp
+++ b/include/boost/geometry/algorithms/detail/distance/point_to_geometry.hpp
@@ -86,13 +86,17 @@ private:
 
     typedef typename strategy::distance::services::return_type
         <
-            comparable_strategy, Point, typename point_type<Range>::type
+            comparable_strategy,
+            Point,
+            typename boost::range_value<Range>::type
         >::type comparable_return_type;
 
 public:
     typedef typename strategy::distance::services::return_type
         <
-            Strategy, Point, typename point_type<Range>::type
+            Strategy,
+            Point,
+            typename boost::range_value<Range>::type
         >::type return_type;
 
     static inline return_type apply(Point const& point, Range const& range,
@@ -123,7 +127,8 @@ public:
         {
             return strategy::distance::services::comparable_to_regular
             <
-                comparable_strategy, Strategy, Point, Range
+                comparable_strategy, Strategy, Point,
+                typename boost::range_value<Range>::type
             >::apply( c_strategy.apply(point,
                                        *boost::begin(view),
                                        *boost::begin(view)) );
@@ -140,7 +145,10 @@ public:
             {
                 return strategy::distance::services::comparable_to_regular
                     <
-                        comparable_strategy, Strategy, Point, Range
+                        comparable_strategy,
+                        Strategy,
+                        Point,
+                        typename boost::range_value<Range>::type
                     >::apply(zero);
             }
             else if (cds < cd)
@@ -151,7 +159,10 @@ public:
 
         return strategy::distance::services::comparable_to_regular
             <
-                comparable_strategy, Strategy, Point, Range
+                comparable_strategy,
+                Strategy,
+                Point,
+                typename boost::range_value<Range>::type
             >::apply(cd);
     }
 };

From 86563682b3b517d61134701cfac1e117f06f5a0a Mon Sep 17 00:00:00 2001
From: Menelaos Karavelas <menelaos.karavelas@gmail.com>
Date: Mon, 19 May 2014 16:45:44 +0300
Subject: [PATCH 19/22] [distance] modify the range-to-segment/box code, so
 that in the case of computing the distance of a point of the range from the
 box, the point-to-range code in point_in_geometry.hpp is used

---
 .../distance/range_to_segment_or_box.hpp      | 21 ++++---------------
 1 file changed, 4 insertions(+), 17 deletions(-)

diff --git a/include/boost/geometry/algorithms/detail/distance/range_to_segment_or_box.hpp b/include/boost/geometry/algorithms/detail/distance/range_to_segment_or_box.hpp
index 56ff37616..edaba1252 100644
--- a/include/boost/geometry/algorithms/detail/distance/range_to_segment_or_box.hpp
+++ b/include/boost/geometry/algorithms/detail/distance/range_to_segment_or_box.hpp
@@ -127,23 +127,10 @@ private:
                                      BoxPoints const& box_points,
                                      ComparableStrategy const& strategy)
         {
-            boost::ignore_unused_variable_warning(strategy);
-
-            comparable_return_type cd_min =
-                strategy.apply(point, box_points[0], box_points[3]);
-
-            for (unsigned int i = 0; i < 3; ++i)
-            {
-                comparable_return_type cd =
-                    strategy.apply(point, box_points[i], box_points[i+1]);
-
-                if ( cd < cd_min )
-                {
-                    cd_min = cd;
-                }
-            }
-            
-            return cd_min;
+            return point_to_range
+                <
+                    Point, BoxPoints, open, ComparableStrategy
+                >::apply(point, box_points, strategy);
         }
     };
 

From 7445898e7795cb85da947b0db001173c9d4a5316 Mon Sep 17 00:00:00 2001
From: Menelaos Karavelas <menelaos.karavelas@gmail.com>
Date: Mon, 19 May 2014 16:49:35 +0300
Subject: [PATCH 20/22] [distance] fix bugs in segment-to-box distance
 computation; add generic algorithm for computing segment-to-box distances:
 the algorithm first checks the segment and the box for intersection, then if
 no intersection is found, it returns the minimum distance over all
 point-segment combinations from the two geometries; for computing a point-box
 distance the algorithm either calls the default point-box strategy, or calls
 the detail::distance::point_to_range algorithm; this alternate segment-box
 distance computation algorithm is currently used in unit tests of segment-box
 distances to verify results with the cartesian-specific approach

---
 .../detail/distance/segment_to_box.hpp        | 174 +++++++++++++++++-
 1 file changed, 169 insertions(+), 5 deletions(-)

diff --git a/include/boost/geometry/algorithms/detail/distance/segment_to_box.hpp b/include/boost/geometry/algorithms/detail/distance/segment_to_box.hpp
index 4a6f23839..c3d65ec8e 100644
--- a/include/boost/geometry/algorithms/detail/distance/segment_to_box.hpp
+++ b/include/boost/geometry/algorithms/detail/distance/segment_to_box.hpp
@@ -10,6 +10,8 @@
 #ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_SEGMENT_TO_BOX_HPP
 #define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_SEGMENT_TO_BOX_HPP
 
+#include <vector>
+
 #include <boost/assert.hpp>
 #include <boost/numeric/conversion/cast.hpp>
 #include <boost/type_traits/is_same.hpp>
@@ -29,11 +31,14 @@
 
 #include <boost/geometry/policies/compare.hpp>
 
-#include <boost/geometry/algorithms/assign.hpp>
 #include <boost/geometry/algorithms/equals.hpp>
+#include <boost/geometry/algorithms/intersects.hpp>
 #include <boost/geometry/algorithms/not_implemented.hpp>
 
+#include <boost/geometry/algorithms/detail/assign_box_corners.hpp>
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
 #include <boost/geometry/algorithms/detail/distance/default_strategies.hpp>
+#include <boost/geometry/algorithms/detail/distance/point_to_geometry.hpp>
 
 #include <boost/geometry/algorithms/dispatch/distance.hpp>
 
@@ -48,6 +53,165 @@ namespace detail { namespace distance
 {
 
 
+template
+<
+    typename Segment,
+    typename Box,
+    typename Strategy,
+    bool UsePointBoxStrategy = false
+>
+class segment_to_box_2D_generic
+{
+private:
+    typedef typename point_type<Segment>::type segment_point;
+    typedef typename point_type<Box>::type box_point;
+
+    typedef typename strategy::distance::services::comparable_type
+        <
+            Strategy
+        >::type comparable_strategy;
+
+    typedef typename strategy::distance::services::return_type
+        <
+            comparable_strategy, segment_point, box_point
+        >::type comparable_return_type;
+    
+    typedef point_to_range
+        <
+            segment_point, std::vector<box_point>, open, comparable_strategy
+        > point_to_box_boundary;
+
+public:
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy, segment_point, box_point
+        >::type return_type;
+
+    static inline return_type apply(Segment const& segment,
+                                    Box const& box,
+                                    Strategy const& strategy,
+                                    bool check_intersection = true)
+    {
+        if ( check_intersection && geometry::intersects(segment, box) )
+        {
+            return 0;
+        }
+
+        comparable_strategy cstrategy =
+            strategy::distance::services::get_comparable
+                <
+                    Strategy
+                >::apply(strategy);
+        boost::ignore_unused_variable_warning(cstrategy);
+
+        // get segment points
+        segment_point p[2];
+        detail::assign_point_from_index<0>(segment, p[0]);
+        detail::assign_point_from_index<1>(segment, p[1]);
+
+        // get box points
+        std::vector<box_point> box_points(4);
+        detail::assign_box_corners_oriented<true>(box, box_points);
+ 
+        comparable_return_type cd[6];
+        for (unsigned int i = 0; i < 4; ++i)
+        {
+            cd[i] = cstrategy.apply(box_points[i], p[0], p[1]);
+        }
+        cd[4] = point_to_box_boundary::apply(p[0], box_points, cstrategy);
+        cd[5] = point_to_box_boundary::apply(p[1], box_points, cstrategy);
+
+        return strategy::distance::services::comparable_to_regular
+            <
+                comparable_strategy, Strategy, Segment, Box
+            >::apply( *std::min_element(cd, cd + 6) );
+    }
+};
+
+
+template
+<
+    typename Segment,
+    typename Box,
+    typename Strategy
+>
+class segment_to_box_2D_generic<Segment, Box, Strategy, true>
+{
+private:
+    typedef typename point_type<Segment>::type segment_point;
+    typedef typename point_type<Box>::type box_point;
+
+    typedef typename strategy::distance::services::comparable_type
+        <
+            Strategy
+        >::type comparable_strategy;
+
+    typedef typename strategy::distance::services::return_type
+        <
+            comparable_strategy, segment_point, box_point
+        >::type comparable_return_type;
+
+    typedef typename strategy::distance::services::comparable_type
+        <
+            typename detail::distance::default_strategy
+            <
+                segment_point, Box
+            >::type
+        >::type point_box_comparable_strategy;
+
+public:
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy, segment_point, box_point
+        >::type return_type;
+
+    static inline return_type apply(Segment const& segment,
+                                    Box const& box,
+                                    Strategy const& strategy,
+                                    bool check_intersection = true)
+    {
+        if ( check_intersection && geometry::intersects(segment, box) )
+        {
+            return 0;
+        }
+
+        comparable_strategy cstrategy =
+            strategy::distance::services::get_comparable
+                <
+                    Strategy
+                >::apply(strategy);
+        boost::ignore_unused_variable_warning(cstrategy);
+
+        // get segment points
+        segment_point p[2];
+        detail::assign_point_from_index<0>(segment, p[0]);
+        detail::assign_point_from_index<1>(segment, p[1]);
+
+        // get box points
+        std::vector<box_point> box_points(4);
+        detail::assign_box_corners_oriented<true>(box, box_points);
+ 
+        comparable_return_type cd[6];
+        for (unsigned int i = 0; i < 4; ++i)
+        {
+            cd[i] = cstrategy.apply(box_points[i], p[0], p[1]);
+        }
+
+        point_box_comparable_strategy pb_cstrategy;
+        boost::ignore_unused_variable_warning(pb_cstrategy);
+        cd[4] = pb_cstrategy.apply(p[0], box);
+        cd[5] = pb_cstrategy.apply(p[1], box);
+
+        return strategy::distance::services::comparable_to_regular
+            <
+                comparable_strategy, Strategy, Segment, Box
+            >::apply( *std::min_element(cd, cd + 6) );
+    }
+};
+
+
+
+
 template
 <
     typename ReturnType,
@@ -118,7 +282,7 @@ private:
         }
 
         // p1 lies to the left of the box
-        if ( geometry::get<0>(p1) <= geometry::get<1>(bottom_left) )
+        if ( geometry::get<0>(p1) <= geometry::get<0>(bottom_left) )
         {
             if ( geometry::get<1>(p1) <= geometry::get<1>(bottom_left) )
             {
@@ -253,7 +417,7 @@ private:
         }
 
         // p1 lies to the left of the box
-        if ( geometry::get<0>(p1) <= geometry::get<1>(bottom_left) )
+        if ( geometry::get<0>(p1) <= geometry::get<0>(bottom_left) )
         {
             if ( geometry::get<1>(p1) >= geometry::get<1>(top_left) )
             {
@@ -322,9 +486,9 @@ private:
         ReturnType diff1 = cast::apply(geometry::get<1>(p0))
             - cast::apply(geometry::get<1>(p1));
         ReturnType t_min1 = cast::apply(geometry::get<1>(p0))
-            - cast::apply(geometry::get<1>(top_right));
-        ReturnType t_max1 = cast::apply(geometry::get<1>(p0))
             - cast::apply(geometry::get<1>(bottom_left));
+        ReturnType t_max1 = cast::apply(geometry::get<1>(p0))
+            - cast::apply(geometry::get<1>(top_right));
 
         //  t_max0 < t_max1
         if ( t_max0 * diff1 < t_max1 * diff0 )

From 270f3e239c7059138e8b62d1e2ccb3751b27750f Mon Sep 17 00:00:00 2001
From: Adam Wulkiewicz <adam.wulkiewicz@gmail.com>
Date: Mon, 19 May 2014 17:07:52 +0200
Subject: [PATCH 21/22] [example/index] Fix GCC/clang c++98 compilation error
 in glut_vis.cpp

The error is caused by the Boost.Move limitation - the correct implicit assignment operator can't be automatically generated for a containing class.
---
 index/example/glut_vis.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/index/example/glut_vis.cpp b/index/example/glut_vis.cpp
index 865ac08b9..9ae15f19f 100644
--- a/index/example/glut_vis.cpp
+++ b/index/example/glut_vis.cpp
@@ -48,6 +48,14 @@ typedef bg::model::multi_polygon<Poly> MPoly;
 template <typename V>
 struct containers
 {
+    containers & operator=(containers const& c)
+    {
+        tree = c.tree;
+        values = c.values;
+        result = c.result;
+        return *this;
+    }
+
     bgi::rtree< V, bgi::rstar<4, 2> > tree;
     std::vector<V> values;
     std::vector<V> result;

From 86259f78a777c7f645d3ae97bef0833135427c7b Mon Sep 17 00:00:00 2001
From: Barend Gehrels <barend@xs4all.nl>
Date: Mon, 19 May 2014 23:10:06 +0200
Subject: [PATCH 22/22] [doc][wkt] Fixed WKT doc / extended WKT doc (in
 progress)

---
 doc/imports.qbk                          |  2 ++
 doc/reference.qbk                        |  2 +-
 doc/reference/io/read_wkt.qbk            | 15 +++++++++
 doc/reference/io/wkt.qbk                 | 16 +++++++++
 doc/src/examples/Jamfile.v2              |  1 +
 doc/src/examples/io/Jamfile.v2           | 19 +++++++++++
 doc/src/examples/io/read_wkt.cpp         | 37 ++++++++++++++++++++
 doc/src/examples/io/wkt.cpp              | 43 ++++++++++++++++++++++++
 include/boost/geometry/io/wkt/read.hpp   | 25 +++-----------
 include/boost/geometry/io/wkt/stream.hpp |  6 ++--
 include/boost/geometry/io/wkt/write.hpp  |  9 ++---
 11 files changed, 143 insertions(+), 32 deletions(-)
 create mode 100644 doc/reference/io/read_wkt.qbk
 create mode 100644 doc/reference/io/wkt.qbk
 create mode 100644 doc/src/examples/io/Jamfile.v2
 create mode 100644 doc/src/examples/io/read_wkt.cpp
 create mode 100644 doc/src/examples/io/wkt.cpp

diff --git a/doc/imports.qbk b/doc/imports.qbk
index 8ef073ab1..3d4706f2e 100644
--- a/doc/imports.qbk
+++ b/doc/imports.qbk
@@ -105,6 +105,8 @@
 [import src/examples/geometries/register/multi_polygon.cpp]
 
 [import src/examples/io/svg.cpp]
+[import src/examples/io/wkt.cpp]
+[import src/examples/io/read_wkt.cpp]
 
 [import src/examples/views/box_view.cpp]
 [import src/examples/views/segment_view.cpp]
diff --git a/doc/reference.qbk b/doc/reference.qbk
index 5878d6f92..047abf2fc 100644
--- a/doc/reference.qbk
+++ b/doc/reference.qbk
@@ -223,7 +223,7 @@
 
 [section:io IO (input/output)]
 [section:wkt WKT (Well-Known Text)]
-[/include generated/wkt.qbk/]
+[include generated/wkt.qbk]
 [endsect]
 [section:svg SVG (Scalable Vector Graphics)]
 [include generated/svg.qbk]
diff --git a/doc/reference/io/read_wkt.qbk b/doc/reference/io/read_wkt.qbk
new file mode 100644
index 000000000..05eca9817
--- /dev/null
+++ b/doc/reference/io/read_wkt.qbk
@@ -0,0 +1,15 @@
+[/============================================================================
+  Boost.Geometry (aka GGL, Generic Geometry Library)
+
+  Copyright (c) 2009-2014 Barend Gehrels, 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)
+=============================================================================/]
+
+[heading Example]
+[read_wkt]
+
+[heading See also]
+* [link geometry.reference.io.wkt.wkt WKT streaming manipulator]
diff --git a/doc/reference/io/wkt.qbk b/doc/reference/io/wkt.qbk
new file mode 100644
index 000000000..8dac6185c
--- /dev/null
+++ b/doc/reference/io/wkt.qbk
@@ -0,0 +1,16 @@
+[/============================================================================
+  Boost.Geometry (aka GGL, Generic Geometry Library)
+
+  Copyright (c) 2009-2014 Barend Gehrels, 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)
+=============================================================================/]
+
+[heading Example]
+[wkt]
+[wkt_output]
+
+[heading See also]
+* [link geometry.reference.io.wkt.read_wkt Read WKT]
diff --git a/doc/src/examples/Jamfile.v2 b/doc/src/examples/Jamfile.v2
index faddc32a5..90c5337d2 100644
--- a/doc/src/examples/Jamfile.v2
+++ b/doc/src/examples/Jamfile.v2
@@ -18,4 +18,5 @@ exe quick_start : quick_start.cpp ;
 build-project algorithms ;
 build-project core ;
 build-project geometries ;
+build-project io ;
 build-project views ;
diff --git a/doc/src/examples/io/Jamfile.v2 b/doc/src/examples/io/Jamfile.v2
new file mode 100644
index 000000000..489fa6a77
--- /dev/null
+++ b/doc/src/examples/io/Jamfile.v2
@@ -0,0 +1,19 @@
+# Boost.Geometry (aka GGL, Generic Geometry Library)
+#
+# Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+# Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+# Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+# Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland
+
+# 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)
+
+
+project boost-geometry-doc-example-io
+    : # requirements
+    ;
+
+exe svg : svg.cpp ;
+exe wkt : wkt.cpp ;
+exe read_wkt : read_wkt.cpp ;
diff --git a/doc/src/examples/io/read_wkt.cpp b/doc/src/examples/io/read_wkt.cpp
new file mode 100644
index 000000000..8abd818dd
--- /dev/null
+++ b/doc/src/examples/io/read_wkt.cpp
@@ -0,0 +1,37 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+// QuickBook Example
+
+// Copyright (c) 2014 Barend Gehrels, 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)
+
+//[read_wkt
+//` Shows the usage of read_wkt
+
+#include <iostream>
+#include <fstream>
+
+#include <boost/geometry.hpp>
+#include <boost/geometry/geometries/point_xy.hpp>
+#include <boost/geometry/geometries/polygon.hpp>
+
+int main()
+{
+    // Specify the basic type
+    typedef boost::geometry::model::d2::point_xy<double> point_type;
+
+    // Declare some geometries and set their values
+    point_type a;
+    boost::geometry::model::polygon<point_type> b;
+
+    boost::geometry::read_wkt("POINT(1 2)", a);
+    boost::geometry::read_wkt("POLYGON((0 0,0 7,4 2,2 0,0 0))", b);
+
+
+    return 0;
+}
+
+//]
+
diff --git a/doc/src/examples/io/wkt.cpp b/doc/src/examples/io/wkt.cpp
new file mode 100644
index 000000000..f862b41a4
--- /dev/null
+++ b/doc/src/examples/io/wkt.cpp
@@ -0,0 +1,43 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+// QuickBook Example
+
+// Copyright (c) 2014 Barend Gehrels, 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)
+
+//[wkt
+//` Shows the usage of wkt
+
+#include <iostream>
+#include <fstream>
+
+#include <boost/geometry.hpp>
+#include <boost/geometry/geometries/point_xy.hpp>
+#include <boost/geometry/geometries/polygon.hpp>
+
+int main()
+{
+    // Specify the basic type
+    typedef boost::geometry::model::d2::point_xy<double> point_type;
+
+    // Declare some geometries and set their values
+    point_type a;
+    boost::geometry::assign_values(a, 3, 6);
+
+    std::cout << boost::geometry::wkt(a) << std::endl;
+
+    return 0;
+}
+
+//]
+
+
+//[wkt_output
+/*`
+Output:
+point(3 6)
+
+*/
+//]
diff --git a/include/boost/geometry/io/wkt/read.hpp b/include/boost/geometry/io/wkt/read.hpp
index 24e93a02f..535a247db 100644
--- a/include/boost/geometry/io/wkt/read.hpp
+++ b/include/boost/geometry/io/wkt/read.hpp
@@ -662,28 +662,11 @@ struct read_wkt<segment_tag, Segment>
 /*!
 \brief Parses OGC Well-Known Text (\ref WKT) into a geometry (any geometry)
 \ingroup wkt
+\tparam Geometry \tparam_geometry
 \param wkt string containing \ref WKT
-\param geometry output geometry
-\par Example:
-\note It is case insensitive and can have the WKT forms "point", "point m", "point z", "point zm", "point mz"
-\note Empty sequences can have forms as "LINESTRING ()" or "POLYGON(())"
-Small example showing how to use read_wkt to build a point
-\dontinclude doxygen_1.cpp
-\skip example_from_wkt_point
-\line {
-\until }
-\par Example:
-Small example showing how to use read_wkt to build a linestring
-\dontinclude doxygen_1.cpp
-\skip example_from_wkt_linestring
-\line {
-\until }
-\par Example:
-Small example showing how to use read_wkt to build a polygon
-\dontinclude doxygen_1.cpp
-\skip example_from_wkt_polygon
-\line {
-\until }
+\param geometry \param_geometry output geometry
+\ingroup wkt
+\qbk{[include reference/io/read_wkt.qbk]}
 */
 template <typename Geometry>
 inline void read_wkt(std::string const& wkt, Geometry& geometry)
diff --git a/include/boost/geometry/io/wkt/stream.hpp b/include/boost/geometry/io/wkt/stream.hpp
index 86e49fdaf..3849dda59 100644
--- a/include/boost/geometry/io/wkt/stream.hpp
+++ b/include/boost/geometry/io/wkt/stream.hpp
@@ -22,10 +22,8 @@
 // Don't use namespace boost::geometry, to enable the library to stream custom
 // geometries which are living outside the namespace boost::geometry
 
-/*!
-\brief Streams a geometry as Well-Known Text
-\ingroup wkt
-*/
+// This is currently not documented on purpose: the Doxygen 2 QBK generator
+// should be updated w.r.t. << which in the end ruins the DocBook XML
 template<typename Char, typename Traits, typename Geometry>
 inline std::basic_ostream<Char, Traits>& operator<<
     (
diff --git a/include/boost/geometry/io/wkt/write.hpp b/include/boost/geometry/io/wkt/write.hpp
index 020084686..05648f5c7 100644
--- a/include/boost/geometry/io/wkt/write.hpp
+++ b/include/boost/geometry/io/wkt/write.hpp
@@ -416,13 +416,10 @@ private:
 
 /*!
 \brief Main WKT-streaming function
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
 \ingroup wkt
-\par Example:
-Small example showing how to use the wkt helper function
-\dontinclude doxygen_1.cpp
-\skip example_as_wkt_vector
-\line {
-\until }
+\qbk{[include reference/io/wkt.qbk]}
 */
 template <typename Geometry>
 inline wkt_manipulator<Geometry> wkt(Geometry const& geometry)