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 <vector>
#include <unordered_set>
#include <memory>
#include <Eigen/Core>

#include <Open3D/Geometry/Geometry3D.h>

namespace open3d {
namespace geometry {

class TriangleMesh : public Geometry3D {
public:
    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;
    void Transform(const Eigen::Matrix4d &transformation) 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();

    void Purge();

protected:
    // Forward child class type to avoid indirect nonvirtual base
    TriangleMesh(Geometry::GeometryType type) : Geometry3D(type){};
    virtual void RemoveDuplicatedVertices();
    virtual void RemoveDuplicatedTriangles();
    virtual void RemoveNonManifoldVertices();
    virtual void RemoveNonManifoldTriangles();

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;
        }
    }

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_;
};

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> 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> 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));

}  // namespace geometry
}  // namespace open3d