Subject: [Boost-commit] svn:boost r64087 - in sandbox/geometry: boost/geometry/algorithms boost/geometry/strategies boost/geometry/strategies/cartesian libs/geometry/test/algorithms
From: barend.gehrels_at_[hidden]
Date: 2010-07-17 06:46:27
Author: barendgehrels
Date: 2010-07-17 06:46:25 EDT (Sat, 17 Jul 2010)
New Revision: 64087
URL: http://svn.boost.org/trac/boost/changeset/64087
Log:
Added Point-Point strategy to default_strategy for Point-segment
Added some MPL assertions
Updated distance tests
Text files modified:
sandbox/geometry/boost/geometry/algorithms/distance.hpp | 18 +
sandbox/geometry/boost/geometry/strategies/cartesian/distance_projected_point.hpp | 24 +
sandbox/geometry/boost/geometry/strategies/cartesian/distance_pythagoras.hpp | 2
sandbox/geometry/boost/geometry/strategies/distance.hpp | 47 ++++
sandbox/geometry/boost/geometry/strategies/distance_result.hpp | 2
sandbox/geometry/libs/geometry/test/algorithms/distance.cpp | 375 ++++++++++++++++++++++++++-------------
sandbox/geometry/libs/geometry/test/algorithms/within.cpp | 2
7 files changed, 327 insertions(+), 143 deletions(-)
Modified: sandbox/geometry/boost/geometry/algorithms/distance.hpp
==============================================================================
--- sandbox/geometry/boost/geometry/algorithms/distance.hpp (original)
+++ sandbox/geometry/boost/geometry/algorithms/distance.hpp 2010-07-17 06:46:25 EDT (Sat, 17 Jul 2010)
@@ -91,7 +91,10 @@
<
segment_tag,
Point,
- typename point_type<Segment>::type
+ typename point_type<Segment>::type,
+ typename cs_tag<Point>::type,
+ typename cs_tag<typename point_type<Segment>::type>::type,
+ Strategy
>::type segment_strategy;
// See remark below.
@@ -125,7 +128,7 @@
return pp_strategy.apply(point, *boost::begin(range));
}
- // Create efficient strategy
+ // Create comparable (more efficient) strategy
typedef typename strategy::distance::services::comparable_type<PSStrategy>::type eps_strategy_type;
eps_strategy_type eps_strategy = strategy::distance::services::get_comparable<PSStrategy>::apply(ps_strategy);
@@ -422,7 +425,7 @@
\param geometry1 first geometry
\param geometry2 second geometry
\param strategy strategy to calculate distance between two points
- \return the distance (either a double or a distance_result, (convertable to double))
+ \return the distance
\note The strategy can be a point-point strategy. In case of distance point-line/point-polygon
it may also be a point-segment strategy.
\par Example:
@@ -432,6 +435,15 @@
\line {
\until }
*/
+
+/*
+Note, in case of a Compilation Error:
+if you get:
+ - "Failed to specialize function template ..."
+ - "error: no matching function for call to ..."
+for distance, it is probably so that there is no specialization
+for return_type<...> for your strategy.
+*/
template <typename Geometry1, typename Geometry2, typename Strategy>
inline typename strategy::distance::services::return_type<Strategy>::type distance(
Geometry1 const& geometry1,
Modified: sandbox/geometry/boost/geometry/strategies/cartesian/distance_projected_point.hpp
==============================================================================
--- sandbox/geometry/boost/geometry/strategies/cartesian/distance_projected_point.hpp (original)
+++ sandbox/geometry/boost/geometry/strategies/cartesian/distance_projected_point.hpp 2010-07-17 06:46:25 EDT (Sat, 17 Jul 2010)
@@ -266,19 +266,29 @@
};
-template <typename Point, typename PointOfSegment>
-struct default_strategy<segment_tag, Point, PointOfSegment, cartesian_tag, cartesian_tag>
+// Get default-strategy for point-segment distance calculation
+// while still have the possibility to specify point-point distance strategy (PPS)
+// It is used in algorithms/distance.hpp where users specify PPS for distance
+// of point-to-segment or point-to-linestring.
+// Convenient for geographic coordinate systems especially.
+template <typename Point, typename PointOfSegment, typename Strategy>
+struct default_strategy<segment_tag, Point, PointOfSegment, cartesian_tag, cartesian_tag, Strategy>
{
typedef strategy::distance::projected_point
<
Point,
PointOfSegment,
void,
- typename default_strategy
- <
- point_tag, Point, PointOfSegment,
- cartesian_tag, cartesian_tag
- >::type
+ typename boost::mpl::if_
+ <
+ boost::is_void<Strategy>,
+ typename default_strategy
+ <
+ point_tag, Point, PointOfSegment,
+ cartesian_tag, cartesian_tag
+ >::type,
+ Strategy
+ >::type
> type;
};
Modified: sandbox/geometry/boost/geometry/strategies/cartesian/distance_pythagoras.hpp
==============================================================================
--- sandbox/geometry/boost/geometry/strategies/cartesian/distance_pythagoras.hpp (original)
+++ sandbox/geometry/boost/geometry/strategies/cartesian/distance_pythagoras.hpp 2010-07-17 06:46:25 EDT (Sat, 17 Jul 2010)
@@ -309,7 +309,7 @@
template <typename Point1, typename Point2>
-struct default_strategy<point_tag, Point1, Point2, cartesian_tag, cartesian_tag>
+struct default_strategy<point_tag, Point1, Point2, cartesian_tag, cartesian_tag, void>
{
typedef pythagoras<Point1, Point2> type;
};
Modified: sandbox/geometry/boost/geometry/strategies/distance.hpp
==============================================================================
--- sandbox/geometry/boost/geometry/strategies/distance.hpp (original)
+++ sandbox/geometry/boost/geometry/strategies/distance.hpp 2010-07-17 06:46:25 EDT (Sat, 17 Jul 2010)
@@ -23,8 +23,15 @@
namespace strategy { namespace distance { namespace services
{
+
template <typename Strategy> struct tag {};
-template <typename Strategy> struct return_type {};
+template <typename Strategy> struct return_type
+{
+ BOOST_MPL_ASSERT_MSG
+ (
+ false, NOT_IMPLEMENTED_FOR_THIS_STRATEGY, (types<Strategy>)
+ );
+};
/*!
@@ -36,7 +43,14 @@
typename Point1,
typename Point2
>
-struct similar_type {};
+struct similar_type
+{
+ BOOST_MPL_ASSERT_MSG
+ (
+ false, NOT_IMPLEMENTED_FOR_THIS_STRATEGY
+ , (types<Strategy, Point1, Point2>)
+ );
+};
template
<
@@ -44,10 +58,30 @@
typename Point1,
typename Point2
>
-struct get_similar {};
+struct get_similar
+{
+ BOOST_MPL_ASSERT_MSG
+ (
+ false, NOT_IMPLEMENTED_FOR_THIS_STRATEGY
+ , (types<Strategy, Point1, Point2>)
+ );
+};
-template <typename Strategy> struct comparable_type {};
-template <typename Strategy> struct get_comparable {};
+template <typename Strategy> struct comparable_type
+{
+ BOOST_MPL_ASSERT_MSG
+ (
+ false, NOT_IMPLEMENTED_FOR_THIS_STRATEGY, (types<Strategy>)
+ );
+};
+
+template <typename Strategy> struct get_comparable
+{
+ BOOST_MPL_ASSERT_MSG
+ (
+ false, NOT_IMPLEMENTED_FOR_THIS_STRATEGY, (types<Strategy>)
+ );
+};
template <typename Strategy> struct result_from_distance {};
@@ -75,7 +109,8 @@
typename Point1,
typename Point2 = Point1,
typename CsTag1 = typename cs_tag<Point1>::type,
- typename CsTag2 = typename cs_tag<Point2>::type
+ typename CsTag2 = typename cs_tag<Point2>::type,
+ typename UnderlyingStrategy = void
>
struct default_strategy
{
Modified: sandbox/geometry/boost/geometry/strategies/distance_result.hpp
==============================================================================
--- sandbox/geometry/boost/geometry/strategies/distance_result.hpp (original)
+++ sandbox/geometry/boost/geometry/strategies/distance_result.hpp 2010-07-17 06:46:25 EDT (Sat, 17 Jul 2010)
@@ -28,7 +28,7 @@
// TODO: rename to "default_distance_result" or services::default_result
-template <typename Geometry1, typename Geometry2>
+template <typename Geometry1, typename Geometry2 = Geometry1>
struct distance_result
{
typedef typename strategy::distance::services::return_type
Modified: sandbox/geometry/libs/geometry/test/algorithms/distance.cpp
==============================================================================
--- sandbox/geometry/libs/geometry/test/algorithms/distance.cpp (original)
+++ sandbox/geometry/libs/geometry/test/algorithms/distance.cpp 2010-07-17 06:46:25 EDT (Sat, 17 Jul 2010)
@@ -6,7 +6,7 @@
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
-//#define TEST_ARRAY
+#define TEST_ARRAY
#include <sstream>
@@ -28,185 +28,312 @@
#include <test_common/test_point.hpp>
-template <typename P>
-void test_distance_result()
+namespace bg = boost::geometry;
+
+
+// Define a custom distance strategy
+// For this one, the "taxicab" distance,
+// see http://en.wikipedia.org/wiki/Taxicab_geometry
+
+// For a point-point-distance operation, one typename Point is enough.
+// For a point-segment-distance operation, there is some magic inside
+// using another point type and casting if necessary. Therefore,
+// two point-types are necessary.
+template <typename P1, typename P2 = P1>
+struct taxicab_distance
{
- typedef typename boost::geometry::distance_result<P, P>::type distance_type;
+ static inline typename boost::geometry::coordinate_type<P1>::type apply(
+ P1 const& p1, P2 const& p2)
+ {
+ using boost::geometry::get;
+ using boost::geometry::math::abs;
+ return abs(get<0>(p1) - get<1>(p2))
+ + abs(get<1>(p1) - get<1>(p2));
+ }
+};
-#ifndef TEST_ARRAY
- P p1 = boost::geometry::make<P>(0, 0);
- P p2 = boost::geometry::make<P>(3, 0);
- P p3 = boost::geometry::make<P>(0, 4);
-#else
- P p1, p2, p3;
- boost::geometry::set<0>(p1, 0); boost::geometry::set<1>(p1, 0);
- boost::geometry::set<0>(p2, 3); boost::geometry::set<1>(p2, 0);
- boost::geometry::set<0>(p3, 0); boost::geometry::set<1>(p3, 4);
-#endif
- distance_type dr12 = boost::geometry::distance(p1, p2);
- distance_type dr13 = boost::geometry::distance(p1, p3);
- distance_type dr23 = boost::geometry::distance(p2, p3);
- BOOST_CHECK_CLOSE(double(dr12), 3.000, 0.001);
- BOOST_CHECK_CLOSE(double(dr13), 4.000, 0.001);
- BOOST_CHECK_CLOSE(double(dr23), 5.000, 0.001);
+namespace boost { namespace geometry { namespace strategy { namespace distance { namespace services
+{
- // COMPARABLE TESTS
- {
- namespace services = boost::geometry::strategy::distance::services;
+template <typename P1, typename P2>
+struct tag<taxicab_distance<P1, P2> >
+{
+ typedef strategy_tag_distance_point_point type;
+};
- typedef typename services::default_strategy<boost::geometry::point_tag, P>::type strategy_type;
- typedef typename services::comparable_type<strategy_type>::type comparable_strategy_type;
- strategy_type strategy;
- comparable_strategy_type comparable_strategy = services::get_comparable<strategy_type>::apply(strategy);
- distance_type comparable = services::result_from_distance<comparable_strategy_type>::apply(comparable_strategy, 3);
+template <typename P1, typename P2>
+struct return_type<taxicab_distance<P1, P2> >
+{
+ typedef typename coordinate_type<P1>::type type;
+};
+
+
+template<typename P1, typename P2, typename PN1, typename PN2>
+struct similar_type<taxicab_distance<P1, P2>, PN1, PN2>
+{
+ typedef taxicab_distance<PN1, PN2> type;
+};
- BOOST_CHECK_CLOSE(double(comparable), 9.000, 0.001);
- // COMPILATION TESTS (probably obsolete...)
- if (comparable == dr12) {};
- if (comparable < dr12) {};
- if (comparable > dr12) {};
-
- // Check streamability
- std::ostringstream s;
- s << comparable;
-
- // Check comparisons with plain double
- double d = 3.0;
- if (dr12 == d) {};
- if (dr12 < d) {};
- if (dr12 > d) {};
+template<typename P1, typename P2, typename PN1, typename PN2>
+struct get_similar<taxicab_distance<P1, P2>, PN1, PN2>
+{
+ static inline typename similar_type
+ <
+ taxicab_distance<P1, P2>, PN1, PN2
+ >::type apply(taxicab_distance<P1, P2> const& )
+ {
+ return taxicab_distance<PN1, PN2>();
}
-}
+};
+
+template <typename P1, typename P2>
+struct comparable_type<taxicab_distance<P1, P2> >
+{
+ typedef taxicab_distance<P1, P2> type;
+};
+
+template <typename P1, typename P2>
+struct get_comparable<taxicab_distance<P1, P2> >
+{
+ static inline taxicab_distance<P1, P2> apply(taxicab_distance<P1, P2> const& input)
+ {
+ return input;
+ }
+};
+
+template <typename P1, typename P2>
+struct result_from_distance<taxicab_distance<P1, P2> >
+{
+ template <typename T>
+ static inline typename coordinate_type<P1>::type apply(taxicab_distance<P1, P2> const& , T const& value)
+ {
+ return value;
+ }
+};
+
+
+}}}}} // namespace boost::geometry::strategy::distance::services
+
+
+
template <typename P>
void test_distance_point()
{
- P p1;
- boost::geometry::set<0>(p1, 1);
- boost::geometry::set<1>(p1, 1);
-
- P p2;
- boost::geometry::set<0>(p2, 2);
- boost::geometry::set<1>(p2, 2);
+ namespace services = bg::strategy::distance::services;
+ typedef typename bg::distance_result<P>::type return_type;
+
+ {
+ // Basic, trivial test
+
+ P p1;
+ bg::set<0>(p1, 1);
+ bg::set<1>(p1, 1);
+
+ P p2;
+ bg::set<0>(p2, 2);
+ bg::set<1>(p2, 2);
+
+ return_type d = bg::distance(p1, p2);
+ BOOST_CHECK_CLOSE(d, return_type(1.4142135), 0.001);
+
+ // Test specifying strategy manually
+ typename services::default_strategy<bg::point_tag, P>::type strategy;
+
+ d = bg::distance(p1, p2, strategy);
+ BOOST_CHECK_CLOSE(d, return_type(1.4142135), 0.001);
- double d = boost::geometry::distance(p1, p2);
- BOOST_CHECK_CLOSE(d, 1.4142135, 0.001);
+ {
+ // Test custom strategy
+ BOOST_CONCEPT_ASSERT( (bg::concept::PointDistanceStrategy<taxicab_distance<P> >) );
+
+ typedef typename services::return_type<taxicab_distance<P> >::type cab_return_type;
+ BOOST_MPL_ASSERT((boost::is_same<cab_return_type, typename bg::coordinate_type<P>::type>));
+
+ taxicab_distance<P> tcd;
+ cab_return_type d = bg::distance(p1, p2, tcd);
+
+ BOOST_CHECK( bg::math::abs(d - cab_return_type(2)) <= cab_return_type(0.01) );
+ }
+ }
+
+
+ {
+ // 3-4-5 angle
+ P p1, p2, p3;
+ bg::set<0>(p1, 0); bg::set<1>(p1, 0);
+ bg::set<0>(p2, 3); bg::set<1>(p2, 0);
+ bg::set<0>(p3, 0); bg::set<1>(p3, 4);
+
+ return_type dr12 = bg::distance(p1, p2);
+ return_type dr13 = bg::distance(p1, p3);
+ return_type dr23 = bg::distance(p2, p3);
+
+ BOOST_CHECK_CLOSE(dr12, return_type(3), 0.001);
+ BOOST_CHECK_CLOSE(dr13, return_type(4), 0.001);
+ BOOST_CHECK_CLOSE(dr23, return_type(5), 0.001);
+ }
+
+
+ {
+ // test comparability
+
+ typedef typename services::default_strategy<bg::point_tag, P>::type strategy_type;
+ typedef typename services::comparable_type<strategy_type>::type comparable_strategy_type;
+
+ strategy_type strategy;
+ comparable_strategy_type comparable_strategy = services::get_comparable<strategy_type>::apply(strategy);
+ return_type comparable = services::result_from_distance<comparable_strategy_type>::apply(comparable_strategy, 3);
+
+ BOOST_CHECK_CLOSE(comparable, return_type(9), 0.001);
+ }
}
template <typename P>
void test_distance_segment()
{
- typedef typename boost::geometry::coordinate_type<P>::type coordinate_type;
+ typedef typename bg::distance_result<P>::type return_type;
+ typedef typename bg::coordinate_type<P>::type coordinate_type;
- P s1; boost::geometry::set<0>(s1, 2); boost::geometry::set<1>(s1, 2);
- P s2; boost::geometry::set<0>(s2, 3); boost::geometry::set<1>(s2, 3);
+ P s1; bg::set<0>(s1, 1); bg::set<1>(s1, 1);
+ P s2; bg::set<0>(s2, 4); bg::set<1>(s2, 4);
// Check points left, right, projected-left, projected-right, on segment
- P p1; boost::geometry::set<0>(p1, 0); boost::geometry::set<1>(p1, 0);
- P p2; boost::geometry::set<0>(p2, 4); boost::geometry::set<1>(p2, 4);
- P p3; boost::geometry::set<0>(p3, coordinate_type(2.4)); boost::geometry::set<1>(p3, coordinate_type(2.6));
- P p4; boost::geometry::set<0>(p4, coordinate_type(2.6)); boost::geometry::set<1>(p4, coordinate_type(2.4));
- P p5; boost::geometry::set<0>(p5, 2.5); boost::geometry::set<1>(p5, 2.5);
-
- const boost::geometry::segment<const P> seg(s1, s2);
-
- double d1 = boost::geometry::distance(p1, seg); BOOST_CHECK_CLOSE(d1, 2.8284271, 0.001);
- double d2 = boost::geometry::distance(p2, seg); BOOST_CHECK_CLOSE(d2, 1.4142135, 0.001);
- double d3 = boost::geometry::distance(p3, seg); BOOST_CHECK_CLOSE(d3, 0.141421, 0.001);
- double d4 = boost::geometry::distance(p4, seg); BOOST_CHECK_CLOSE(d4, 0.141421, 0.001);
- double d5 = boost::geometry::distance(p5, seg); BOOST_CHECK_CLOSE(d5, 0.0, 0.001);
-
- // Reverse case
- double dr1 = boost::geometry::distance(seg, p1); BOOST_CHECK_CLOSE(dr1, d1, 0.001);
- double dr2 = boost::geometry::distance(seg, p2); BOOST_CHECK_CLOSE(dr2, d2, 0.001);
+ P p1; bg::set<0>(p1, 0); bg::set<1>(p1, 1);
+ P p2; bg::set<0>(p2, 1); bg::set<1>(p2, 0);
+ P p3; bg::set<0>(p3, 3); bg::set<1>(p3, 1);
+ P p4; bg::set<0>(p4, 1); bg::set<1>(p4, 3);
+ P p5; bg::set<0>(p5, 3); bg::set<1>(p5, 3);
+
+ bg::segment<P const> const seg(s1, s2);
+
+ return_type d1 = bg::distance(p1, seg);
+ return_type d2 = bg::distance(p2, seg);
+ return_type d3 = bg::distance(p3, seg);
+ return_type d4 = bg::distance(p4, seg);
+ return_type d5 = bg::distance(p5, seg);
+
+ BOOST_CHECK_CLOSE(d1, return_type(1), 0.001);
+ BOOST_CHECK_CLOSE(d2, return_type(1), 0.001);
+ BOOST_CHECK_CLOSE(d3, return_type(1.4142135), 0.001);
+ BOOST_CHECK_CLOSE(d4, return_type(1.4142135), 0.001);
+ BOOST_CHECK_CLOSE(d5, return_type(0), 0.001);
+
+ // Reverse case: segment/point instead of point/segment
+ return_type dr1 = bg::distance(seg, p1);
+ return_type dr2 = bg::distance(seg, p2);
+
+ BOOST_CHECK_CLOSE(dr1, d1, 0.001);
+ BOOST_CHECK_CLOSE(dr2, d2, 0.001);
+
+ // Test specifying strategy manually:
+ // 1) point-point-distance
+ typename bg::strategy::distance::services::default_strategy<bg::point_tag, P>::type pp_strategy;
+ d1 = bg::distance(p1, seg, pp_strategy);
+ BOOST_CHECK_CLOSE(d1, return_type(1), 0.001);
+
+ // 2) point-segment-distance
+ typename bg::strategy::distance::services::default_strategy<bg::segment_tag, P>::type ps_strategy;
+ d1 = bg::distance(p1, seg, ps_strategy);
+ BOOST_CHECK_CLOSE(d1, return_type(1), 0.001);
+
+ // 3) custom point strategy
+ taxicab_distance<P> tcd;
+ return_type d = bg::distance(p1, seg, tcd);
+ BOOST_CHECK_CLOSE(d1, return_type(1), 0.001);
}
+
template <typename P>
void test_distance_linestring()
{
- typedef typename boost::geometry::coordinate_type<P>::type coordinate_type;
+ typedef typename bg::distance_result<P>::type return_type;
boost::array<P, 2> points;
- boost::geometry::set<0>(points[0], 1);
- boost::geometry::set<1>(points[0], 1);
- boost::geometry::set<0>(points[1], 3);
- boost::geometry::set<1>(points[1], 3);
+ bg::set<0>(points[0], 1);
+ bg::set<1>(points[0], 1);
+ bg::set<0>(points[1], 3);
+ bg::set<1>(points[1], 3);
-#ifndef TEST_ARRAY
- P p = boost::geometry::make<P>(2, 1);
-#else
P p;
- boost::geometry::set<0>(p, 2); boost::geometry::set<1>(p, 1);
-#endif
+ bg::set<0>(p, 2); bg::set<1>(p, 1);
- double d = boost::geometry::distance(p, points);
- BOOST_CHECK_CLOSE(d, 0.70710678, 0.001);
+ return_type d = bg::distance(p, points);
+ BOOST_CHECK_CLOSE(d, return_type(0.70710678), 0.001);
-#ifndef TEST_ARRAY
- p = boost::geometry::make<P>(5, 5);
-#else
- boost::geometry::set<0>(p, 5); boost::geometry::set<1>(p, 5);
-#endif
- d = boost::geometry::distance(p, points);
- BOOST_CHECK_CLOSE(d, 2.828427, 0.001);
+ bg::set<0>(p, 5); bg::set<1>(p, 5);
+ d = bg::distance(p, points);
+ BOOST_CHECK_CLOSE(d, return_type(2.828427), 0.001);
- boost::geometry::linestring<P> line;
-#ifndef TEST_ARRAY
- line.push_back(boost::geometry::make<P>(1,1));
- line.push_back(boost::geometry::make<P>(2,2));
- line.push_back(boost::geometry::make<P>(3,3));
-#else
+ bg::linestring<P> line;
{
P lp;
- boost::geometry::set<0>(lp, 1); boost::geometry::set<1>(lp, 1); line.push_back(lp);
- boost::geometry::set<0>(lp, 2); boost::geometry::set<1>(lp, 2); line.push_back(lp);
- boost::geometry::set<0>(lp, 3); boost::geometry::set<1>(lp, 3); line.push_back(lp);
+ bg::set<0>(lp, 1); bg::set<1>(lp, 1); line.push_back(lp);
+ bg::set<0>(lp, 2); bg::set<1>(lp, 2); line.push_back(lp);
+ bg::set<0>(lp, 3); bg::set<1>(lp, 3); line.push_back(lp);
}
-#endif
-#ifndef TEST_ARRAY
- p = boost::geometry::make<P>(5, 5);
-#else
- boost::geometry::set<0>(p, 5); boost::geometry::set<1>(p, 5);
-#endif
+ bg::set<0>(p, 5); bg::set<1>(p, 5);
- d = boost::geometry::distance(p, line);
- BOOST_CHECK_CLOSE(d, 2.828427, 0.001);
+ d = bg::distance(p, line);
+ BOOST_CHECK_CLOSE(d, return_type(2.828427), 0.001);
- // Reverse case
- d = boost::geometry::distance(line, p);
- BOOST_CHECK_CLOSE(d, 2.828427, 0.001);
+ // Reverse case: line/point instead of point/line
+ d = bg::distance(line, p);
+ BOOST_CHECK_CLOSE(d, return_type(2.828427), 0.001);
}
+
+template <typename P>
+void test_distance_ring()
+{
+ typedef typename bg::distance_result<P>::type return_type;
+
+ bg::linear_ring<P> ring;
+ {
+ P lp;
+ bg::set<0>(lp, 1); bg::set<1>(lp, 1); line.push_back(lp);
+ bg::set<0>(lp, 2); bg::set<1>(lp, 2); line.push_back(lp);
+ bg::set<0>(lp, 3); bg::set<1>(lp, 3); line.push_back(lp);
+ }
+
+ bg::set<0>(p, 5); bg::set<1>(p, 5);
+
+ d = bg::distance(p, line);
+ BOOST_CHECK_CLOSE(d, return_type(2.828427), 0.001);
+
+ // Reverse case: line/point instead of point/line
+ d = bg::distance(line, p);
+ BOOST_CHECK_CLOSE(d, return_type(2.828427), 0.001);
+}
+
+
template <typename P>
void test_all()
{
- test_distance_result<P>();
test_distance_point<P>();
-// test_distance_segment<P>();
-#ifndef TEST_ARRAY
- //test_distance_linestring<P>();
-#endif
+ test_distance_segment<P>();
+ test_distance_linestring<P>();
}
int test_main(int, char* [])
{
#ifdef TEST_ARRAY
- test_all<int[2]>();
- test_all<float[2]>();
- test_all<double[2]>();
- test_all<test::test_point>(); // located here because of 3D
+ //test_all<int[2]>();
+ //test_all<float[2]>();
+ //test_all<double[2]>();
+ //test_all<test::test_point>(); // located here because of 3D
#endif
- test_all<boost::geometry::point_xy<int> >();
+ test_all<bg::point_xy<int> >();
test_all<boost::tuple<float, float> >();
- test_all<boost::geometry::point_xy<float> >();
- test_all<boost::geometry::point_xy<double> >();
+ test_all<bg::point_xy<float> >();
+ test_all<bg::point_xy<double> >();
return 0;
}
Modified: sandbox/geometry/libs/geometry/test/algorithms/within.cpp
==============================================================================
--- sandbox/geometry/libs/geometry/test/algorithms/within.cpp (original)
+++ sandbox/geometry/libs/geometry/test/algorithms/within.cpp 2010-07-17 06:46:25 EDT (Sat, 17 Jul 2010)
@@ -77,5 +77,5 @@
test_all<boost::geometry::point_xy<boost::numeric_adaptor::gmp_value_type> >();
#endif
- return 0;
+ return 0;
}