TriangleMesh.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        Open3D: www.open3d.org                            -
// ----------------------------------------------------------------------------
// The MIT License (MIT)
//
// Copyright (c) 2018 www.open3d.org
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
// ----------------------------------------------------------------------------

#pragma once

#include <Eigen/Core>
#include <memory>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#include "Open3D/Geometry/Geometry3D.h"
#include "Open3D/Utility/Helper.h"

namespace open3d {
namespace geometry {

class PointCloud;

class TriangleMesh : public Geometry3D {
public:
    enum class SimplificationContraction { Average, Quadric };

    enum class FilterScope { All, Color, Normal, Vertex };

    TriangleMesh() : Geometry3D(Geometry::GeometryType::TriangleMesh) {}
    ~TriangleMesh() override {}

public:
    void Clear() override;
    bool IsEmpty() const override;
    Eigen::Vector3d GetMinBound() const override;
    Eigen::Vector3d GetMaxBound() const override;
    TriangleMesh &Transform(const Eigen::Matrix4d &transformation) override;
    TriangleMesh &Translate(const Eigen::Vector3d &translation) override;
    TriangleMesh &Scale(const double scale, bool center = true) override;
    TriangleMesh &Rotate(const Eigen::Vector3d &rotation,
                         bool center = true,
                         RotationType type = RotationType::XYZ) override;

public:
    TriangleMesh &operator+=(const TriangleMesh &mesh);
    TriangleMesh operator+(const TriangleMesh &mesh) const;

    void ComputeTriangleNormals(bool normalized = true);

    void ComputeVertexNormals(bool normalized = true);

    void ComputeAdjacencyList();

    virtual void RemoveDuplicatedVertices();

    virtual void RemoveDuplicatedTriangles();

    virtual void RemoveUnreferencedVertices();

    virtual void RemoveDegenerateTriangles();

    virtual void RemoveNonManifoldEdges();

    void FilterSharpen(int number_of_iterations,
                       double strength,
                       FilterScope scope = FilterScope::All);

    void FilterSmoothSimple(int number_of_iterations,
                            FilterScope scope = FilterScope::All);

    void FilterSmoothLaplacian(int number_of_iterations,
                               double lambda,
                               FilterScope scope = FilterScope::All);

    void FilterSmoothTaubin(int number_of_iterations,
                            double lambda = 0.5,
                            double mu = -0.53,
                            FilterScope scope = FilterScope::All);

protected:
    // Forward child class type to avoid indirect nonvirtual base
    TriangleMesh(Geometry::GeometryType type) : Geometry3D(type) {}

public:
    bool HasVertices() const { return vertices_.size() > 0; }

    bool HasTriangles() const {
        return vertices_.size() > 0 && triangles_.size() > 0;
    }

    bool HasVertexNormals() const {
        return vertices_.size() > 0 &&
               vertex_normals_.size() == vertices_.size();
    }

    bool HasVertexColors() const {
        return vertices_.size() > 0 &&
               vertex_colors_.size() == vertices_.size();
    }

    bool HasTriangleNormals() const {
        return HasTriangles() && triangles_.size() == triangle_normals_.size();
    }

    bool HasAdjacencyList() const {
        return vertices_.size() > 0 &&
               adjacency_list_.size() == vertices_.size();
    }

    void NormalizeNormals() {
        for (size_t i = 0; i < vertex_normals_.size(); i++) {
            vertex_normals_[i].normalize();
            if (std::isnan(vertex_normals_[i](0))) {
                vertex_normals_[i] = Eigen::Vector3d(0.0, 0.0, 1.0);
            }
        }
        for (size_t i = 0; i < triangle_normals_.size(); i++) {
            triangle_normals_[i].normalize();
            if (std::isnan(triangle_normals_[i](0))) {
                triangle_normals_[i] = Eigen::Vector3d(0.0, 0.0, 1.0);
            }
        }
    }

    void PaintUniformColor(const Eigen::Vector3d &color) {
        vertex_colors_.resize(vertices_.size());
        for (size_t i = 0; i < vertices_.size(); i++) {
            vertex_colors_[i] = color;
        }
    }

    int EulerPoincareCharacteristic() const;

    std::vector<Eigen::Vector2i> GetNonManifoldEdges(
            bool allow_boundary_edges = true) const;

    bool IsEdgeManifold(bool allow_boundary_edges = true) const;

    std::vector<int> GetNonManifoldVertices() const;

    bool IsVertexManifold() const;

    std::vector<Eigen::Vector2i> GetSelfIntersectingTriangles() const;

    bool IsSelfIntersecting() const;

    bool IsBoundingBoxIntersecting(const TriangleMesh &other) const;

    bool IsIntersecting(const TriangleMesh &other) const;

    bool IsOrientable() const;

    bool OrientTriangles();

    std::unordered_map<Eigen::Vector2i,
                       std::vector<int>,
                       utility::hash_eigen::hash<Eigen::Vector2i>>
    GetEdgeToTrianglesMap() const;

    double GetTriangleArea(size_t triangle_idx) const;

    double GetSurfaceArea() const;

    double GetSurfaceArea(std::vector<double> &triangle_areas) const;

    Eigen::Vector4d GetTrianglePlane(size_t triangle_idx) const;

public:
    std::vector<Eigen::Vector3d> vertices_;
    std::vector<Eigen::Vector3d> vertex_normals_;
    std::vector<Eigen::Vector3d> vertex_colors_;
    std::vector<Eigen::Vector3i> triangles_;
    std::vector<Eigen::Vector3d> triangle_normals_;
    std::vector<std::unordered_set<int>> adjacency_list_;
};

double ComputeTriangleArea(const Eigen::Vector3d &p0,
                           const Eigen::Vector3d &p1,
                           const Eigen::Vector3d &p2);

Eigen::Vector4d ComputeTrianglePlane(const Eigen::Vector3d &p0,
                                     const Eigen::Vector3d &p1,
                                     const Eigen::Vector3d &p2);

std::shared_ptr<TriangleMesh> ComputeMeshConvexHull(const TriangleMesh &mesh);

std::shared_ptr<PointCloud> SamplePointsUniformly(const TriangleMesh &input,
                                                  size_t number_of_points);

std::shared_ptr<PointCloud> SamplePointsPoissonDisk(
        const TriangleMesh &input,
        size_t number_of_points,
        double init_factor = 5,
        const std::shared_ptr<PointCloud> pcl_init = nullptr);

std::shared_ptr<TriangleMesh> SubdivideMidpoint(const TriangleMesh &input,
                                                int number_of_iterations);

std::shared_ptr<TriangleMesh> SubdivideLoop(const TriangleMesh &input,
                                            int number_of_iterations);

std::shared_ptr<TriangleMesh> SimplifyVertexClustering(
        const TriangleMesh &input,
        double voxel_size,
        TriangleMesh::SimplificationContraction contraction =
                TriangleMesh::SimplificationContraction::Average);

std::shared_ptr<TriangleMesh> SimplifyQuadricDecimation(
        const TriangleMesh &input, int target_number_of_triangles);

std::shared_ptr<TriangleMesh> SelectDownSample(
        const TriangleMesh &input, const std::vector<size_t> &indices);

std::shared_ptr<TriangleMesh> CropTriangleMesh(
        const TriangleMesh &input,
        const Eigen::Vector3d &min_bound,
        const Eigen::Vector3d &max_bound);

std::shared_ptr<TriangleMesh> CreateMeshTetrahedron(double radius = 1.0);

std::shared_ptr<TriangleMesh> CreateMeshOctahedron(double radius = 1.0);

std::shared_ptr<TriangleMesh> CreateMeshIcosahedron(double radius = 1.0);

std::shared_ptr<TriangleMesh> CreateMeshBox(double width = 1.0,
                                            double height = 1.0,
                                            double depth = 1.0);

std::shared_ptr<TriangleMesh> CreateMeshSphere(double radius = 1.0,
                                               int resolution = 20);

std::shared_ptr<TriangleMesh> CreateMeshCylinder(double radius = 1.0,
                                                 double height = 2.0,
                                                 int resolution = 20,
                                                 int split = 4);

std::shared_ptr<TriangleMesh> CreateMeshCone(double radius = 1.0,
                                             double height = 2.0,
                                             int resolution = 20,
                                             int split = 1);

std::shared_ptr<TriangleMesh> CreateMeshTorus(double torus_radius = 1.0,
                                              double tube_radius = 0.5,
                                              int radial_resolution = 30,
                                              int tubular_resolution = 20);

std::shared_ptr<TriangleMesh> CreateMeshArrow(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);

std::shared_ptr<TriangleMesh> CreateMeshCoordinateFrame(
        double size = 1.0,
        const Eigen::Vector3d &origin = Eigen::Vector3d(0.0, 0.0, 0.0));

std::shared_ptr<TriangleMesh> CreateMeshMoebius(int length_split = 70,
                                                int width_split = 15,
                                                int twists = 1,
                                                double radius = 1,
                                                double flatness = 1,
                                                double width = 1,
                                                double scale = 1);

}  // namespace geometry
}  // namespace open3d