Boost::geometry::intersection 给出错误的输出。 版本 BOOST_1_57_0

Question

This might be a question asked multiple times. But I cross checked similar questions, to make sure mine is not repeated.

I have a source code that uses boost::geometry::intersection in the code, to get the resultant of intersection between two polygons. I have boost::geometry::correct tested for the polygons used. The sequence of points in the polygon is clockwise. Everything seems right, but I get incorrect output from the boost::geometry::intersection call.

Please help me identify what the issue here is.

This is class Point definition:

class Point {
public:
    double _x, _y;
    Point();
    Point(double, double);
    Point(const Point& orig);
    void SetX(double x);
    void SetY(double y);
    double GetX() const;
    double GetY() const;
};

code where boost libraries are used

#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/geometries/register/ring.hpp>
#include <boost/geometry/geometries/register/point.hpp>

BOOST_GEOMETRY_REGISTER_POINT_2D(Point, double, cs::cartesian, _x, _y)
BOOST_GEOMETRY_REGISTER_RING(std::vector<Point>)

namespace bg = boost::geometry;
namespace bd2 = boost::geometry::model::d2;

std::vector<Point> ORCAModel :: BoostPolyIntersect( std::vector<Point>& poly_1,
                                                    std::vector<Point>& poly_2,
                                                    bool &intersect_FLAG) const{

    std::vector<Point> poly_result;

    bg::correct(poly_1);
    bg::correct(poly_2);

    bg::intersection(poly_1, poly_2, poly_result);
    intersect_FLAG = (int(poly_result.size()) > 2)
    return poly_result;

    }

I used basic iostream to check the output. (Note : The input values are taken from one of the run sequences of the program, but not fed in as a user input)

--------------poly_1------------
( 0.075 : 27.2 )  ----  ( 27 : 27.2 )  ----  ( 27 : -22.8 )  ----  ( 0.075 : -22.8 )  ----  ( 0.075 : 27.2 )  ----  
--------------poly_2------------
( -23 : -22.8 )  ----  ( -23 : 3.925 )  ----  ( 27 : 3.925 )  ----  ( 27 : -22.8 )  ----  ( -23 : -22.8 )  ----  
result in bstpolyint size : 3
-----------------RESULT  POLY ------------------------
( 27 : 3.925 )  ----  ( 27 : -22.8 )  ----  ( 0.0750023 : 3.925 )  ----  

The output should have 4 points and is clearly missing a point (0.07500 : - 22.8) .

(Note : The input points are rounded off during the display check. Not manually though. When the displayed points were used in the test case, the results were correct. But it is clearly because of the round off, the points used in the original program for calculation and in the test case are perturbed.)

Please help to identify the issue. Thanks in advance.

EDIT : This is my test case. The commented lines polygon_1 & polygon_2 are rounded off values. Using those values gives 4 corners of the new polygon. The magnified values in use result in only 3 corners as got in the release mode.

#define BOOST_TEST_MODULE convexHull
#define BOOST_TEST_DYN_LINK
#include <boost/test/unit_test.hpp>

#include "../../geometry/Point.h"

#include <vector> 
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/geometries/register/ring.hpp>
#include <boost/geometry/geometries/register/point.hpp>
#include <string>

BOOST_GEOMETRY_REGISTER_POINT_2D(Point, double, cs::cartesian, _x, _y)
BOOST_GEOMETRY_REGISTER_RING(std::vector<Point>)

namespace bg = boost::geometry;
namespace bd2 = boost::geometry::model::d2;

BOOST_AUTO_TEST_SUITE(convexHull)

BOOST_AUTO_TEST_CASE(poly_Intersect_Test) {

//   std::vector<Point> polygon_1 = {Point(0.075, 27.2), Point( 27,  27.2), Point( 27, -22.8 ), Point( 0.075, -22.8 ), Point( 0.075,  27.2 )};
//   std::vector<Point> polygon_2 = {Point( -23, -22.8 ), Point( -23, 3.925 ), Point( 27, 3.925 ), Point( 27, -22.8 ), Point ( -23, -22.8 )};


  std::vector<Point> polygon_1 = {Point(749, 271999), Point(270000, 272000), Point(270000, -228000), Point(750, -227999), Point(749, 271999)};
  std::vector<Point> polygon_2 = {Point(-230000, -228000), Point (-230000, 39250) , Point(270000, 39250), Point (270000, -228000), Point (-230000, -228000)};
  std::vector<Point> polygon_result;

  bg::intersection(polygon_1, polygon_2, polygon_result);
  std::string points = "";
  for (auto it : polygon_result)
    points = points + "---" + it.toString();
  BOOST_CHECK_MESSAGE(false, points);
}

BOOST_AUTO_TEST_SUITE_END()

Answer 1

You're not intersecting polygons, you're passing rings . Now, the problem is that you don't pass the right concept as an output collection.

Quite simply, two arbitrary polygons (evens rings) might have multiple disjunct intersection polygons. You need to accomodate multiple intersections in the output type. @cv_and_he's further simplified and extended:

Live On Coliru

#include <vector> 
#include <boost/geometry.hpp>
#include <boost/geometry/io/io.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/geometries/register/ring.hpp>
#include <boost/geometry/geometries/register/point.hpp>
#include <string>

class Point {
public:
    double _x, _y;
    Point():_x(),_y(){}
    Point(double x, double y):_x(x),_y(y){}
};

BOOST_GEOMETRY_REGISTER_POINT_2D(Point, double, cs::cartesian, _x, _y)
BOOST_GEOMETRY_REGISTER_RING(std::vector<Point>)

namespace bg = boost::geometry;

template <typename G>
void test(G const& g1, G const& g2) {
    std::cout << "----\nIntersecting\n\t" << bg::wkt(g1) << "\n\t" << bg::wkt(g2) << "\nresult: ";

    std::vector<G> polygon_results;
    bg::intersection<G, G>(g1, g2, polygon_results);

    for (auto polygon : polygon_results)
        std::cout << bg::wkt(polygon) << "\n";
}

int main() {
    using Ring = std::vector<Point>;

    test<Ring>(
            {{749,  271999},  {270000, 272000}, {270000, -228000},    {750, -227999},     {749,  271999}},
            {{-230000, -228000}, {-230000,  39250}, {270000,   39250}, {270000, -228000}, {-230000, -228000}});
    test<Ring>(
            {{0.075,   27.2},  { 27,   27.2}, { 27, -22.8 }, { 0.075, -22.8 }, { 0.075,  27.2 }},
            {{ -23, -22.8 }, { -23, 3.925 }, { 27, 3.925 },    { 27, -22.8 },   { -23, -22.8 }});
}

Output:

----
Intersecting
    POLYGON((749 271999,270000 272000,270000 -228000,750 -227999,749 271999))
    POLYGON((-230000 -228000,-230000 39250,270000 39250,270000 -228000,-230000 -228000))
result: POLYGON((270000 39250,270000 -228000,750 -227999,749.465 39250,270000 39250))
----
Intersecting
    POLYGON((0.075 27.2,27 27.2,27 -22.8,0.075 -22.8,0.075 27.2))
    POLYGON((-23 -22.8,-23 3.925,27 3.925,27 -22.8,-23 -22.8))
result: POLYGON((27 3.925,27 -22.8,0.075 -22.8,0.075 3.925,27 3.925))