Convert triangle mesh model to tmesh map

ToString for Material
MaterialRecord to Material conversion
Support for emissive color reading in FileASSIMP
 (model) and writing for tmesh (tio FIleASSIMP)

cpp/open3d/io/file_format/FileASSIMP.cpp

@@ -422,6 +422,9 @@ bool ReadModelUsingAssimp(const std::string& filename,
         mat->Get(AI_MATKEY_CLEARCOAT_ROUGHNESS_FACTOR,
                  o3d_mat.base_clearcoat_roughness);
         mat->Get(AI_MATKEY_ANISOTROPY, o3d_mat.base_anisotropy);
+        mat->Get(AI_MATKEY_COLOR_EMISSIVE, color);
+        o3d_mat.emissive_color =
+                Eigen::Vector4f(color.r, color.g, color.b, 1.f);
         aiString alpha_mode;
         mat->Get(AI_MATKEY_GLTF_ALPHAMODE, alpha_mode);
         std::string alpha_mode_str(alpha_mode.C_Str());

cpp/open3d/t/geometry/TriangleMesh.cpp

@@ -377,6 +377,7 @@ geometry::TriangleMesh TriangleMesh::FromLegacy(
         tmat.SetAnisotropy(mat.baseAnisotropy);
         tmat.SetBaseClearcoat(mat.baseClearCoat);
         tmat.SetBaseClearcoatRoughness(mat.baseClearCoatRoughness);
+        // no emissive_color in legacy mesh material
         if (mat.albedo) tmat.SetAlbedoMap(Image::FromLegacy(*mat.albedo));
         if (mat.normalMap) tmat.SetNormalMap(Image::FromLegacy(*mat.normalMap));
         if (mat.roughness)
@@ -453,10 +454,6 @@ open3d::geometry::TriangleMesh TriangleMesh::ToLegacy() const {
             legacy_mat.baseColor.f4[1] = tmat.GetBaseColor().y();
             legacy_mat.baseColor.f4[2] = tmat.GetBaseColor().z();
             legacy_mat.baseColor.f4[3] = tmat.GetBaseColor().w();
-            utility::LogWarning("{},{},{},{}", legacy_mat.baseColor.f4[0],
-                                legacy_mat.baseColor.f4[1],
-                                legacy_mat.baseColor.f4[2],
-                                legacy_mat.baseColor.f4[3]);
         }
         if (tmat.HasBaseRoughness()) {
             legacy_mat.baseRoughness = tmat.GetBaseRoughness();
@@ -523,6 +520,26 @@ open3d::geometry::TriangleMesh TriangleMesh::ToLegacy() const {
     return mesh_legacy;
 }
 
+std::unordered_map<std::string, geometry::TriangleMesh>
+TriangleMesh::FromTriangleMeshModel(
+        const open3d::visualization::rendering::TriangleMeshModel &model,
+        core::Dtype float_dtype,
+        core::Dtype int_dtype,
+        const core::Device &device) {
+    std::unordered_map<std::string, TriangleMesh> tmeshes;
+    for (const auto &mobj : model.meshes_) {
+        auto tmesh = TriangleMesh::FromLegacy(*mobj.mesh, float_dtype,
+                                              int_dtype, device);
+        // material textures will be on the CPU. GPU resident texture images is
+        // not yet supported. See comment in Material.cpp
+        tmesh.SetMaterial(
+                visualization::rendering::Material::FromMaterialRecord(
+                        model.materials_[mobj.material_idx]));
+        tmeshes.emplace(mobj.mesh_name, tmesh);
+    }
+    return tmeshes;
+}
+
 TriangleMesh TriangleMesh::To(const core::Device &device, bool copy) const {
     if (!copy && GetDevice() == device) {
         return *this;

cpp/open3d/t/geometry/TriangleMesh.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <list>
+#include <unordered_map>
 
 #include "open3d/core/Tensor.h"
 #include "open3d/core/TensorCheck.h"
@@ -16,6 +17,7 @@
 #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 {
@@ -701,7 +703,8 @@ class TriangleMesh : public Geometry, public DrawableGeometry {
     /// values, e.g. vertices, normals, colors.
     /// \param int_dtype Int32 or Int64, used to store index values, e.g.
     /// triangles.
-    /// \param device The device where the resulting TriangleMesh resides in.
+    /// \param device The device where the resulting TriangleMesh resides in
+    /// (default CPU:0).
     static geometry::TriangleMesh FromLegacy(
             const open3d::geometry::TriangleMesh &mesh_legacy,
             core::Dtype float_dtype = core::Float32,
@@ -711,6 +714,28 @@ class TriangleMesh : public Geometry, public DrawableGeometry {
     /// Convert to a legacy Open3D TriangleMesh.
     open3d::geometry::TriangleMesh ToLegacy() const;
 
+    /// Convert a TriangleMeshModel (e.g. as read from a file with
+    /// open3d::io::ReadTriangleMeshModel) to an unordered map of mesh names to
+    /// TriangleMeshes. Only one material is supported per mesh. Materials
+    /// common to multiple meshes will be dupicated. Textures (as
+    /// t::geometry::Image) will use shared storage.
+    /// \param model TriangleMeshModel to convert.
+    /// \param float_dtype Float32 or Float64, used to store floating point
+    /// values, e.g. vertices, normals, colors.
+    /// \param int_dtype Int32 or Int64, used to store index values, e.g.
+    /// triangles.
+    /// \param device The device where the resulting TriangleMesh resides in
+    /// (default CPU:0). Material textures use CPU storage - GPU resident
+    /// texture images are not yet supported.
+    /// \return unordered map of constituent mesh names to TriangleMeshes, with
+    /// materials.
+    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"));
+
     /// Compute the convex hull of the triangle mesh using qhull.
     ///
     /// This runs on the CPU.

cpp/open3d/t/io/file_format/FileASSIMP.cpp

@@ -6,6 +6,7 @@
 // ----------------------------------------------------------------------------
 
 #include <assimp/GltfMaterial.h>
+#include <assimp/material.h>
 #include <assimp/postprocess.h>
 #include <assimp/scene.h>
 
@@ -357,12 +358,17 @@ bool WriteTriangleMeshUsingASSIMP(const std::string& filename,
             auto r = mesh.GetMaterial().GetBaseClearcoatRoughness();
             ai_mat->AddProperty(&r, 1, AI_MATKEY_CLEARCOAT_ROUGHNESS_FACTOR);
         }
+        if (mesh.GetMaterial().HasEmissiveColor()) {
+            auto c = mesh.GetMaterial().GetEmissiveColor();
+            auto ac = aiColor4D(c.x(), c.y(), c.z(), c.w());
+            ai_mat->AddProperty(&ac, 1, AI_MATKEY_COLOR_EMISSIVE);
+        }
 
         // Count texture maps...
         // NOTE: GLTF2 expects a single combined roughness/metal map. If the
         // model has one we just export it, otherwise if both roughness and
-        // metal maps are avaialbe we combine them, otherwise if only one or the
-        // other is available we just export the one map.
+        // metal maps are available we combine them, otherwise if only one or
+        // the other is available we just export the one map.
         int n_textures = 0;
         if (mesh.GetMaterial().HasAlbedoMap()) ++n_textures;
         if (mesh.GetMaterial().HasNormalMap()) ++n_textures;

cpp/open3d/visualization/rendering/Material.cpp

@@ -26,6 +26,7 @@ void Material::SetDefaultProperties() {
     SetTransmission(1.f);
     SetAbsorptionColor(Eigen::Vector4f(1.f, 1.f, 1.f, 1.f));
     SetAbsorptionDistance(1.f);
+    SetEmissiveColor(Eigen::Vector4f(1.f, 1.f, 1.f, 1.f));
     SetPointSize(3.f);
     SetLineWidth(1.f);
 }
@@ -39,6 +40,24 @@ void Material::SetTextureMap(const std::string &key,
     texture_maps_[key] = image.To(core::Device("CPU:0"), true);
 }
 
+std::string Material::ToString() const {
+    if (!IsValid()) {
+        return "Invalid Material\n";
+    }
+    std::ostringstream os;
+    os << "Material " << material_name_ << '\n';
+    for (const auto &kv : scalar_properties_) {
+        os << '\t' << kv.first << ": " << kv.second << '\n';
+    }
+    for (const auto &kv : vector_properties_) {
+        os << '\t' << kv.first << ": " << kv.second.transpose() << '\n';
+    }
+    for (const auto &kv : texture_maps_) {
+        os << '\t' << kv.first << ": " << kv.second.ToString() << '\n';
+    }
+    return os.str();
+}
+
 void Material::ToMaterialRecord(MaterialRecord &record) const {
     record.shader = GetMaterialName();
     // Convert base material properties
@@ -63,6 +82,9 @@ void Material::ToMaterialRecord(MaterialRecord &record) const {
     if (HasAnisotropy()) {
         record.base_anisotropy = GetAnisotropy();
     }
+    if (HasEmissiveColor()) {
+        record.emissive_color = GetEmissiveColor();
+    }
     if (HasThickness()) {
         record.thickness = GetThickness();
     }
@@ -124,6 +146,62 @@ void Material::ToMaterialRecord(MaterialRecord &record) const {
     }
 }
 
+Material Material::FromMaterialRecord(const MaterialRecord &record) {
+    using t::geometry::Image;
+    Material tmat(record.shader);
+    // scalar and vector properties
+    tmat.SetBaseColor(record.base_color);
+    tmat.SetBaseMetallic(record.base_metallic);
+    tmat.SetBaseRoughness(record.base_roughness);
+    tmat.SetBaseReflectance(record.base_reflectance);
+    tmat.SetBaseClearcoat(record.base_clearcoat);
+    tmat.SetBaseClearcoatRoughness(record.base_clearcoat_roughness);
+    tmat.SetAnisotropy(record.base_anisotropy);
+    tmat.SetEmissiveColor(record.emissive_color);
+    // refractive materials
+    tmat.SetThickness(record.thickness);
+    tmat.SetTransmission(record.transmission);
+    tmat.SetAbsorptionDistance(record.absorption_distance);
+    // points and lines
+    tmat.SetPointSize(record.point_size);
+    tmat.SetLineWidth(record.line_width);
+    // maps
+    if (record.albedo_img) {
+        tmat.SetAlbedoMap(Image::FromLegacy(*record.albedo_img));
+    }
+    if (record.normal_img) {
+        tmat.SetNormalMap(Image::FromLegacy(*record.normal_img));
+    }
+    if (record.ao_img) {
+        tmat.SetAOMap(Image::FromLegacy(*record.ao_img));
+    }
+    if (record.metallic_img) {
+        tmat.SetMetallicMap(Image::FromLegacy(*record.metallic_img));
+    }
+    if (record.roughness_img) {
+        tmat.SetRoughnessMap(Image::FromLegacy(*record.roughness_img));
+    }
+    if (record.reflectance_img) {
+        tmat.SetReflectanceMap(Image::FromLegacy(*record.reflectance_img));
+    }
+    if (record.clearcoat_img) {
+        tmat.SetClearcoatMap(Image::FromLegacy(*record.clearcoat_img));
+    }
+    if (record.clearcoat_roughness_img) {
+        tmat.SetClearcoatRoughnessMap(
+                Image::FromLegacy(*record.clearcoat_roughness_img));
+    }
+    if (record.anisotropy_img) {
+        tmat.SetAnisotropyMap(Image::FromLegacy(*record.anisotropy_img));
+    }
+    if (record.ao_rough_metal_img) {
+        tmat.SetAORoughnessMetalMap(
+                Image::FromLegacy(*record.ao_rough_metal_img));
+    }
+
+    return tmat;
+}
+
 }  // namespace rendering
 }  // namespace visualization
 }  // namespace open3d

cpp/open3d/visualization/rendering/Material.h

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include <sstream>
 #include <string>
 
 #include "open3d/t/geometry/Image.h"
@@ -34,6 +35,9 @@ class Material {
 
     Material(const Material &mat) = default;
 
+    /// Convert from MaterialRecord
+    static Material FromMaterialRecord(const MaterialRecord &mat);
+
     Material &operator=(const Material &other) = default;
 
     /// Create an empty but valid material for the specified material name
@@ -51,6 +55,9 @@ class Material {
     /// Get the name of the material.
     const std::string &GetMaterialName() const { return material_name_; }
 
+    /// String reprentation for printing.
+    std::string ToString() const;
+
     /// Returns the texture map map
     const TextureMaps &GetTextureMaps() const { return texture_maps_; }
 
@@ -249,6 +256,9 @@ class Material {
     float GetAbsorptionDistance() const {
         return GetScalarProperty("absorption_distance");
     }
+    Eigen::Vector4f GetEmissiveColor() const {
+        return GetVectorProperty("emissive_color");
+    }
 
     bool HasBaseColor() const { return HasVectorProperty("base_color"); }
     bool HasBaseMetallic() const { return HasScalarProperty("metallic"); }
@@ -267,6 +277,9 @@ class Material {
     bool HasAbsorptionDistance() const {
         return HasScalarProperty("absorption_distance");
     }
+    bool HasEmissiveColor() const {
+        return HasVectorProperty("emissive_color");
+    }
 
     void SetBaseColor(const Eigen::Vector4f &value) {
         SetVectorProperty("base_color", value);
@@ -295,6 +308,9 @@ class Material {
     void SetAbsorptionDistance(float value) {
         SetScalarProperty("absorption_distance", value);
     }
+    void SetEmissiveColor(const Eigen::Vector4f &value) {
+        SetVectorProperty("emissive_color", value);
+    }
 
     ////////////////////////////////////////////////////////////////////////////
     ///

cpp/pybind/t/geometry/trianglemesh.cpp

@@ -238,6 +238,28 @@ The attributes of the triangle mesh have different levels::
             "vertex_dtype"_a = core::Float32, "triangle_dtype"_a = core::Int64,
             "device"_a = core::Device("CPU:0"),
             "Create a TriangleMesh from a legacy Open3D TriangleMesh.");
+    triangle_mesh.def_static(
+            "from_triangle_mesh_model", &TriangleMesh::FromTriangleMeshModel,
+            "model"_a, "vertex_dtype"_a = core::Float32,
+            "triangle_dtype"_a = core::Int64,
+            "device"_a = core::Device("CPU:0"),
+            R"(Convert a TriangleMeshModel (e.g. as read from a file with
+`open3d.io.read_triangle_mesh_model()`) to a dictionary of mesh names to
+triangle meshes with the specified vertex and triangle dtypes and moved to the
+specified device. Only a single material per mesh is supported. Materials common
+to multiple meshes will be duplicated. Textures (as t.geometry.Image) will use
+shared storage on the CPU (GPU resident images for textures is not yet supported).
+
+Returns:
+    Dictionary of names to triangle meshes.
+
+Example:
+    flight_helmet = o3d.data.FlightHelmetModel()
+    model = o3d.io.read_triangle_model(flight_helmet.path)
+    mesh_dict = o3d.t.geometry.TriangleMesh.from_triangle_mesh_model(model)
+    o3d.visualization.draw(list({"name": name, "geometry": tmesh} for
+        (name, tmesh) in mesh_dict.items()))
+            )");
     // conversion
     triangle_mesh.def("to_legacy", &TriangleMesh::ToLegacy,
                       "Convert to a legacy Open3D TriangleMesh.");

cpp/pybind/visualization/rendering/material.cpp

@@ -12,6 +12,7 @@
 
 #include "open3d/visualization/rendering/Material.h"
 
+#include "open3d/visualization/rendering/MaterialRecord.h"
 #include "pybind/open3d_pybind.h"
 
 PYBIND11_MAKE_OPAQUE(
@@ -41,6 +42,9 @@ void pybind_material(py::module& m) {
     mat.def(py::init<>())
             .def(py::init<Material>(), "", "mat"_a)
             .def(py::init<const std::string&>(), "", "material_name"_a)
+            .def(py::init(&Material::FromMaterialRecord), "material_record"_a,
+                 "Convert from MaterialRecord.")
+            .def("__repr__", &Material::ToString)
             .def("set_default_properties", &Material::SetDefaultProperties,
                  "Fills material with defaults for common PBR material "
                  "properties used by Open3D")

cpp/tests/t/geometry/TriangleMesh.cpp

@@ -10,6 +10,7 @@
 #include <gmock/gmock.h>
 
 #include "core/CoreTest.h"
+#include "open3d/core/Dtype.h"
 #include "open3d/core/EigenConverter.h"
 #include "open3d/core/TensorCheck.h"
 #include "tests/Tests.h"