通过自动分配来增强几何联合

Question

#include <iostream> 
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/register/point.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>

using namespace boost::geometry;

class CustomPoint{
public:
    double X;
    double Y;
};

using cpPtr = boost::shared_ptr<CustomPoint>;

namespace boost { namespace geometry { namespace traits {
    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_TRAITS(cpPtr, 2, double, cs::cartesian)

    template<> struct access<cpPtr, 0> {
        static inline double get(cpPtr const& p) { return p->X; }
        static inline void set(cpPtr& p, double const& value) { p->X = value; }
    };
    template<> struct access<cpPtr, 1> {
        static inline double get(cpPtr const& p) { return p->Y; }
        static inline void set(cpPtr& p, double const& value) { p->Y = value; }
    };
}}}

int main()
{
  std::vector<cpPtr> one,Two;
  //init polys
  std::vector< std::vector<cpPtr> > output;
  boost::geometry::union_(one,two,output)

}

您好我尝试将boost :: shared_ptr作为多边形。问题是当我做联合裁剪时算法没有分配内存。有谁知道解决这个问题？

Answer 1

首先让我花点时间说我对这种“尴尬”的点型选择的动机感到困惑。

在我看来，这

• 如果你的积分很少，那么分享似乎并不重要
• 如果你这样做，那么看起来shared_ptr（2x指针开销和原子引用计数锁定）的开销会阻止扩展。

对于两个世界中最好的（一次可以在多个集合中的点），您是否考虑过直线指针，或者甚至是Boost Intrusive容器（它们不会对所包含的元素拥有所有权）？

抛开所有问题，这是一种方法：

---

您可以围绕shared_ptr做一个简单的包装，它允许您以这种方式使用它：

template<typename T>
    struct shared_instancing : boost::shared_ptr<T> {
        using boost::shared_ptr<T>::shared_ptr;

        shared_instancing(boost::shared_ptr<T> sp = boost::make_shared<T>()) 
            : boost::shared_ptr<T>(sp)
        { }
    };

如您所见，它将默认构造为一个新实例;看到它Live On Coliru

#include <iostream> 
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/geometries/polygon.hpp>
#include <boost/geometry/geometries/register/point.hpp>
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>

using namespace boost::geometry;

struct CustomPoint{
    double X;
    double Y;
};

namespace {
    template<typename T>
        struct shared_instancing : boost::shared_ptr<T> {
            using boost::shared_ptr<T>::shared_ptr;

            shared_instancing(boost::shared_ptr<T> sp = boost::make_shared<T>()) 
                : boost::shared_ptr<T>(sp)
            { }
        };
}

using cpPtr = shared_instancing<CustomPoint>; // boost::shared_ptr<CustomPoint>;

namespace boost { namespace geometry { namespace traits {
    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_TRAITS(cpPtr, 2, double, cs::cartesian)

    template<> struct access<cpPtr, 0> {
        static inline double get(cpPtr const& p) { return p->X; }
        static inline void set(cpPtr& p, double const& value) { p->X = value; }
    };
    template<> struct access<cpPtr, 1> {
        static inline double get(cpPtr const& p) { return p->Y; }
        static inline void set(cpPtr& p, double const& value) { p->Y = value; }
    };
}}}

int main()
{
    typedef boost::geometry::model::polygon<cpPtr > polygon;

    polygon green, blue;

    boost::geometry::read_wkt(
        "POLYGON((2 1.3,2.4 1.7,2.8 1.8,3.4 1.2,3.7 1.6,3.4 2,4.1 3,5.3 2.6,5.4 1.2,4.9 0.8,2.9 0.7,2 1.3)"
            "(4.0 2.0, 4.2 1.4, 4.8 1.9, 4.4 2.2, 4.0 2.0))", green);

    boost::geometry::read_wkt(
        "POLYGON((4.0 -0.5 , 3.5 1.0 , 2.0 1.5 , 3.5 2.0 , 4.0 3.5 , 4.5 2.0 , 6.0 1.5 , 4.5 1.0 , 4.0 -0.5))", blue);

    std::vector<polygon> output;
    boost::geometry::union_(green, blue, output);

    int i = 0;
    std::cout << "green || blue:" << std::endl;
    for(polygon const& p: output)
    {
        std::cout << i++ << ": " << boost::geometry::area(p) << std::endl;
    }
}