TriangleMesh.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        Open3D: www.open3d.org                            -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.open3d.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
#include <list>
#include <type_traits>
#include <unordered_map>
 
#include "open3d/core/Tensor.h"
#include "open3d/core/TensorCheck.h"
#include "open3d/geometry/TriangleMesh.h"
#include "open3d/t/geometry/BoundingVolume.h"
#include "open3d/t/geometry/DrawableGeometry.h"
#include "open3d/t/geometry/Geometry.h"
#include "open3d/t/geometry/TensorMap.h"
#include "open3d/visualization/rendering/Model.h"
 
namespace open3d {
namespace t {
namespace geometry {
 
class LineSet;
class PointCloud;
 
class TriangleMesh : public Geometry, public DrawableGeometry {
public:
    TriangleMesh(const core::Device &device = core::Device("CPU:0"));
 
    TriangleMesh(const core::Tensor &vertex_positions,
                 const core::Tensor &triangle_indices);
 
    virtual ~TriangleMesh() override {}
 
public:
    std::string ToString() const;
 
    TriangleMesh To(const core::Device &device, bool copy = false) const;
 
    TriangleMesh Clone() const { return To(GetDevice(), /*copy=*/true); }
 
    const TensorMap &GetVertexAttr() const { return vertex_attr_; }
 
    TensorMap &GetVertexAttr() { return vertex_attr_; }
 
    core::Tensor &GetVertexAttr(const std::string &key) {
        return vertex_attr_.at(key);
    }
 
    core::Tensor &GetVertexPositions() { return GetVertexAttr("positions"); }
 
    core::Tensor &GetVertexColors() { return GetVertexAttr("colors"); }
 
    core::Tensor &GetVertexNormals() { return GetVertexAttr("normals"); }
 
    const TensorMap &GetTriangleAttr() const { return triangle_attr_; }
 
    TensorMap &GetTriangleAttr() { return triangle_attr_; }
 
    core::Tensor &GetTriangleAttr(const std::string &key) {
        return triangle_attr_.at(key);
    }
 
    core::Tensor &GetTriangleIndices() { return GetTriangleAttr("indices"); }
 
    core::Tensor &GetTriangleNormals() { return GetTriangleAttr("normals"); }
 
    core::Tensor &GetTriangleColors() { return GetTriangleAttr("colors"); }
 
    const core::Tensor &GetVertexAttr(const std::string &key) const {
        return vertex_attr_.at(key);
    }
 
    void RemoveVertexAttr(const std::string &key) { vertex_attr_.Erase(key); }
 
    const core::Tensor &GetVertexPositions() const {
        return GetVertexAttr("positions");
    }
 
    const core::Tensor &GetVertexColors() const {
        return GetVertexAttr("colors");
    }
 
    const core::Tensor &GetVertexNormals() const {
        return GetVertexAttr("normals");
    }
 
    const core::Tensor &GetTriangleAttr(const std::string &key) const {
        return triangle_attr_.at(key);
    }
 
    void RemoveTriangleAttr(const std::string &key) {
        triangle_attr_.Erase(key);
    }
 
    const core::Tensor &GetTriangleIndices() const {
        return GetTriangleAttr("indices");
    }
 
    const core::Tensor &GetTriangleNormals() const {
        return GetTriangleAttr("normals");
    }
 
    const core::Tensor &GetTriangleColors() const {
        return GetTriangleAttr("colors");
    }
 
    void SetVertexAttr(const std::string &key, const core::Tensor &value) {
        core::AssertTensorDevice(value, device_);
        vertex_attr_[key] = value;
    }
 
    void SetVertexPositions(const core::Tensor &value) {
        core::AssertTensorShape(value, {utility::nullopt, 3});
        SetVertexAttr("positions", value);
    }
 
    void SetVertexColors(const core::Tensor &value) {
        core::AssertTensorShape(value, {utility::nullopt, 3});
        SetVertexAttr("colors", value);
    }
 
    void SetVertexNormals(const core::Tensor &value) {
        core::AssertTensorShape(value, {utility::nullopt, 3});
        SetVertexAttr("normals", value);
    }
 
    void SetTriangleAttr(const std::string &key, const core::Tensor &value) {
        core::AssertTensorDevice(value, device_);
        triangle_attr_[key] = value;
    }
 
    void SetTriangleIndices(const core::Tensor &value) {
        core::AssertTensorShape(value, {utility::nullopt, 3});
        SetTriangleAttr("indices", value);
    }
 
    void SetTriangleNormals(const core::Tensor &value) {
        core::AssertTensorShape(value, {utility::nullopt, 3});
        SetTriangleAttr("normals", value);
    }
 
    void SetTriangleColors(const core::Tensor &value) {
        core::AssertTensorShape(value, {utility::nullopt, 3});
        SetTriangleAttr("colors", value);
    }
 
    bool HasVertexAttr(const std::string &key) const {
        return vertex_attr_.Contains(key) &&
               GetVertexAttr(key).GetLength() > 0 &&
               GetVertexAttr(key).GetLength() ==
                       GetVertexPositions().GetLength();
    }
 
    bool HasVertexPositions() const { return HasVertexAttr("positions"); }
 
    bool HasVertexColors() const { return HasVertexAttr("colors"); }
 
    bool HasVertexNormals() const { return HasVertexAttr("normals"); }
 
    bool HasTriangleAttr(const std::string &key) const {
        return triangle_attr_.Contains(key) &&
               GetTriangleAttr(key).GetLength() > 0 &&
               GetTriangleAttr(key).GetLength() ==
                       GetTriangleIndices().GetLength();
    }
 
    bool HasTriangleIndices() const { return HasTriangleAttr("indices"); }
 
    bool HasTriangleNormals() const { return HasTriangleAttr("normals"); }
 
    bool HasTriangleColors() const { return HasTriangleAttr("colors"); }
 
    static TriangleMesh CreateBox(
            double width = 1.0,
            double height = 1.0,
            double depth = 1.0,
            core::Dtype float_dtype = core::Float32,
            core::Dtype int_dtype = core::Int64,
            const core::Device &device = core::Device("CPU:0"));
 
    static TriangleMesh CreateSphere(
            double radius = 1.0,
            int resolution = 20,
            core::Dtype float_dtype = core::Float32,
            core::Dtype int_dtype = core::Int64,
            const core::Device &device = core::Device("CPU:0"));
 
    static TriangleMesh CreateTetrahedron(
            double radius = 1.0,
            core::Dtype float_dtype = core::Float32,
            core::Dtype int_dtype = core::Int64,
            const core::Device &device = core::Device("CPU:0"));
 
    static TriangleMesh CreateOctahedron(
            double radius = 1.0,
            core::Dtype float_dtype = core::Float32,
            core::Dtype int_dtype = core::Int64,
            const core::Device &device = core::Device("CPU:0"));
 
    static TriangleMesh CreateIcosahedron(
            double radius = 1.0,
            core::Dtype float_dtype = core::Float32,
            core::Dtype int_dtype = core::Int64,
            const core::Device &device = core::Device("CPU:0"));
 
    static TriangleMesh CreateCylinder(
            double radius = 1.0,
            double height = 2.0,
            int resolution = 20,
            int split = 4,
            core::Dtype float_dtype = core::Float32,
            core::Dtype int_dtype = core::Int64,
            const core::Device &device = core::Device("CPU:0"));
 
    static TriangleMesh CreateCone(
            double radius = 1.0,
            double height = 2.0,
            int resolution = 20,
            int split = 1,
            core::Dtype float_dtype = core::Float32,
            core::Dtype int_dtype = core::Int64,
            const core::Device &device = core::Device("CPU:0"));
 
    static TriangleMesh CreateTorus(
            double torus_radius = 1.0,
            double tube_radius = 0.5,
            int radial_resolution = 30,
            int tubular_resolution = 20,
            core::Dtype float_dtype = core::Float32,
            core::Dtype int_dtype = core::Int64,
            const core::Device &device = core::Device("CPU:0"));
 
    static TriangleMesh CreateArrow(
            double cylinder_radius = 1.0,
            double cone_radius = 1.5,
            double cylinder_height = 5.0,
            double cone_height = 4.0,
            int resolution = 20,
            int cylinder_split = 4,
            int cone_split = 1,
            core::Dtype float_dtype = core::Float32,
            core::Dtype int_dtype = core::Int64,
            const core::Device &device = core::Device("CPU:0"));
 
    static TriangleMesh CreateCoordinateFrame(
            double size = 1.0,
            const Eigen::Vector3d &origin = Eigen::Vector3d(0.0, 0.0, 0.0),
            core::Dtype float_dtype = core::Float32,
            core::Dtype int_dtype = core::Int64,
            const core::Device &device = core::Device("CPU:0"));
 
    static TriangleMesh CreateMobius(
            int length_split = 70,
            int width_split = 15,
            int twists = 1,
            double radius = 1,
            double flatness = 1,
            double width = 1,
            double scale = 1,
            core::Dtype float_dtype = core::Float32,
            core::Dtype int_dtype = core::Int64,
            const core::Device &device = core::Device("CPU:0"));
 
    static TriangleMesh CreateText(
            const std::string &text,
            double depth = 0.0,
            core::Dtype float_dtype = core::Float32,
            core::Dtype int_dtype = core::Int64,
            const core::Device &device = core::Device("CPU:0"));
 
    static TriangleMesh CreateIsosurfaces(
            const core::Tensor &volume,
            const std::vector<double> contour_values = {0.0},
            const core::Device &device = core::Device("CPU:0"));
 
public:
    TriangleMesh &Clear() override {
        vertex_attr_.clear();
        triangle_attr_.clear();
        return *this;
    }
 
    bool IsEmpty() const override { return !HasVertexPositions(); }
 
    core::Tensor GetMinBound() const { return GetVertexPositions().Min({0}); }
 
    core::Tensor GetMaxBound() const { return GetVertexPositions().Max({0}); }
 
    core::Tensor GetCenter() const { return GetVertexPositions().Mean({0}); }
 
    TriangleMesh &Transform(const core::Tensor &transformation);
 
    TriangleMesh &Translate(const core::Tensor &translation,
                            bool relative = true);
 
    TriangleMesh &Scale(double scale, const core::Tensor &center);
 
    TriangleMesh &Rotate(const core::Tensor &R, const core::Tensor &center);
 
    TriangleMesh &NormalizeNormals();
 
    TriangleMesh &ComputeTriangleNormals(bool normalized = true);
 
    TriangleMesh &ComputeVertexNormals(bool normalized = true);
 
    double GetSurfaceArea() const;
 
    TriangleMesh &ComputeTriangleAreas();
 
    TriangleMesh ClipPlane(const core::Tensor &point,
                           const core::Tensor &normal) const;
 
    LineSet SlicePlane(const core::Tensor &point,
                       const core::Tensor &normal,
                       const std::vector<double> contour_values = {0.0}) const;
 
    core::Device GetDevice() const override { return device_; }
 
    static geometry::TriangleMesh FromLegacy(
            const open3d::geometry::TriangleMesh &mesh_legacy,
            core::Dtype float_dtype = core::Float32,
            core::Dtype int_dtype = core::Int64,
            const core::Device &device = core::Device("CPU:0"));
 
    open3d::geometry::TriangleMesh ToLegacy() const;
 
    static std::unordered_map<std::string, geometry::TriangleMesh>
    FromTriangleMeshModel(
            const open3d::visualization::rendering::TriangleMeshModel &model,
            core::Dtype float_dtype = core::Float32,
            core::Dtype int_dtype = core::Int64,
            const core::Device &device = core::Device("CPU:0"));
 
    TriangleMesh ComputeConvexHull(bool joggle_inputs = false) const;
 
    TriangleMesh SimplifyQuadricDecimation(double target_reduction,
                                           bool preserve_volume = true) const;
 
    TriangleMesh BooleanUnion(const TriangleMesh &mesh,
                              double tolerance = 1e-6) const;
 
    TriangleMesh BooleanIntersection(const TriangleMesh &mesh,
                                     double tolerance = 1e-6) const;
 
    TriangleMesh BooleanDifference(const TriangleMesh &mesh,
                                   double tolerance = 1e-6) const;
 
    AxisAlignedBoundingBox GetAxisAlignedBoundingBox() const;
 
    OrientedBoundingBox GetOrientedBoundingBox() const;
 
    TriangleMesh FillHoles(double hole_size = 1e6) const;
 
    std::tuple<float, int, int> ComputeUVAtlas(size_t size = 512,
                                               float gutter = 1.0f,
                                               float max_stretch = 1.f / 6,
                                               int parallel_partitions = 1,
                                               int nthreads = 0);
 
    std::unordered_map<std::string, core::Tensor> BakeVertexAttrTextures(
            int size,
            const std::unordered_set<std::string> &vertex_attr = {},
            double margin = 2.,
            double fill = 0.,
            bool update_material = true);
 
    std::unordered_map<std::string, core::Tensor> BakeTriangleAttrTextures(
            int size,
            const std::unordered_set<std::string> &triangle_attr = {},
            double margin = 2.,
            double fill = 0.,
            bool update_material = true);
 
    TriangleMesh ExtrudeRotation(double angle,
                                 const core::Tensor &axis,
                                 int resolution = 16,
                                 double translation = 0.0,
                                 bool capping = true) const;
 
    TriangleMesh ExtrudeLinear(const core::Tensor &vector,
                               double scale = 1.0,
                               bool capping = true) const;
 
    int PCAPartition(int max_faces);
 
    TriangleMesh SelectFacesByMask(const core::Tensor &mask) const;
 
    TriangleMesh SelectByIndex(const core::Tensor &indices,
                               bool copy_attributes = true) const;
 
    TriangleMesh RemoveUnreferencedVertices();
 
    Image ProjectImagesToAlbedo(
            const std::vector<Image> &images,
            const std::vector<core::Tensor> &intrinsic_matrices,
            const std::vector<core::Tensor> &extrinsic_matrices,
            int tex_size = 1024,
            bool update_material = true);
 
    TriangleMesh RemoveNonManifoldEdges();
 
    core::Tensor GetNonManifoldEdges(bool allow_boundary_edges = true) const;
 
    PointCloud SamplePointsUniformly(size_t number_of_points,
                                     bool use_triangle_normal = false);
 
 
 
    core::Tensor ComputeMetrics(
            const TriangleMesh &mesh2,
            std::vector<Metric> metrics = {Metric::ChamferDistance},
            MetricParameters params = MetricParameters()) const;
 
protected:
    core::Device device_ = core::Device("CPU:0");
    TensorMap vertex_attr_;
    TensorMap triangle_attr_;
};
 
}  // namespace geometry
}  // namespace t
}  // namespace open3d