ceph/src/boost/libs/geometry/test/algorithms/set_operations/union/union_aa_geo.cpp

   1 // Boost.Geometry
   2 // Unit Test
   3
   4 // Copyright (c) 2017, Oracle and/or its affiliates.
   5 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
   6
   7 // Use, modification and distribution is subject to the Boost Software License,
   8 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
   9 // http://www.boost.org/LICENSE_1_0.txt)
  10
  11 #include <iostream>
  12 #include <string>
  13
  14 #include "test_union.hpp"
  15
  16 #include <boost/geometry/geometries/point_xy.hpp>
  17
  18
  19 struct exterior_points_counter
  20 {
  21     exterior_points_counter() : count(0) {}
  22
  23     template <typename Polygon>
  24     void operator()(Polygon const& poly)
  25     {
  26         count += boost::size(bg::exterior_ring(poly));
  27     }
  28
  29     std::size_t count;
  30 };
  31
  32 struct interiors_counter
  33     : exterior_points_counter
  34 {
  35     template <typename Polygon>
  36     void operator()(Polygon const& poly)
  37     {
  38         count += boost::size(bg::interior_rings(poly));
  39     }
  40 };
  41
  42 void test_geographic_one(std::string const& wkt1, std::string const& wkt2,
  43                          std::size_t count, std::size_t exterior_points_count, std::size_t interiors_count,
  44                          double expected_area)
  45 {
  46     typedef bg::model::point<double, 2, bg::cs::geographic<bg::degree> > point;
  47     typedef bg::model::polygon<point> polygon;
  48     typedef bg::model::multi_polygon<polygon> multipolygon;
  49
  50     bg::srs::spheroid<double> sph(6378137.0000000000, 6356752.3142451793);
  51
  52     bg::strategy::intersection::geographic_segments<> is(sph);
  53     bg::strategy::area::geographic<point> as(sph);
  54
  55     polygon p1, p2;
  56
  57     boost::geometry::read_wkt(wkt1, p1);
  58     boost::geometry::read_wkt(wkt2, p2);
  59
  60     multipolygon result;
  61
  62     enum test_mode { expect_valid, expect_empty, expect_exception };
  63
  64 #if defined(BOOST_GEOMETRY_UNION_THROW_INVALID_OUTPUT_EXCEPTION)
  65     test_mode mode = expected_area >= 0 ? expect_valid : expect_exception;
  66 #elif defined(BOOST_GEOMETRY_UNION_RETURN_INVALID)
  67     test_mode mode = expect_valid;
  68 #else
  69     // default
  70     test_mode mode = expected_area >= 0 ? expect_valid : expect_empty;
  71 #endif
  72
  73     if (mode == expect_exception)
  74     {
  75         BOOST_CHECK_THROW(boost::geometry::union_(p1, p2, result, is),
  76                           bg::invalid_output_exception);
  77     }
  78     else
  79     {
  80
  81         boost::geometry::union_(p1, p2, result, is);
  82
  83         double result_area = bg::area(result, as);
  84
  85         std::size_t result_count = boost::size(result);
  86         std::size_t result_exterior_points = std::for_each(boost::begin(result),
  87                                                            boost::end(result),
  88                                                            exterior_points_counter()).count;
  89         std::size_t result_interiors = std::for_each(boost::begin(result),
  90                                                      boost::end(result),
  91                                                      interiors_counter()).count;
  92         if (mode == expect_valid)
  93         {
  94             BOOST_CHECK_EQUAL(result_count, count);
  95             BOOST_CHECK_EQUAL(result_exterior_points, exterior_points_count);
  96             BOOST_CHECK_EQUAL(result_interiors, interiors_count);
  97             BOOST_CHECK_CLOSE(result_area, expected_area, 0.001);
  98         }
  99         else
 100         {
 101             BOOST_CHECK_EQUAL(result_count, 0);
 102             BOOST_CHECK_EQUAL(result_area, 0);
 103         }
 104     }
 105 }
 106
 107
 108 void test_geographic()
 109 {
 110     // input ok and the result is ok
 111     test_geographic_one("POLYGON((16 15,-132 10,-56 89,67 5,16 15))",
 112                         "POLYGON((101 49,12 40,-164 10,117 0,101 49))",
 113                         1, 9, 0, 144265751613509.06);
 114
 115     // input ok but the result is too big
 116     test_geographic_one("POLYGON((16 -15,-132 -22,-56 89,67 -29,16 -15))",
 117                         "POLYGON((101 49,12 40,-164 -21,117 -61,101 49))",
 118                         1, 9, 0, -163427005620080.0);
 119
 120     // the second polygon is reversed i.e. it covers more than half of the globe
 121     // so the result is also too big
 122     test_geographic_one("POLYGON((16 -15,-132 -22,-56 89,67 -29,16 -15))",
 123                         "POLYGON((101 49,117 -61,-164 -21,12 40,101 49))",
 124                         1, 7, 0, -125258931656228.08);
 125 }
 126
 127
 128 int test_main(int, char* [])
 129 {
 130     test_geographic();
 131
 132     return 0;
 133 }