PointCloud.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        Open3D: www.open3d.org                            -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2023 www.open3d.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
#include <string>
#include <unordered_map>
#include <unordered_set>
 
#include "open3d/core/Tensor.h"
#include "open3d/core/TensorCheck.h"
#include "open3d/core/hashmap/HashMap.h"
#include "open3d/geometry/PointCloud.h"
#include "open3d/t/geometry/BoundingVolume.h"
#include "open3d/t/geometry/DrawableGeometry.h"
#include "open3d/t/geometry/Geometry.h"
#include "open3d/t/geometry/Image.h"
#include "open3d/t/geometry/RGBDImage.h"
#include "open3d/t/geometry/TensorMap.h"
#include "open3d/t/geometry/TriangleMesh.h"
#include "open3d/utility/Logging.h"
 
namespace open3d {
namespace t {
namespace geometry {
 
class LineSet;
 
class PointCloud : public Geometry, public DrawableGeometry {
public:
    PointCloud(const core::Device &device = core::Device("CPU:0"));
 
    PointCloud(const core::Tensor &points);
 
    PointCloud(const std::unordered_map<std::string, core::Tensor>
                       &map_keys_to_tensors);
 
    virtual ~PointCloud() override {}
 
    std::string ToString() const;
 
    const TensorMap &GetPointAttr() const { return point_attr_; }
 
    TensorMap &GetPointAttr() { return point_attr_; }
 
    core::Tensor &GetPointAttr(const std::string &key) {
        return point_attr_.at(key);
    }
 
    core::Tensor &GetPointPositions() { return GetPointAttr("positions"); }
 
    core::Tensor &GetPointColors() { return GetPointAttr("colors"); }
 
    core::Tensor &GetPointNormals() { return GetPointAttr("normals"); }
 
    const core::Tensor &GetPointAttr(const std::string &key) const {
        return point_attr_.at(key);
    }
 
    const core::Tensor &GetPointPositions() const {
        return GetPointAttr("positions");
    }
 
    const core::Tensor &GetPointColors() const {
        return GetPointAttr("colors");
    }
 
    const core::Tensor &GetPointNormals() const {
        return GetPointAttr("normals");
    }
 
    void SetPointAttr(const std::string &key, const core::Tensor &value) {
        if (value.GetDevice() != device_) {
            utility::LogError("Attribute device {} != Pointcloud's device {}.",
                              value.GetDevice().ToString(), device_.ToString());
        }
        point_attr_[key] = value;
    }
 
    void SetPointPositions(const core::Tensor &value) {
        core::AssertTensorShape(value, {utility::nullopt, 3});
        SetPointAttr("positions", value);
    }
 
    void SetPointColors(const core::Tensor &value) {
        core::AssertTensorShape(value, {utility::nullopt, 3});
        SetPointAttr("colors", value);
    }
 
    void SetPointNormals(const core::Tensor &value) {
        core::AssertTensorShape(value, {utility::nullopt, 3});
        SetPointAttr("normals", value);
    }
 
    bool HasPointAttr(const std::string &key) const {
        return point_attr_.Contains(key) && GetPointAttr(key).GetLength() > 0 &&
               GetPointAttr(key).GetLength() == GetPointPositions().GetLength();
    }
 
    void RemovePointAttr(const std::string &key) { point_attr_.Erase(key); }
 
    bool HasPointPositions() const { return HasPointAttr("positions"); }
 
    bool HasPointColors() const { return HasPointAttr("colors"); }
 
    bool HasPointNormals() const { return HasPointAttr("normals"); }
 
public:
    PointCloud To(const core::Device &device, bool copy = false) const;
 
    PointCloud Clone() const;
 
    PointCloud &Clear() override {
        point_attr_.clear();
        return *this;
    }
 
    bool IsEmpty() const override { return !HasPointPositions(); }
 
    core::Tensor GetMinBound() const;
 
    core::Tensor GetMaxBound() const;
 
    core::Tensor GetCenter() const;
 
    PointCloud Append(const PointCloud &other) const;
 
    PointCloud operator+(const PointCloud &other) const {
        return Append(other);
    }
 
    PointCloud &Transform(const core::Tensor &transformation);
 
    PointCloud &Translate(const core::Tensor &translation,
                          bool relative = true);
 
    PointCloud &Scale(double scale, const core::Tensor &center);
 
    PointCloud &Rotate(const core::Tensor &R, const core::Tensor &center);
 
    PointCloud &PaintUniformColor(const core::Tensor &color);
 
    PointCloud SelectByMask(const core::Tensor &boolean_mask,
                            bool invert = false) const;
 
    PointCloud SelectByIndex(const core::Tensor &indices,
                             bool invert = false,
                             bool remove_duplicates = false) const;
 
    PointCloud VoxelDownSample(double voxel_size,
                               const core::HashBackendType &backend =
                                       core::HashBackendType::Default) const;
 
    PointCloud UniformDownSample(size_t every_k_points) const;
 
    PointCloud RandomDownSample(double sampling_ratio) const;
 
    PointCloud FarthestPointDownSample(size_t num_samples) const;
 
    std::tuple<PointCloud, core::Tensor> RemoveRadiusOutliers(
            size_t nb_points, double search_radius) const;
 
    std::tuple<PointCloud, core::Tensor> RemoveStatisticalOutliers(
            size_t nb_neighbors, double std_ratio) const;
 
    std::tuple<PointCloud, core::Tensor> RemoveDuplicatedPoints() const;
 
    std::tuple<PointCloud, core::Tensor> RemoveNonFinitePoints(
            bool remove_nan = true, bool remove_infinite = true) const;
 
    core::Device GetDevice() const override { return device_; }
 
    std::tuple<TriangleMesh, core::Tensor> HiddenPointRemoval(
            const core::Tensor &camera_location, double radius) const;
 
    core::Tensor ClusterDBSCAN(double eps,
                               size_t min_points,
                               bool print_progress = false) const;
 
    std::tuple<core::Tensor, core::Tensor> SegmentPlane(
            const double distance_threshold = 0.01,
            const int ransac_n = 3,
            const int num_iterations = 100,
            const double probability = 0.99999999) const;
 
    TriangleMesh ComputeConvexHull(bool joggle_inputs = false) const;
 
    std::tuple<PointCloud, core::Tensor> ComputeBoundaryPoints(
            double radius,
            int max_nn = 30,
            double angle_threshold = 90.0) const;
 
public:
    PointCloud &NormalizeNormals();
 
    void EstimateNormals(
            const utility::optional<int> max_nn = 30,
            const utility::optional<double> radius = utility::nullopt);
 
    void OrientNormalsToAlignWithDirection(
            const core::Tensor &orientation_reference =
                    core::Tensor::Init<float>({0, 0, 1},
                                              core::Device("CPU:0")));
 
    void OrientNormalsTowardsCameraLocation(
            const core::Tensor &camera_location = core::Tensor::Zeros(
                    {3}, core::Float32, core::Device("CPU:0")));
 
    void OrientNormalsConsistentTangentPlane(size_t k);
 
    void EstimateColorGradients(
            const utility::optional<int> max_nn = 30,
            const utility::optional<double> radius = utility::nullopt);
 
public:
    static PointCloud CreateFromDepthImage(
            const Image &depth,
            const core::Tensor &intrinsics,
            const core::Tensor &extrinsics =
                    core::Tensor::Eye(4, core::Float32, core::Device("CPU:0")),
            float depth_scale = 1000.0f,
            float depth_max = 3.0f,
            int stride = 1,
            bool with_normals = false);
 
    static PointCloud CreateFromRGBDImage(
            const RGBDImage &rgbd_image,
            const core::Tensor &intrinsics,
            const core::Tensor &extrinsics =
                    core::Tensor::Eye(4, core::Float32, core::Device("CPU:0")),
            float depth_scale = 1000.0f,
            float depth_max = 3.0f,
            int stride = 1,
            bool with_normals = false);
 
    static PointCloud FromLegacy(
            const open3d::geometry::PointCloud &pcd_legacy,
            core::Dtype dtype = core::Float32,
            const core::Device &device = core::Device("CPU:0"));
 
    open3d::geometry::PointCloud ToLegacy() const;
 
    geometry::Image ProjectToDepthImage(
            int width,
            int height,
            const core::Tensor &intrinsics,
            const core::Tensor &extrinsics =
                    core::Tensor::Eye(4, core::Float32, core::Device("CPU:0")),
            float depth_scale = 1000.0f,
            float depth_max = 3.0f);
 
    geometry::RGBDImage ProjectToRGBDImage(
            int width,
            int height,
            const core::Tensor &intrinsics,
            const core::Tensor &extrinsics =
                    core::Tensor::Eye(4, core::Float32, core::Device("CPU:0")),
            float depth_scale = 1000.0f,
            float depth_max = 3.0f);
 
    AxisAlignedBoundingBox GetAxisAlignedBoundingBox() const;
 
    OrientedBoundingBox GetOrientedBoundingBox() const;
 
    PointCloud Crop(const AxisAlignedBoundingBox &aabb,
                    bool invert = false) const;
 
    PointCloud Crop(const OrientedBoundingBox &obb, bool invert = false) const;
 
    LineSet ExtrudeRotation(double angle,
                            const core::Tensor &axis,
                            int resolution = 16,
                            double translation = 0.0,
                            bool capping = true) const;
 
    LineSet ExtrudeLinear(const core::Tensor &vector,
                          double scale = 1.0,
                          bool capping = true) const;
 
    int PCAPartition(int max_points);
 
protected:
    core::Device device_ = core::Device("CPU:0");
    TensorMap point_attr_;
};
 
}  // namespace geometry
}  // namespace t
}  // namespace open3d