Shrink/Expand the outline of a polygon with holes

问题

I want to expand/shrink a polygon with holes using boost::polygon. So to clarify that a bit, I have a single data structure

boost::polygon::polygon_with_holes_data<int> inPoly

where inPoly contains data that describe a rectangular outline and a triangle which forms the hole within this rectangle (in picture below this is the left, black drawing).

Now I want to

a) expand the whole stuff so that the rectangle becomes bigger and the hole becomes smaller (resulting in the red polygon in image below) or

b) shrink it so that the rectangle becomes smaller and the hole bigger (resulting in the green image below).

The corners don't necessarily need to be straight, the also can be rounded or somehow "rough".

My question: how can this be done using boost::polygon?

Thanks!

回答1:

I answered this Expand polygons with boost::geometry?

And yes you can teach Boost Geometry to act on Boost Polygon types:

#include <boost/geometry/geometries/adapted/boost_polygon.hpp>

I came up with a test polygon like you described:

boost::polygon::polygon_with_holes_data<int> inPoly;
bg::read_wkt("POLYGON ((0 0,0 1000,1000 1000,1000 0,0 0),(100 100,900 100,500 700,100 100))", inPoly);

Now, apparently we can't just buffer on the adapted polygon, nor can we bg::assign or bg::convert directly. So, I came up with an ugly workaround of converting to WKT and back. And then you can do the buffer, and conver back similarly.

It's not very elegant, but it does work:

poly in;
bg::read_wkt(boost::lexical_cast<std::string>(bg::wkt(inPoly)), in);

Full Demo

Include SVG output:

Live On Coliru

#include <boost/polygon/polygon.hpp>
#include <boost/polygon/polygon_set_data.hpp>
#include <boost/polygon/polygon_with_holes_data.hpp>

#include <boost/geometry.hpp>
#include <boost/geometry/strategies/buffer.hpp>
#include <boost/geometry/algorithms/buffer.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/geometry/geometries/multi_polygon.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/geometries/adapted/boost_polygon.hpp>
#include <fstream>

namespace bp = boost::polygon;
namespace bg = boost::geometry;
using P = bp::polygon_with_holes_data<int>;
using PS = bp::polygon_set_data<int>;
using coordinate_type = bg::coordinate_type<P>::type;

int main() {
    P inPoly, grow, shrink;
    bg::read_wkt("POLYGON ((0 0,0 1000,1000 1000,1000 0,0 0),(100 100,900 100,500 700,100 100))", inPoly);

    {
        // define our boost geometry types
        namespace bs = bg::strategy::buffer;
        namespace bgm = bg::model;
        using pt = bgm::d2::point_xy<coordinate_type>;
        using poly = bgm::polygon<pt>;
        using mpoly = bgm::multi_polygon<poly>;

        // define our buffering strategies
        using dist = bs::distance_symmetric<coordinate_type>;
        bs::side_straight  side_strategy;
        const int points_per_circle = 12;
        bs::join_round   join_strategy(points_per_circle);
        bs::end_round    end_strategy(points_per_circle);
        bs::point_circle point_strategy(points_per_circle);

        poly in;
        bg::read_wkt(boost::lexical_cast<std::string>(bg::wkt(inPoly)), in);

        for (auto [offset, output_p] : { std::tuple(+15, &grow), std::tuple(-15, &shrink) }) {
            mpoly out;
            bg::buffer(in, out, dist(offset), side_strategy, join_strategy, end_strategy, point_strategy);

            assert(out.size() == 1);
            bg::read_wkt(boost::lexical_cast<std::string>(bg::wkt(out.front())), *output_p);
        }
    }

    {
        std::ofstream svg("output.svg");
        using pt = bg::model::d2::point_xy<coordinate_type>;
        boost::geometry::svg_mapper<pt> mapper(svg, 400, 400);
        mapper.add(inPoly);
        mapper.add(grow);
        mapper.add(shrink);

        mapper.map(inPoly, "fill-opacity:0.3;fill:rgb(153,204,0);stroke:rgb(153,204,0);stroke-width:2");
        mapper.map(grow, "fill-opacity:0.05;fill:rgb(255,0,0);stroke:rgb(255,0,0);stroke-width:2");
        mapper.map(shrink, "fill-opacity:0.05;fill:rgb(0,0,255);stroke:rgb(0,0,255);stroke-width:2");
    }
}

The output.svg written:

回答2:

More or less accidentally I found boost::polygon also provides a single function for that which is quite easy to use: boost::polygon::polygon_set_data offers a function resize() which is doing exactly what is described above. Using the additional, parameters corner_fill_arc and num_segments rounded corners can be created.

No idea why this function is located in boost::polygon::polygon_set_data and not in boost::polygon::polygon_with_holes_data which in my opinion would be the more logically place for such a function...

来源：https://stackoverflow.com/questions/62635255/shrink-expand-the-outline-of-a-polygon-with-holes

标签

c++

boost

polygon

boost-polygon