Boost :: Geometry: ¿cómo unir polígonos que se cruzan en un multi_polygon?

Así que quiero unir todos los polígonos interrelacionados en un multi_polygon. ¿Cómo hacer tal cosa?

Tenemos tal imagen (de un multi_polygon verde) que queremos optimizar (podemos ver líneas de puntos amarillos - resultado de la simplificación que aparentemente se realizó en cada poligon de multi_polygon no en multi_polygon en general):

enter image description here

Y aquí hay un código compilable para generar dicha imagen:

#include <iostream>
#include <fstream>
#include <boost/assign.hpp>

#include <boost/algorithm/string.hpp>
#include <boost/geometry/geometry.hpp>
#include <boost/geometry/geometries/geometries.hpp>
#include <boost/geometry/multi/geometries/multi_polygon.hpp>

#include <boost/geometry/extensions/io/svg/svg_mapper.hpp>

template <typename Geometry1, typename Geometry2>
void create_svg(std::string const& filename, Geometry1 const& a, Geometry2 const& b)
{
    typedef typename boost::geometry::point_type<Geometry1>::type point_type;
    std::ofstream svg(filename.c_str());

    boost::geometry::svg_mapper<point_type> mapper(svg, 400, 400);
    mapper.add(a);
    mapper.add(b);

    mapper.map(a, "fill-opacity:0.5;fill:rgb(153,204,0);stroke:rgb(153,204,0);stroke-width:2");
    mapper.map(b, "opacity:0.8;fill:none;stroke:rgb(255,128,0);stroke-width:4;stroke-dasharray:1,7;stroke-linecap:round");
}


boost::geometry::model::polygon<boost::geometry::model::d2::point_xy<double> > make_point(int x, int y)
{
    boost::geometry::model::polygon<boost::geometry::model::d2::point_xy<double> > return_item;
    boost::geometry::model::d2::point_xy<double> p1(x, y);
    boost::geometry::model::d2::point_xy<double> p2(x-1, y);
    boost::geometry::model::d2::point_xy<double> p3(x-1, y-1);
    boost::geometry::model::d2::point_xy<double> p4(x, y-1);

    boost::geometry::append(  return_item, p1);
    boost::geometry::append(  return_item, p2);
    boost::geometry::append(  return_item, p3);
    boost::geometry::append(  return_item, p4);

    return return_item;

}

int main()
{
    // create a container for joined points structure
    boost::geometry::model::multi_polygon< boost::geometry::model::polygon<boost::geometry::model::d2::point_xy<double> > > output, simpl;

    // join points one by one (because one day we would have many=))
    output.push_back(make_point(1,1));
    boost::geometry::correct(output);

    output.push_back(make_point(2,1));
    boost::geometry::correct(output);

    output.push_back(make_point(3,1));
    boost::geometry::correct(output);

    output.push_back(make_point(4,1));
    boost::geometry::correct(output);

    output.push_back(make_point(5,1));
    boost::geometry::correct(output);

    output.push_back(make_point(2,2));
    boost::geometry::correct(output);

    output.push_back(make_point(3,2));
    boost::geometry::correct(output);

    output.push_back(make_point(5,2));
    boost::geometry::correct(output);

    output.push_back(make_point(5,5));
    boost::geometry::correct(output);


    // simplify joined structure
    boost::geometry::simplify(output, simpl, 0.5);

    // create an svg image
    create_svg("make_envelope.svg",  output, simpl );
}

requiere al menos boost 1.47.0 y 3 archivos de boost / geometry / extensions / io / svg /

lo que necesito es simple: ¿cómo agrupar polígonos interrelacionados? En este caso, obtendremos 2 poligones en nuestro multy_poligon como se muestra aquí - rojo y verde:

enter image description here

Actualizar:

Entonces encontré esta información en disolver y creó un código de muestra que usa anillos para la creación de celdas:

#include <iostream>
#include <fstream>
#include <boost/assign.hpp>

//Boost
#include <boost/algorithm/string.hpp>
#include <boost/geometry/geometry.hpp>
#include <boost/geometry/geometries/geometries.hpp>
#include <boost/geometry/multi/geometries/multi_polygon.hpp>
#include <boost/geometry/geometries/adapted/boost_tuple.hpp>

BOOST_GEOMETRY_REGISTER_BOOST_TUPLE_CS(cs::cartesian)

#include <boost/foreach.hpp>

//Boost Geometry extensions (from trunk) 
#include <boost/geometry/extensions/io/svg/svg_mapper.hpp>

template <typename Geometry1, typename Geometry2>
void create_svg(std::string const& filename, Geometry1 const& a, Geometry2 const& b)
{
    typedef typename boost::geometry::point_type<Geometry1>::type point_type;
    std::ofstream svg(filename.c_str());

    boost::geometry::svg_mapper<point_type> mapper(svg, 400, 400);
    mapper.add(a);
    mapper.add(b);

    mapper.map(a, "fill-rule:nonzero;fill-opacity:0.5;fill:rgb(153,204,0);stroke:rgb(153,204,0);stroke-width:2;");
    mapper.map(b, "opacity:0.8;fill:none;stroke:rgb(255,128,0);stroke-width:4;stroke-dasharray:1,7;stroke-linecap:round");
}

void make_point(int x, int y, boost::geometry::model::ring<boost::geometry::model::d2::point_xy<double> > & ring)
{
    using namespace boost::assign;

    ring += 
        boost::geometry::model::d2::point_xy<double>(x-1, y-1),
        boost::geometry::model::d2::point_xy<double>(x, y-1),
        boost::geometry::model::d2::point_xy<double>(x, y),
        boost::geometry::model::d2::point_xy<double>(x-1, y),
        boost::geometry::model::d2::point_xy<double>(x-1, y-1);

}

int main()
{
    using namespace boost::assign;
    boost::geometry::model::ring<boost::geometry::model::d2::point_xy<double> > ring0, ring1,ring;

    boost::geometry::model::multi_polygon< boost::geometry::model::polygon<boost::geometry::model::d2::point_xy<double> > > outputw;

    make_point(1, 1, ring) ;
    make_point(2, 1, ring) ;
    make_point(3, 1, ring) ;
    make_point(4, 1, ring) ;
    make_point(5, 1, ring) ;
    make_point(2, 2, ring) ;
    make_point(3, 2, ring) ;
    make_point(5, 2, ring) ;

    boost::geometry::model::ring<boost::geometry::model::d2::point_xy<double> > output;
    boost::geometry::simplify(ring, output, 1);

    // create an svg image
    create_svg("make_envelope.svg",  ring, output );
}

Devuelve tal imagen de anillo:

enter image description here

Si pudiéramos usar disolver para convertirlo en polígono, eso realmente resolvería algunos de mis problemas. Pero parece que actualmente no podemos debido a este problema de errores del compilador descrito aquí

preguntado el 08 de noviembre de 11 a las 12:11

Creo que podría estar buscando Extracción de conectividad: boost.org/doc/libs/1_47_0/libs/polygon/doc/… -

2 Respuestas

¿Qué pasa con el uso de Qt. Si usa un QPolygonF, puede llamar a unite, que hace exactamente lo que necesita. Después del unísono, puede extraer los puntos y volver a colocarlos en su contenedor de impulso.

Si qt no es una opción, eche un vistazo a los algoritmos propuestos aquí. http://www.wykobi.com

respondido 18 nov., 11:03

Puede usar esta función desde la biblioteca boost:

void union_(Geometry1 const & geometry1, Geometry2 const & geometry2, Collection & output_collection)

Toma dos geometrías y las une si tienen intersecciones o las pone en una colección (vector, deque, etc.) si no.

Respondido 21 Feb 19, 19:02

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.