PointCloud.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        Open3D: www.open3d.org                            -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2026 www.open3d.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
#include <Eigen/Core>
#include <memory>
#include <optional>
#include <tuple>
#include <vector>
 
#include "open3d/geometry/Geometry3D.h"
#include "open3d/geometry/KDTreeSearchParam.h"
 
namespace open3d {
 
namespace camera {
class PinholeCameraIntrinsic;
}
 
namespace geometry {
 
class Image;
class RGBDImage;
class TriangleMesh;
class VoxelGrid;
 
class PointCloud : public Geometry3D {
public:
    PointCloud() : Geometry3D(Geometry::GeometryType::PointCloud) {}
    PointCloud(const std::vector<Eigen::Vector3d>& points)
        : Geometry3D(Geometry::GeometryType::PointCloud), points_(points) {}
    ~PointCloud() override {}
 
public:
    PointCloud& Clear() override;
    bool IsEmpty() const override;
    Eigen::Vector3d GetMinBound() const override;
    Eigen::Vector3d GetMaxBound() const override;
    Eigen::Vector3d GetCenter() const override;
    AxisAlignedBoundingBox GetAxisAlignedBoundingBox() const override;
    OrientedBoundingBox GetOrientedBoundingBox(
            bool robust = false) const override;
    OrientedBoundingBox GetMinimalOrientedBoundingBox(
            bool robust = false) const override;
    OrientedBoundingEllipsoid GetOrientedBoundingEllipsoid(
            bool robust = false) const;
    PointCloud& Transform(const Eigen::Matrix4d& transformation) override;
    PointCloud& Translate(const Eigen::Vector3d& translation,
                          bool relative = true) override;
    PointCloud& Scale(const double scale,
                      const Eigen::Vector3d& center) override;
    PointCloud& Rotate(const Eigen::Matrix3d& R,
                       const Eigen::Vector3d& center) override;
 
    PointCloud& operator+=(const PointCloud& cloud);
    PointCloud operator+(const PointCloud& cloud) const;
 
    bool HasPoints() const { return points_.size() > 0; }
 
    bool HasNormals() const {
        return points_.size() > 0 && normals_.size() == points_.size();
    }
 
    bool HasColors() const {
        return points_.size() > 0 && colors_.size() == points_.size();
    }
 
    bool HasCovariances() const {
        return !points_.empty() && covariances_.size() == points_.size();
    }
 
    PointCloud& NormalizeNormals() {
        for (size_t i = 0; i < normals_.size(); i++) {
            normals_[i].normalize();
        }
        return *this;
    }
 
    PointCloud& PaintUniformColor(const Eigen::Vector3d& color) {
        ResizeAndPaintUniformColor(colors_, points_.size(), color);
        return *this;
    }
 
    PointCloud& RemoveNonFinitePoints(bool remove_nan = true,
                                      bool remove_infinite = true);
 
    PointCloud& RemoveDuplicatedPoints();
 
    std::shared_ptr<PointCloud> SelectByIndex(
            const std::vector<size_t>& indices, bool invert = false) const;
 
    std::shared_ptr<PointCloud> VoxelDownSample(double voxel_size) const;
 
    std::tuple<std::shared_ptr<PointCloud>,
               Eigen::MatrixXi,
               std::vector<std::vector<int>>>
    VoxelDownSampleAndTrace(double voxel_size,
                            const Eigen::Vector3d& min_bound,
                            const Eigen::Vector3d& max_bound,
                            bool approximate_class = false) const;
 
    std::shared_ptr<PointCloud> UniformDownSample(size_t every_k_points) const;
 
    std::shared_ptr<PointCloud> RandomDownSample(double sampling_ratio) const;
 
    std::shared_ptr<PointCloud> FarthestPointDownSample(
            const size_t num_samples, const size_t start_index = 0) const;
 
    std::shared_ptr<PointCloud> Crop(const AxisAlignedBoundingBox& bbox,
                                     bool invert = false) const;
 
    std::shared_ptr<PointCloud> Crop(const OrientedBoundingBox& bbox,
                                     bool invert = false) const;
 
    PointCloud SmoothMLS(const KDTreeSearchParam& search_param =
                                 KDTreeSearchParamHybrid(0.05, 30)) const;
 
    PointCloud SmoothLaplacian(size_t iterations,
                               double lambda,
                               int knn = 20,
                               bool use_fixed_neighborhoods = false) const;
 
    PointCloud SmoothTaubin(size_t iterations = 10,
                            double lambda = 0.5,
                            double mu = -0.53,
                            int knn = 20,
                            bool use_fixed_neighborhoods = false) const;
 
    PointCloud SmoothBilateral(const KDTreeSearchParam& search_param =
                                       KDTreeSearchParamHybrid(0.05, 30),
                               double sigma_s = 0.05,
                               double sigma_r = 0.05) const;
 
    std::tuple<std::shared_ptr<PointCloud>, std::vector<size_t>>
    RemoveRadiusOutliers(size_t nb_points,
                         double search_radius,
                         bool print_progress = false) const;
 
    std::tuple<std::shared_ptr<PointCloud>, std::vector<size_t>>
    RemoveStatisticalOutliers(size_t nb_neighbors,
                              double std_ratio,
                              bool print_progress = false) const;
 
    void EstimateNormals(
            const KDTreeSearchParam& search_param = KDTreeSearchParamKNN(),
            bool fast_normal_computation = true);
 
    void OrientNormalsToAlignWithDirection(
            const Eigen::Vector3d& orientation_reference =
                    Eigen::Vector3d(0.0, 0.0, 1.0));
 
    void OrientNormalsTowardsCameraLocation(
            const Eigen::Vector3d& camera_location = Eigen::Vector3d::Zero());
 
    void OrientNormalsConsistentTangentPlane(size_t k,
                                             const double lambda = 0.0,
                                             const double cos_alpha_tol = 1.0);
 
    std::vector<double> ComputePointCloudDistance(const PointCloud& target);
 
    static std::vector<Eigen::Matrix3d> EstimatePerPointCovariances(
            const PointCloud& input,
            const KDTreeSearchParam& search_param = KDTreeSearchParamKNN());
 
    void EstimateCovariances(
            const KDTreeSearchParam& search_param = KDTreeSearchParamKNN());
 
    std::tuple<Eigen::Vector3d, Eigen::Matrix3d> ComputeMeanAndCovariance()
            const;
 
    std::vector<double> ComputeMahalanobisDistance() const;
 
    std::vector<double> ComputeNearestNeighborDistance() const;
 
    std::tuple<std::shared_ptr<TriangleMesh>, std::vector<size_t>>
    ComputeConvexHull(bool joggle_inputs = false) const;
 
    std::tuple<std::shared_ptr<TriangleMesh>, std::vector<size_t>>
    HiddenPointRemoval(const Eigen::Vector3d& camera_location,
                       const double radius) const;
 
    std::vector<int> ClusterDBSCAN(double eps,
                                   size_t min_points,
                                   bool print_progress = false) const;
 
    std::tuple<Eigen::Vector4d, std::vector<size_t>> SegmentPlane(
            const double distance_threshold = 0.01,
            const int ransac_n = 3,
            const int num_iterations = 100,
            const double probability = 0.99999999) const;
 
    std::vector<std::shared_ptr<OrientedBoundingBox>> DetectPlanarPatches(
            double normal_variance_threshold_deg = 60,
            double coplanarity_deg = 75,
            double outlier_ratio = 0.75,
            double min_plane_edge_length = 0.0,
            size_t min_num_points = 0,
            const geometry::KDTreeSearchParam& search_param =
                    geometry::KDTreeSearchParamKNN()) const;
 
    static std::shared_ptr<PointCloud> CreateFromDepthImage(
            const Image& depth,
            const camera::PinholeCameraIntrinsic& intrinsic,
            const Eigen::Matrix4d& extrinsic = Eigen::Matrix4d::Identity(),
            double depth_scale = 1000.0,
            double depth_trunc = 1000.0,
            int stride = 1,
            bool project_valid_depth_only = true);
 
    static std::shared_ptr<PointCloud> CreateFromRGBDImage(
            const RGBDImage& image,
            const camera::PinholeCameraIntrinsic& intrinsic,
            const Eigen::Matrix4d& extrinsic = Eigen::Matrix4d::Identity(),
            bool project_valid_depth_only = true);
 
    static std::shared_ptr<PointCloud> CreateFromVoxelGrid(
            const VoxelGrid& voxel_grid);
 
public:
    std::vector<Eigen::Vector3d> points_;
    std::vector<Eigen::Vector3d> normals_;
    std::vector<Eigen::Vector3d> colors_;
    std::vector<Eigen::Matrix3d> covariances_;
};
 
}  // namespace geometry
}  // namespace open3d