Question

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

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

就像没有定义任何序列化环的函数一样。由于环从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();
}

Answer 1

即使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的定义中，如base_type，但它对于类来说是私有的。如果它是公开的，您可以使用ring::base_type作为序列化的参数（而不是上面的std::vector<point>）编写不那么糟糕的代码。

也许知道序列化库的内部，你可以“绑定”序列化机制，以便两个调用不是必需的，专门针对ring类本身的一些部分特化，但我怀疑这是可移植的。 / p>

Answer 2

正如@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的变种。

Answer 3

我将其用于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

工作完美。

提升多边形序列化：环

3 个答案: