ply io for py (#170)

Author: koide3

src/python/glk.cpp

@@ -9,6 +9,7 @@
 #include <glk/texture.hpp>
 #include <glk/thin_lines.hpp>
 #include <glk/pointcloud_buffer.hpp>
+#include <glk/io/ply_io.hpp>
 #include <glk/primitives/primitives.hpp>
 #include <glk/effects/screen_effect.hpp>
 #include <glk/effects/naive_screen_space_ambient_occlusion.hpp>
@@ -341,4 +342,94 @@ void define_glk(py::module_& m) {
   primitives_.def("wire_icosahedron", [] { return glk::Primitives::wire_icosahedron(); });
   primitives_.def("wire_bunny", [] { return glk::Primitives::wire_bunny(); });
   primitives_.def("wire_frustum", [] { return glk::Primitives::wire_frustum(); });
+
+  // IO
+  // glk::PLYData
+  py::class_<glk::PLYData, std::shared_ptr<glk::PLYData>>(glk_, "PLYData")  //
+    .def(py::init<>())
+    .def_property(
+      "vertices",
+      [](glk::PLYData& self) -> Eigen::Matrix<float, -1, -1, Eigen::RowMajor> {
+        return Eigen::Map<const Eigen::Matrix<float, -1, -1, Eigen::RowMajor>>(self.vertices[0].data(), self.vertices.size(), 3);
+      },
+      [](glk::PLYData& self, const Eigen::MatrixXf& vertices) {
+        if (vertices.cols() != 3 && vertices.cols() != 4) {
+          std::cerr << "vertices must be 3 or 4 columns (cols=" << vertices.cols() << ")" << std::endl;
+          return;
+        }
+
+        self.vertices.resize(vertices.rows());
+        for (int i = 0; i < vertices.rows(); i++) {
+          self.vertices[i] = vertices.row(i).head<3>();
+        }
+      })
+    .def_property(
+      "normals",
+      [](glk::PLYData& self) -> Eigen::Matrix<float, -1, -1, Eigen::RowMajor> {
+        return Eigen::Map<const Eigen::Matrix<float, -1, -1, Eigen::RowMajor>>(self.normals[0].data(), self.normals.size(), 3);
+      },
+      [](glk::PLYData& self, const Eigen::MatrixXf& normals) {
+        if (normals.cols() != 3 && normals.cols() != 4) {
+          std::cerr << "normals must be 3 or 4 columns (cols=" << normals.cols() << ")" << std::endl;
+          return;
+        }
+
+        self.normals.resize(normals.rows());
+        for (int i = 0; i < normals.rows(); i++) {
+          self.normals[i] = normals.row(i).head<3>();
+        }
+      })
+    .def_property(
+      "intensities",
+      [](glk::PLYData& self) -> Eigen::VectorXf { return Eigen::Map<const Eigen::VectorXf>(self.intensities.data(), self.intensities.size()); },
+      [](glk::PLYData& self, const Eigen::VectorXf& intensities) {
+        self.intensities.resize(intensities.size());
+        for (int i = 0; i < intensities.size(); i++) {
+          self.intensities[i] = intensities[i];
+        }
+      })
+    .def_property(
+      "colors",
+      [](glk::PLYData& self) -> Eigen::Matrix<float, -1, -1, Eigen::RowMajor> {
+        return Eigen::Map<const Eigen::Matrix<float, -1, -1, Eigen::RowMajor>>(self.colors[0].data(), self.colors.size(), 4);
+      },
+      [](glk::PLYData& self, const Eigen::MatrixXf& colors) {
+        if (colors.cols() != 4) {
+          std::cerr << "colors must be 3 or 4 columns (cols=" << colors.cols() << ")" << std::endl;
+          return;
+        }
+
+        self.colors.resize(colors.rows());
+        for (int i = 0; i < colors.rows(); i++) {
+          self.colors[i] = colors.row(i);
+        }
+      })
+    .def_property(
+      "indices",
+      [](glk::PLYData& self) -> Eigen::VectorXi { return Eigen::Map<const Eigen::VectorXi>(self.indices.data(), self.indices.size()); },
+      [](glk::PLYData& self, const Eigen::VectorXi& indices) {
+        self.indices.resize(indices.size());
+        for (int i = 0; i < indices.size(); i++) {
+          self.indices[i] = indices[i];
+        }
+      })
+    .def_property(
+      "comments",
+      [](glk::PLYData& self) -> std::vector<std::string> { return self.comments; },
+      [](glk::PLYData& self, const std::vector<std::string>& comments) { self.comments = comments; });
+
+  glk_.def("load_ply", &glk::load_ply, py::arg("filename"));
+  glk_.def("save_ply", &glk::save_ply, py::arg("filename"), py::arg("ply"), py::arg("binary") = true);
+  glk_.def("save_ply", [](const std::string& filename, const Eigen::Matrix<float, -1, -1, Eigen::RowMajor>& points) {
+    if (points.cols() != 3 && points.cols() != 4) {
+      std::cerr << "points must be 3 or 4 columns (cols=" << points.cols() << ")" << std::endl;
+      return false;
+    }
+
+    if (points.cols() == 3) {
+      return glk::save_ply_binary(filename, reinterpret_cast<const Eigen::Matrix<float, 3, 1>*>(points.data()), points.rows());
+    } else {
+      return glk::save_ply_binary(filename, reinterpret_cast<const Eigen::Matrix<float, 4, 1>*>(points.data()), points.rows());
+    }
+  });
 }