[Draft] support PointCloud pickle

cpp/pybind/geometry/pointcloud.cpp

@@ -45,6 +45,21 @@ void pybind_pointcloud_definitions(py::module &m) {
                  })
             .def(py::self + py::self)
             .def(py::self += py::self)
+            .def(py::pickle(
+                    [](const PointCloud &pcd) {
+                        return py::make_tuple(pcd.points_, pcd.normals_,
+                                              pcd.colors_, pcd.covariances_);
+                    },
+                    [](py::tuple t) {
+                        PointCloud pcd;
+                        pcd.points_ = t[0].cast<std::vector<Eigen::Vector3d>>();
+                        pcd.normals_ =
+                                t[1].cast<std::vector<Eigen::Vector3d>>();
+                        pcd.colors_ = t[2].cast<std::vector<Eigen::Vector3d>>();
+                        pcd.covariances_ =
+                                t[3].cast<std::vector<Eigen::Matrix3d>>();
+                        return pcd;
+                    }))
             .def("has_points", &PointCloud::HasPoints,
                  "Returns ``True`` if the point cloud contains points.")
             .def("has_normals", &PointCloud::HasNormals,

cpp/pybind/utility/eigen.cpp

@@ -166,6 +166,30 @@ py::class_<Vector, holder_type> pybind_eigen_vector_of_vector(
     vec.def("__deepcopy__", [](std::vector<EigenVector> &v, py::dict &memo) {
         return std::vector<EigenVector>(v);
     });
+    vec.def(py::pickle(
+            [](const std::vector<EigenVector> &v) {
+                const size_t n = v.size();
+                if (n == 0) {
+                    return py::make_tuple(py::bytes(""), 0);
+                }
+
+                const size_t rows = EigenVector::RowsAtCompileTime;
+                const char *raw = reinterpret_cast<const char *>(v[0].data());
+                return py::make_tuple(py::bytes(raw, n * rows * sizeof(Scalar)),
+                                      n);
+            },
+            [](py::tuple t) {
+                auto buffer = t[0].cast<std::string>();
+                auto n = t[1].cast<size_t>();
+                std::vector<EigenVector> p;
+                if (n == 0) {
+                    return p;
+                }
+
+                p.resize(n);
+                std::memcpy(p[0].data(), buffer.data(), buffer.size());
+                return p;
+            }));
 
     // py::detail must be after custom constructor
     using Class_ = py::class_<Vector, std::unique_ptr<Vector>>;
@@ -290,6 +314,31 @@ py::class_<Vector, holder_type> pybind_eigen_vector_of_matrix(
             [](std::vector<EigenMatrix, EigenAllocator> &v, py::dict &memo) {
                 return std::vector<EigenMatrix, EigenAllocator>(v);
             });
+    vec.def(py::pickle(
+            [](const std::vector<EigenMatrix, EigenAllocator> &v) {
+                const size_t n = v.size();
+                if (n == 0) {
+                    return py::make_tuple(py::bytes(""), 0);
+                }
+
+                const char *raw = reinterpret_cast<const char *>(v[0].data());
+                return py::make_tuple(
+                        py::bytes(raw, n * v[0].rows() * v[0].cols() *
+                                               sizeof(Scalar)),
+                        n);
+            },
+            [](py::tuple t) {
+                auto buffer = t[0].cast<std::string>();
+                auto n = t[1].cast<size_t>();
+                std::vector<EigenMatrix, EigenAllocator> p;
+                if (n == 0) {
+                    return p;
+                }
+
+                p.resize(n);
+                std::memcpy(p[0].data(), buffer.data(), buffer.size());
+                return p;
+            }));
 
     // py::detail must be after custom constructor
     using Class_ = py::class_<Vector, std::unique_ptr<Vector>>;