672 lines
23 KiB
C++
672 lines
23 KiB
C++
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
|
// Unit Test
|
|
|
|
// Copyright (c) 2014-2018, Oracle and/or its affiliates.
|
|
|
|
// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
|
|
// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
|
|
|
|
// Licensed under the Boost Software License version 1.0.
|
|
// http://www.boost.org/users/license.html
|
|
|
|
#include <iostream>
|
|
|
|
#ifndef BOOST_TEST_MODULE
|
|
#define BOOST_TEST_MODULE test_distance_cartesian_pointlike_areal
|
|
#endif
|
|
|
|
#include <boost/test/included/unit_test.hpp>
|
|
|
|
#include "test_distance_common.hpp"
|
|
|
|
|
|
typedef bg::model::point<double,2,bg::cs::cartesian> point_type;
|
|
typedef bg::model::multi_point<point_type> multi_point_type;
|
|
typedef bg::model::point<double,3,bg::cs::cartesian> point_type_3d;
|
|
typedef bg::model::multi_point<point_type_3d> multi_point_type_3d;
|
|
typedef bg::model::polygon<point_type, false> polygon_type;
|
|
typedef bg::model::multi_polygon<polygon_type> multi_polygon_type;
|
|
typedef bg::model::ring<point_type, false> ring_type;
|
|
typedef bg::model::box<point_type> box_type;
|
|
typedef bg::model::box<point_type_3d> box_type_3d;
|
|
|
|
namespace services = bg::strategy::distance::services;
|
|
typedef bg::default_distance_result<point_type>::type return_type;
|
|
|
|
typedef bg::strategy::distance::pythagoras<> point_point_strategy;
|
|
typedef bg::strategy::distance::projected_point<> point_segment_strategy;
|
|
typedef bg::strategy::distance::pythagoras_point_box<> point_box_strategy;
|
|
|
|
//===========================================================================
|
|
|
|
template <typename Strategy>
|
|
void test_distance_point_polygon(Strategy const& strategy)
|
|
{
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
std::cout << std::endl;
|
|
std::cout << "point/polygon distance tests" << std::endl;
|
|
#endif
|
|
typedef test_distance_of_geometries<point_type, polygon_type> tester;
|
|
|
|
tester::apply("point(0 -20)",
|
|
"polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
|
|
10, 100, strategy);
|
|
|
|
tester::apply("point(12 0)",
|
|
"polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
|
|
2, 4, strategy);
|
|
|
|
tester::apply("point(0 0)",
|
|
"polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
|
|
0, 0, strategy);
|
|
|
|
tester::apply("point(0 0)",
|
|
"polygon((-10 -10,10 -10,10 10,-10 10,-10 -10),\
|
|
(-5 -5,-5 5,5 5,5 -5,-5 -5))",
|
|
5, 25, strategy);
|
|
|
|
// polygons with single-point rings
|
|
tester::apply("point(0 0)",
|
|
"polygon((-5 5))",
|
|
sqrt(50.0), 50, strategy);
|
|
|
|
tester::apply("point(0 0)",
|
|
"polygon((-10 -10,10 -10,10 10,-10 10,-10 -10),(-5 5))",
|
|
0, 0, strategy);
|
|
}
|
|
|
|
//===========================================================================
|
|
|
|
template <typename Strategy>
|
|
void test_distance_point_ring(Strategy const& strategy)
|
|
{
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
std::cout << std::endl;
|
|
std::cout << "point/ring distance tests" << std::endl;
|
|
#endif
|
|
typedef test_distance_of_geometries<point_type, ring_type> tester;
|
|
|
|
tester::apply("point(0 -20)",
|
|
"polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
|
|
10, 100, strategy);
|
|
|
|
tester::apply("point(12 0)",
|
|
"polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
|
|
2, 4, strategy);
|
|
|
|
tester::apply("point(0 0)",
|
|
"polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
|
|
0, 0, strategy);
|
|
|
|
// single-point rings
|
|
tester::apply("point(0 0)",
|
|
"polygon((-10 -10))",
|
|
sqrt(200.0), 200, strategy);
|
|
}
|
|
|
|
//===========================================================================
|
|
|
|
template <typename Strategy>
|
|
void test_distance_point_multipolygon(Strategy const& strategy)
|
|
{
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
std::cout << std::endl;
|
|
std::cout << "point/multipolygon distance tests" << std::endl;
|
|
#endif
|
|
typedef test_distance_of_geometries<point_type, multi_polygon_type> tester;
|
|
|
|
tester::apply("point(0 -20)",
|
|
"multipolygon(((-10 -10,10 -10,10 10,-10 10,-10 -10)),\
|
|
((0 22,-1 30,2 40,0 22)))",
|
|
10, 100, strategy);
|
|
|
|
tester::apply("point(12 0)",
|
|
"multipolygon(((-10 -10,10 -10,10 10,-10 10,-10 -10)),\
|
|
((20 -1,21 2,30 -10,20 -1)))",
|
|
2, 4, strategy);
|
|
|
|
tester::apply("point(0 0)",
|
|
"multipolygon(((-10 -10,10 -10,10 10,-10 10,-10 -10)),\
|
|
((20 -1,21 2,30 -10,20 -1)))",
|
|
0, 0, strategy);
|
|
|
|
tester::apply("point(0 0)",
|
|
"multipolygon(((-10 -10,10 -10,10 10,-10 10,-10 -10),\
|
|
(-5 -5,-5 5,5 5,5 -5,-5 -5)),\
|
|
((100 0,101 0,101 1,100 1,100 0)))",
|
|
5, 25, strategy);
|
|
}
|
|
|
|
//===========================================================================
|
|
|
|
template <typename Strategy>
|
|
void test_distance_multipoint_polygon(Strategy const& strategy)
|
|
{
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
std::cout << std::endl;
|
|
std::cout << "multipoint/polygon distance tests" << std::endl;
|
|
#endif
|
|
typedef test_distance_of_geometries<multi_point_type, polygon_type> tester;
|
|
|
|
tester::apply("multipoint(0 -20,0 -15)",
|
|
"polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
|
|
5, 25, strategy);
|
|
|
|
tester::apply("multipoint(16 0,12 0)",
|
|
"polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
|
|
2, 4, strategy);
|
|
|
|
tester::apply("multipoint(0 0,5 5,4 4)",
|
|
"polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
|
|
0, 0, strategy);
|
|
|
|
tester::apply("multipoint(0 0,2 0)",
|
|
"polygon((-10 -10,10 -10,10 10,-10 10,-10 -10),\
|
|
(-5 -5,-5 5,5 5,5 -5,-5 -5))",
|
|
3, 9, strategy);
|
|
|
|
tester::apply("multipoint(4 4,11 11)",
|
|
"polygon((0 0,0 10,10 10,10 0,0 0))",
|
|
0, 0, strategy);
|
|
}
|
|
|
|
//===========================================================================
|
|
|
|
template <typename Strategy>
|
|
void test_distance_multipoint_ring(Strategy const& strategy)
|
|
{
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
std::cout << std::endl;
|
|
std::cout << "multipoint/ring distance tests" << std::endl;
|
|
#endif
|
|
typedef test_distance_of_geometries<multi_point_type, ring_type> tester;
|
|
|
|
tester::apply("multipoint(0 -20,0 -15)",
|
|
"polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
|
|
5, 25, strategy);
|
|
|
|
tester::apply("multipoint(16 0,12 0)",
|
|
"polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
|
|
2, 4, strategy);
|
|
|
|
tester::apply("multipoint(0 0,5 5,4 4)",
|
|
"polygon((-10 -10,10 -10,10 10,-10 10,-10 -10))",
|
|
0, 0, strategy);
|
|
|
|
// single-point ring
|
|
tester::apply("multipoint(0 0,5 5,4 4)",
|
|
"polygon((10 10))",
|
|
sqrt(50.0), 50, strategy);
|
|
}
|
|
|
|
//===========================================================================
|
|
|
|
template <typename Strategy>
|
|
void test_distance_multipoint_multipolygon(Strategy const& strategy)
|
|
{
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
std::cout << std::endl;
|
|
std::cout << "multipoint/multipolygon distance tests" << std::endl;
|
|
#endif
|
|
typedef test_distance_of_geometries
|
|
<
|
|
multi_point_type, multi_polygon_type
|
|
> tester;
|
|
|
|
tester::apply("multipoint(0 -20,0 -15)",
|
|
"multipolygon(((-10 -10,10 -10,10 10,-10 10,-10 -10)),\
|
|
((0 22,-1 30,2 40,0 22)))",
|
|
5, 25, strategy);
|
|
|
|
tester::apply("multipoint(16 0,12 0)",
|
|
"multipolygon(((-10 -10,10 -10,10 10,-10 10,-10 -10)),\
|
|
((20 -1,21 2,30 -10,20 -1)))",
|
|
2, 4, strategy);
|
|
|
|
tester::apply("multipoint(0 0,4 4,5 5)",
|
|
"multipolygon(((-10 -10,10 -10,10 10,-10 10,-10 -10)),\
|
|
((20 -1,21 2,30 -10,20 -1)))",
|
|
0, 0, strategy);
|
|
|
|
tester::apply("multipoint(0 0,2 0)",
|
|
"multipolygon(((-10 -10,10 -10,10 10,-10 10,-10 -10),\
|
|
(-5 -5,-5 5,5 5,5 -5,-5 -5)),\
|
|
((100 0,101 0,101 1,100 1,100 0)))",
|
|
3, 9, strategy);
|
|
|
|
tester::apply("MULTIPOINT(19 19,100 100)",
|
|
"MULTIPOLYGON(((0 0,0 10,10 10,10 0,0 0),\
|
|
(4 4,4 6,6 6,6 4,4 4)), ((10 10,10 20,20 20,20 10,10 10),\
|
|
(14 14,14 16,16 16,16 14,14 14)))",
|
|
0, 0, strategy);
|
|
}
|
|
|
|
//===========================================================================
|
|
|
|
template <typename Strategy>
|
|
void test_distance_point_box_2d(Strategy const& strategy)
|
|
{
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
std::cout << std::endl;
|
|
std::cout << "2D point/box distance tests" << std::endl;
|
|
#endif
|
|
typedef test_distance_of_geometries<box_type, point_type> tester;
|
|
|
|
// point inside box
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(0 0)", 0, 0, strategy);
|
|
|
|
// points on box corners
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(-1 -1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(-1 1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(1 -1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(1 1)", 0, 0, strategy);
|
|
|
|
// points on box boundary edges
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(0 -1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(-1 0)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(1 0)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(0 1)", 0, 0, strategy);
|
|
|
|
// points outside box
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(0 4)", 3, 9, strategy);
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(0.5 4)", 3, 9, strategy);
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(-0.5 5)", 4, 16, strategy);
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(3 0.25)", 2, 4, strategy);
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(-3 -0.25)", 2, 4, strategy);
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(3 5)", sqrt(20.0), 20, strategy);
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(-5 -4)", 5, 25, strategy);
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(2 -2)", sqrt(2.0), 2, strategy);
|
|
tester::apply("box(-1 -1,1 1)",
|
|
"point(-3 4)", sqrt(13.0), 13, strategy);
|
|
}
|
|
|
|
//===========================================================================
|
|
|
|
template <typename Strategy>
|
|
void test_distance_point_box_different_point_types(Strategy const& strategy)
|
|
{
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
std::cout << std::endl;
|
|
std::cout << "2D point/box distance tests with different points"
|
|
<< std::endl;
|
|
#endif
|
|
typedef point_type double_point;
|
|
typedef box_type double_box;
|
|
typedef bg::model::point<int,2,bg::cs::cartesian> int_point;
|
|
typedef bg::model::box<int_point> int_box;
|
|
|
|
test_distance_of_geometries
|
|
<
|
|
int_point, int_box
|
|
>::apply("point(0 0)",
|
|
"box(1 1, 2 2)",
|
|
sqrt(2.0), 2, strategy);
|
|
|
|
test_distance_of_geometries
|
|
<
|
|
double_point, int_box
|
|
>::apply("point(0.5 0)",
|
|
"box(1 -1,2 1)",
|
|
0.5, 0.25, strategy);
|
|
|
|
test_distance_of_geometries
|
|
<
|
|
double_point, double_box
|
|
>::apply("point(1.5 0)",
|
|
"box(1 -1,2 1)",
|
|
0, 0, strategy);
|
|
|
|
test_distance_of_geometries
|
|
<
|
|
double_point, int_box
|
|
>::apply("point(1.5 0)",
|
|
"box(1 -1,2 1)",
|
|
0, 0, strategy);
|
|
|
|
test_distance_of_geometries
|
|
<
|
|
int_point, double_box
|
|
>::apply("point(1 0)",
|
|
"box(0.5 -1,1.5 1)",
|
|
0, 0, strategy);
|
|
|
|
test_distance_of_geometries
|
|
<
|
|
int_point, double_box
|
|
>::apply("point(0 0)",
|
|
"box(0.5, -1,1.5, 1)",
|
|
0.5, 0.25, strategy);
|
|
}
|
|
|
|
//===========================================================================
|
|
|
|
template <typename Strategy>
|
|
void test_distance_point_box_3d(Strategy const& strategy)
|
|
{
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
std::cout << std::endl;
|
|
std::cout << "3D point/box distance tests" << std::endl;
|
|
#endif
|
|
typedef test_distance_of_geometries<box_type_3d, point_type_3d> tester;
|
|
|
|
// point inside box
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(0 0 0)", 0, 0, strategy);
|
|
|
|
// points on box corners
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-1 -1 -1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-1 -1 1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-1 1 -1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-1 1 1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(1 -1 -1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(1 -1 1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(1 1 -1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(1 1 1)", 0, 0, strategy);
|
|
|
|
// points on box boundary edges
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(0 -1 -1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(0 -1 1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(0 1 -1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(0 1 1)", 0, 0, strategy);
|
|
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-1 0 -1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-1 0 1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(1 0 -1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(1 0 1)", 0, 0, strategy);
|
|
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-1 -1 0)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-1 1 0)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(1 -1 0)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(1 1 0)", 0, 0, strategy);
|
|
|
|
// point on box faces
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(0 0 -1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(0 0 1)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(0 -1 0)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(0 1 0)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-1 0 0)", 0, 0, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(1 0 0)", 0, 0, strategy);
|
|
|
|
// points outside box -- closer to box corners
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-2 -3 -4)", sqrt(14.0), 14, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-2 -3 3)", 3, 9, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-2 5 -2)", sqrt(18.0), 18, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-2 5 3)", sqrt(21.0), 21, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(4 -6 -3)", sqrt(38.0), 38, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(4 -6 4)", sqrt(43.0), 43, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(4 7 -2)", sqrt(46.0), 46, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(4 7 8)", sqrt(94.0), 94, strategy);
|
|
|
|
|
|
// points closer to box facets
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(0 0 10)", 9, 81, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(0 0 -5)", 4, 16, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(0 7 0)", 6, 36, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(0 -6 0)", 5, 25, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(4 0 0)", 3, 9, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-3 0 0)", 2, 4, strategy);
|
|
|
|
// points closer to box edges
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(0 -4 -5)", 5, 25, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(0 -3 6)", sqrt(29.0), 29, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(0 2 -7)", sqrt(37.0), 37, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(0 8 7)", sqrt(85.0), 85, strategy);
|
|
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-4 0 -4)", sqrt(18.0), 18, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-3 0 5)", sqrt(20.0), 20, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(2 0 -6)", sqrt(26.0), 26, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(8 0 6)", sqrt(74.0), 74, strategy);
|
|
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-5 -5 0)", sqrt(32.0), 32, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(-4 6 0)", sqrt(34.0), 34, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(3 -7 0)", sqrt(40.0), 40, strategy);
|
|
tester::apply("box(-1 -1 -1,1 1 1)",
|
|
"point(9 7 0)", 10, 100, strategy);
|
|
}
|
|
|
|
//===========================================================================
|
|
|
|
template <typename Strategy>
|
|
void test_distance_multipoint_box_2d(Strategy const& strategy)
|
|
{
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
std::cout << std::endl;
|
|
std::cout << "2D multipoint/box distance tests" << std::endl;
|
|
#endif
|
|
typedef test_distance_of_geometries<box_type, multi_point_type> tester;
|
|
|
|
// at least one point inside the box
|
|
tester::apply("box(0 0,10 10)",
|
|
"multipoint(0 0,-1 -1,20 20)",
|
|
0, 0, strategy);
|
|
|
|
tester::apply("box(0 0,10 10)",
|
|
"multipoint(1 1,-1 -1,20 20)",
|
|
0, 0, strategy);
|
|
|
|
tester::apply("box(0 0,10 10)",
|
|
"multipoint(1 1,2 2,3 3)",
|
|
0, 0, strategy);
|
|
|
|
// all points outside the box
|
|
tester::apply("box(0 0,10 10)",
|
|
"multipoint(-1 -1,20 20)",
|
|
sqrt(2.0), 2, strategy);
|
|
|
|
tester::apply("box(0 0,10 10)",
|
|
"multipoint(5 13, 50 50)",
|
|
3, 9, strategy);
|
|
}
|
|
|
|
//===========================================================================
|
|
|
|
template <typename Strategy>
|
|
void test_distance_multipoint_box_3d(Strategy const& strategy)
|
|
{
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
std::cout << std::endl;
|
|
std::cout << "3D multipoint/box distance tests" << std::endl;
|
|
#endif
|
|
typedef test_distance_of_geometries
|
|
<
|
|
box_type_3d, multi_point_type_3d
|
|
> tester;
|
|
|
|
// at least one point inside the box
|
|
tester::apply("box(0 0 0,10 10 10)",
|
|
"multipoint(0 0 0,-1 -1 -1,20 20 20)",
|
|
0, 0, strategy);
|
|
|
|
tester::apply("box(0 0 0,10 10 10)",
|
|
"multipoint(1 1 1,-1 -1 -1,20 20 20)",
|
|
0, 0, strategy);
|
|
|
|
tester::apply("box(0 0 0,10 10 10)",
|
|
"multipoint(1 1 1,2 2 2,3 3 3)",
|
|
0, 0, strategy);
|
|
|
|
// all points outside the box
|
|
tester::apply("box(0 0 0,10 10 10)",
|
|
"multipoint(-1 -1 -1,20 20 20)",
|
|
sqrt(3.0), 3, strategy);
|
|
|
|
tester::apply("box(0 0 0,10 10 10)",
|
|
"multipoint(5 5 13,50 50 50)",
|
|
3, 9, strategy);
|
|
}
|
|
|
|
//===========================================================================
|
|
|
|
template <typename Point, typename Strategy>
|
|
void test_more_empty_input_pointlike_areal(Strategy const& strategy)
|
|
{
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
std::cout << std::endl;
|
|
std::cout << "testing on empty inputs... " << std::flush;
|
|
#endif
|
|
bg::model::multi_point<Point> multipoint_empty;
|
|
bg::model::polygon<Point> polygon_empty;
|
|
bg::model::multi_polygon<bg::model::polygon<Point> > multipolygon_empty;
|
|
bg::model::ring<Point> ring_empty;
|
|
|
|
Point point = from_wkt<Point>("point(0 0)");
|
|
bg::model::polygon<Point> polygon =
|
|
from_wkt<bg::model::polygon<Point> >("polygon((0 0,1 0,0 1))");
|
|
bg::model::ring<Point> ring =
|
|
from_wkt<bg::model::ring<Point> >("polygon((0 0,1 0,0 1))");
|
|
|
|
// 1st geometry is empty
|
|
test_empty_input(multipoint_empty, polygon, strategy);
|
|
test_empty_input(multipoint_empty, ring, strategy);
|
|
|
|
// 2nd geometry is empty
|
|
test_empty_input(point, polygon_empty, strategy);
|
|
test_empty_input(point, multipolygon_empty, strategy);
|
|
test_empty_input(point, ring_empty, strategy);
|
|
|
|
// both geometries are empty
|
|
test_empty_input(multipoint_empty, polygon_empty, strategy);
|
|
test_empty_input(multipoint_empty, multipolygon_empty, strategy);
|
|
test_empty_input(multipoint_empty, ring_empty, strategy);
|
|
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
std::cout << "done!" << std::endl;
|
|
#endif
|
|
}
|
|
|
|
//===========================================================================
|
|
|
|
BOOST_AUTO_TEST_CASE( test_all_pointlike_polygon )
|
|
{
|
|
test_distance_point_polygon(point_point_strategy()); // back-compatibility
|
|
test_distance_point_polygon(point_segment_strategy());
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( test_all_point_multipolygon )
|
|
{
|
|
test_distance_point_multipolygon(point_point_strategy()); // back-compatibility
|
|
test_distance_point_multipolygon(point_segment_strategy());
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( test_all_point_ring )
|
|
{
|
|
test_distance_point_ring(point_point_strategy()); // back-compatibility
|
|
test_distance_point_ring(point_segment_strategy());
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( test_all_multipoint_polygon )
|
|
{
|
|
test_distance_multipoint_polygon(point_point_strategy()); // back-compatibility
|
|
test_distance_multipoint_polygon(point_segment_strategy());
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( test_all_multipoint_multipolygon )
|
|
{
|
|
test_distance_multipoint_multipolygon(point_point_strategy()); // back-compatibility
|
|
test_distance_multipoint_multipolygon(point_segment_strategy());
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( test_all_multipoint_ring )
|
|
{
|
|
test_distance_multipoint_ring(point_segment_strategy());
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( test_all_point_box_2d )
|
|
{
|
|
point_box_strategy pb_strategy;
|
|
|
|
test_distance_point_box_2d(pb_strategy);
|
|
test_distance_point_box_different_point_types(pb_strategy);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( test_all_point_box_3d )
|
|
{
|
|
test_distance_point_box_3d(point_box_strategy());
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( test_all_multipoint_box_2d )
|
|
{
|
|
test_distance_multipoint_box_2d(point_box_strategy());
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( test_all_multipoint_box_3d )
|
|
{
|
|
test_distance_multipoint_box_3d(point_box_strategy());
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( test_all_empty_input_pointlike_areal )
|
|
{
|
|
test_more_empty_input_pointlike_areal
|
|
<
|
|
point_type
|
|
>(point_segment_strategy());
|
|
}
|