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 "open3d/core/Tensor.h"
#include "open3d/core/TensorList.h"
#include "open3d/geometry/TriangleMesh.h"
#include "open3d/t/geometry/Geometry.h"
#include "open3d/t/geometry/TensorListMap.h"

namespace open3d {
namespace t {
namespace geometry {

class TriangleMesh : public Geometry {
public:
    TriangleMesh(core::Dtype vertex_dtype = core::Dtype::Float32,
                 core::Dtype triangle_dtype = core::Dtype::Int64,
                 const core::Device &device = core::Device("CPU:0"));

    TriangleMesh(const core::TensorList &vertices,
                 const core::TensorList &triangles);

    virtual ~TriangleMesh() override {}

public:
    core::TensorList &GetVertexAttr(const std::string &key) {
        return vertex_attr_.at(key);
    }

    core::TensorList &GetVertices() { return GetVertexAttr("vertices"); }

    core::TensorList &GetVertexColors() { return GetVertexAttr("colors"); }

    core::TensorList &GetVertexNormals() { return GetVertexAttr("normals"); }

    core::TensorList &GetTriangleAttr(const std::string &key) {
        return triangle_attr_.at(key);
    }

    core::TensorList &GetTriangles() { return GetTriangleAttr("triangles"); }

    core::TensorList &GetTriangleNormals() {
        return GetTriangleAttr("normals");
    }

    core::TensorList &GetTriangleColors() { return GetTriangleAttr("colors"); }

    const core::TensorList &GetVertexAttr(const std::string &key) const {
        return vertex_attr_.at(key);
    }

    const core::TensorList &GetVertices() const {
        return GetVertexAttr("vertices");
    }

    const core::TensorList &GetVertexColors() const {
        return GetVertexAttr("colors");
    }

    const core::TensorList &GetVertexNormals() const {
        return GetVertexAttr("normals");
    }

    const core::TensorList &GetTriangleAttr(const std::string &key) const {
        return triangle_attr_.at(key);
    }

    const core::TensorList &GetTriangles() const {
        return GetTriangleAttr("triangles");
    }

    const core::TensorList &GetTriangleNormals() const {
        return GetTriangleAttr("normals");
    }

    const core::TensorList &GetTriangleColors() const {
        return GetTriangleAttr("colors");
    }

    void SetVertexAttr(const std::string &key, const core::TensorList &value) {
        value.AssertDevice(device_);
        vertex_attr_[key] = value;
    }

    void SetVertices(const core::TensorList &value) {
        value.AssertElementShape({3});
        SetVertexAttr("vertices", value);
    }

    void SetVertexColors(const core::TensorList &value) {
        value.AssertElementShape({3});
        SetVertexAttr("colors", value);
    }

    void SetVertexNormals(const core::TensorList &value) {
        value.AssertElementShape({3});
        SetVertexAttr("normals", value);
    }

    void SetTriangleAttr(const std::string &key,
                         const core::TensorList &value) {
        value.AssertDevice(device_);
        triangle_attr_[key] = value;
    }

    void SetTriangles(const core::TensorList &value) {
        value.AssertElementShape({3});
        SetTriangleAttr("triangles", value);
    }

    void SetTriangleNormals(const core::TensorList &value) {
        value.AssertElementShape({3});
        SetTriangleAttr("normals", value);
    }

    void SetTriangleColors(const core::TensorList &value) {
        value.AssertElementShape({3});
        SetTriangleAttr("colors", value);
    }

    bool HasVertexAttr(const std::string &key) const {
        return vertex_attr_.Contains(key) && GetVertexAttr(key).GetSize() > 0 &&
               GetVertexAttr(key).GetSize() == GetVertices().GetSize();
    }

    bool HasVertices() const { return HasVertexAttr("vertices"); }

    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).GetSize() > 0 &&
               GetTriangleAttr(key).GetSize() == GetTriangles().GetSize();
    }

    bool HasTriangles() const { return HasTriangleAttr("triangles"); }

    bool HasTriangleNormals() const { return HasTriangleAttr("normals"); }

    bool HasTriangleColors() const { return HasTriangleAttr("colors"); }

    void VertexSynchronizedPushBack(
            const std::unordered_map<std::string, core::Tensor>
                    &map_keys_to_tensors) {
        vertex_attr_.SynchronizedPushBack(map_keys_to_tensors);
    }

    void TriangleSynchronizedPushBack(
            const std::unordered_map<std::string, core::Tensor>
                    &map_keys_to_tensors) {
        triangle_attr_.SynchronizedPushBack(map_keys_to_tensors);
    }

public:
    TriangleMesh &Clear() override {
        vertex_attr_.clear();
        triangle_attr_.clear();
        return *this;
    }

    bool IsEmpty() const override { return !HasVertices(); }

    core::Tensor GetMinBound() const { utility::LogError("Unimplemented"); }

    core::Tensor GetMaxBound() const { utility::LogError("Unimplemented"); }

    core::Tensor GetCenter() const { utility::LogError("Unimplemented"); }

    TriangleMesh &Transform(const core::Tensor &transformation) {
        utility::LogError("Unimplemented");
    }

    TriangleMesh &Translate(const core::Tensor &translation,
                            bool relative = true) {
        utility::LogError("Unimplemented");
    }

    TriangleMesh &Scale(double scale, const core::Tensor &center) {
        utility::LogError("Unimplemented");
    }

    TriangleMesh &Rotate(const core::Tensor &R, const core::Tensor &center) {
        utility::LogError("Unimplemented");
    }

    core::Device GetDevice() const { return device_; }

    static geometry::TriangleMesh FromLegacyTrangleMesh(
            const geometry::TriangleMesh &mesh_legacy,
            core::Dtype dtype = core::Dtype::Float32,
            const core::Device &device = core::Device("CPU:0")) {
        utility::LogError("Unimplemented");
    }

    geometry::TriangleMesh ToLegacyTriangleMesh() const {
        utility::LogError("Unimplemented");
    }

protected:
    core::Device device_ = core::Device("CPU:0");
    TensorListMap vertex_attr_;
    TensorListMap triangle_attr_;
};

}  // namespace geometry
}  // namespace t
}  // namespace open3d