point_cloud_generator.cpp

Go to the documentation of this file.

//
// Created by Matěj Boxan on 2024-05-02.
//
 
#include "point_cloud_generator.h"
 
#include "pointmatcher/PointMatcher.h"
 
namespace python
{
    namespace pointmatcher
    {
 
        void applyTransformation(
                const StaticCoordVector& translation, const Eigen::Matrix<ScalarType, 4, 1>& rotation,
                DataPoints& pointCloud)
        {
            PM::Quaternion quaternion(rotation(0), rotation(1), rotation(2), rotation(3));
            Generator::applyTransformation(translation, quaternion, pointCloud);
        }
 
        DataPoints generateUniformlySampledBoxWrapper(
                const ScalarType length, const ScalarType width, const ScalarType height, const DataPoints::Index numberOfPoints,
                const StaticCoordVector& translation, const Eigen::Matrix<ScalarType, 4, 1>& rotation)
        {
            PM::Quaternion quaternion(rotation(0), rotation(1), rotation(2), rotation(3));
            return Generator::generateUniformlySampledBox(length, width, height, numberOfPoints, translation, quaternion);
        }
 
        DataPoints generateUniformlySampledPlane(
                const StaticCoordVector& dimensions, const DataPoints::Index numberOfPoints,
                const StaticCoordVector& translation, const Eigen::Matrix<ScalarType, 4, 1>& rotation)
        {
            PM::Quaternion quaternion(rotation(0), rotation(1), rotation(2), rotation(3));
            return Generator::generateUniformlySampledPlane(dimensions, numberOfPoints, translation, quaternion);
        }
 
        DataPoints generateUniformlySampledCylinder(
                const ScalarType radius, const ScalarType height, const DataPoints::Index numberOfPoints,
                const StaticCoordVector& translation, const Eigen::Matrix<ScalarType, 4, 1>& rotation)
        {
            PM::Quaternion quaternion(rotation(0), rotation(1), rotation(2), rotation(3));
            return Generator::generateUniformlySampledCylinder(radius, height, numberOfPoints, translation, quaternion);
        }
 
        DataPoints generateUniformlySampledCircle(
                const ScalarType radius, const DataPoints::Index numberOfPoints,
                const StaticCoordVector& translation, const Eigen::Matrix<ScalarType, 4, 1>& rotation)
        {
            PM::Quaternion quaternion(rotation(0), rotation(1), rotation(2), rotation(3));
            return Generator::generateUniformlySampledCircle(radius, numberOfPoints, translation, quaternion);
        }
 
        DataPoints generateUniformlySampledSphere(
                const ScalarType radius, const DataPoints::Index numberOfPoints,
                const StaticCoordVector& translation, const Eigen::Matrix<ScalarType, 4, 1>& rotation)
        {
            PM::Quaternion quaternion(rotation(0), rotation(1), rotation(2), rotation(3));
            return Generator::generateUniformlySampledSphere(radius, numberOfPoints, translation, quaternion);
        }
 
        void pybindPointCloudGenerator(py::module& p_module)
        {
            py::class_<Generator>(p_module, "PointCloudGenerator", "Class containing methods to generate point clouds in the shape of geometric primitives.")
                    .def_static("buildUpTransformation",
                                &Generator::buildUpTransformation,
                                py::arg("translation"),
                                py::arg("rotation"))
                    .def_static("addEmpty3dPointFields", &Generator::addEmpty3dPointFields, py::arg("numberOfPoints"), py::arg("pointCloud"))
                    .def_static("applyTransformation", &applyTransformation, py::arg("translation"), py::arg("rotation"), py::arg("pointCloud"))
                    .def_static("computeNormalOfAxisAlignedPlane", &Generator::computeNormalOfAxisAlignedPlane, py::arg("axisAlignedPlaneDimensions"))
                    .def_static("generateUniformlySampledSphere", &generateUniformlySampledSphere, py::arg("radius"), py::arg("numberOfPoints"), py::arg("translation"),
                                py::arg("rotation"))
                    .def_static("generateUniformlySampledCircle", &generateUniformlySampledCircle, py::arg("radius"), py::arg("numberOfPoints"), py::arg("translation"),
                                py::arg("rotation"))
                    .def_static("generateUniformlySampledCylinder", &generateUniformlySampledCylinder, py::arg("radius"), py::arg("height"), py::arg("numberOfPoints"),
                                py::arg("translation"), py::arg("rotation"))
                    .def_static("generateUniformlySampledPlane", &generateUniformlySampledPlane, py::arg("dimensions"), py::arg("numberOfPoints"),
                                py::arg("translation"), py::arg("rotation"))
                    .def_static("generateUniformlySampledBox", &generateUniformlySampledBoxWrapper, py::arg("length"), py::arg("width"), py::arg("height"),
                                py::arg("numberOfPoints"), py::arg("translation"), py::arg("rotation"));
        }
    }
}