4

根据这个相关问题（Boost Polygon Serialization）。我正在尝试使用 Boost 序列化多边形。我现在遇到的问题是我正在尝试使用自定义 X、Y、点的多边形来编译一个示例，但是编译器在编译时抛出了这个错误：

error: 'class boost::geometry::model::ring<boost::geometry::model::d2::point_xy<double> >' has no member named 'serialize'

就像没有定义任何函数来序列化一个环一样。由于 Ring 从 std::vector 扩展，并且如相关问题所述，没有必要为其序列化定义方法。但是编译器抱怨。

在这里，我有一个关于定义多边形及其序列化的完整示例：

#include <fstream>

#include <boost/serialization/vector.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/version.hpp>
#include <boost/serialization/tracking.hpp>

#include <boost/geometry/geometry.hpp>
#include <boost/geometry/geometries/polygon.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/io/wkt/wkt.hpp>
#include <boost/geometry/multi/geometries/multi_polygon.hpp>
#include <boost/geometry/geometries/ring.hpp>

#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>

typedef boost::geometry::model::d2::point_xy< double > point;
typedef boost::geometry::model::ring< point > ring;
typedef boost::geometry::model::polygon< point > polygon;

namespace boost{
        namespace serialization{

                template<class Archive>
                inline void serialize(Archive & ar, point &point, const unsigned int file_version)
                {
                        std::cout << "Point: Serializing point" << std::endl;
                        ar & boost::serialization::make_nvp("x", point.x());
                        ar & boost::serialization::make_nvp("y", point.y());
                }

                template<class Archive>
                inline void serialize(Archive & ar, polygon &t, const unsigned int file_version)
                {
                        std::cout << "Polygon: Serializing outer ring" << std::endl;
                        ar & boost::serialization::make_nvp("outer", t.outer());

                        std::cout << "Polygon: Serializing inner rings" << std::endl;
                        ar & boost::serialization::make_nvp("inners", t.inners());
                }
        }
}

using namespace boost::geometry;
using namespace boost::archive;
using namespace std;

int main()
{
        polygon poly;
        append(poly, make<point>(0.0, 0.0));
        append(poly, make<point>(5.0, 5.0));
        append(poly, make<point>(5.0, 0.0));
        correct(poly);

        ofstream ofs("polygon.xml");
        xml_oarchive oa(ofs);
        oa << BOOST_SERIALIZATION_NVP(poly);
}

关于如何使它工作的任何想法？

编辑：关于多边形序列化的全功能代码

#include <fstream>
#include <vector>

#include <boost/serialization/vector.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/version.hpp>
#include <boost/serialization/tracking.hpp>
#include <boost/foreach.hpp>

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

#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>

typedef boost::geometry::model::d2::point_xy< double > point;
typedef boost::geometry::model::ring< point > ring;
typedef boost::geometry::model::polygon< point > polygon;

namespace boost{
        namespace serialization{

                template<class Archive>
                inline void serialize(Archive & ar, point &point, const unsigned int file_version)
                {
                        std::cout << "Point: Serializing point" << std::endl;
                        ar & const_cast<double &>(point.x());
                        ar & const_cast<double &>(point.y());
                }

                template<class Archive>
                inline void serialize(Archive & ar, ring &ring, const unsigned int file_version)
                {
                        std::cout << "Ring: Serializing ring" << std::endl;
                        ar & static_cast<std::vector<point>& >(ring);
                }

                template<class Archive>
                inline void serialize(Archive & ar, polygon &t, const unsigned int file_version)
                {
                        std::cout << "Polygon: Serializing outer ring" << std::endl;
                        ar & t.outer();

                        std::cout << "Polygon: Serializing inner rings" << std::endl;
                        ar & t.inners();
                }
        }
}

using namespace boost::geometry;
using namespace boost::archive;
using namespace std;

int main()
{
        polygon poly;
        append(poly, make<point>(0.0, 0.0));
        append(poly, make<point>(5.0, 5.0));
        append(poly, make<point>(5.0, 0.0));
        correct(poly);

        BOOST_FOREACH(point& p, poly.outer())
        {
                std::cout << "point " << p.x() << "," << p.y() << std::endl;
        }

        ofstream ofs("polygon.dat");
        binary_oarchive oa(ofs);
        oa << poly;
        ofs.close();

        polygon polyFromFile;
        ifstream ifs("polygon.dat");
        binary_iarchive ia(ifs);
        ia >> polyFromFile;

        BOOST_FOREACH(point& p, polyFromFile.outer())
        {
                std::cout << "point " << p.x() << "," << p.y() << std::endl;
        }
        ifs.close();
}
4

3 回答 3

6

即使为此存在序列化的部分专业化std:vector<T>并不意味着它适用于子类，因此您必须为以下内容添加序列化方法ring：

template<class Archive>
inline void serialize(Archive & ar, ring &t, const unsigned int file_version)
{
    // Impl
}

那么实施中的内容是什么？由于geometry不是为序列化而构建的，因此您无法访问对序列化有用的类型（例如，为容器ring继承选择正确的默认实现），因此您可以以某种方式强制执行此操作。例如，这似乎有效：

template<class Archive>
inline void serialize(Archive & ar, ring &t, const unsigned int file_version)
{
     std::cout << "Ring: Serializing a ring" << std::endl;
     serialize(ar, static_cast< std::vector<point>& >(t), file_version);
}

您还可以尝试编写一些基类序列化调用：

template<class Archive>
inline void serialize(Archive & ar, ring &t, const unsigned int file_version)
{
     std::cout << "Ring: Serializing a ring" << std::endl;
     ar & boost::serialization::make_nvp( "Base",
              boost::serialization::base_object<std::vector<point> >(t));
}

但同样，问题是您应该能够从内部访问该继承的类ring。事实上，它在ring, as的定义中base_type，但它是类私有的。如果它是公开的，您可以编写不那么糟糕的代码，将ring::base_type其用作序列化的参数（而不是std::vector<point>上面的裸代码）。

也许知道序列化库的内部，您可以“绑定”序列化机制，这样就不需要两次调用，专门针对ring类本身进行一些部分专业化，但我怀疑这是否是可移植的。

于 2014-01-29T18:59:39.987 回答
0

正如@Diego Sevilla 上面指出的那样，主要障碍是 base_type 在ring<...>. 这有点奇怪，因为继承实际上是公开的。

不过，可以通过使用 geometry::model::ring 的详细定义来稍微概括他的解决方案

namespace boost {
namespace serialization{
    template<class Archive,  //other template params are from model::ring
             typename Point,
             bool ClockWise , bool Closed ,
             template<typename, typename> class Container, //= std::vector,
             template<typename> class Allocator// = std::allocator
             >
    void serialize(Archive & ar,
                   geometry::model::ring<Point, ClockWise, 
                                        Closed, Container, Allocator> & rng,
                   const unsigned int version)
    {
        typedef Container<Point, Allocator<Point> > ring_base_type;
        ring_base_type & contour = rng;
        ar & BOOST_SERIALIZATION_NVP(contour);
    }
} //namespace serialization
} //namespace boost

它应该适用于几乎任何 boost::geometry::model::ring 的变体。

于 2014-01-31T22:57:36.917 回答
0

我将它用于 boost::geometry 到字符串序列化：

boost::geometry::wkt https://www.boost.org/doc/libs/1_65_0/libs/geometry/doc/html/geometry/reference/io/wkt/wkt.html

这用于反序列化：

boost::geometry::read_wkt https://www.boost.org/doc/libs/1_65_1/libs/geometry/doc/html/geometry/reference/io/wkt/read_wkt.html

完美运行。

于 2019-08-02T13:28:01.753 回答