Improved mesh parsing to include normals, vertex color, material and texture (#490)

Author: johnwason

tesseract/tesseract_common/include/tesseract_common/resource.h

@@ -96,6 +96,21 @@ class Resource
    * @return A std::istream shared pointer for the resource data
    */
   virtual std::shared_ptr<std::istream> getResourceContentStream() = 0;
+
+  /**
+   * @brief Retrive a sub-resource relative to the current resource
+   *
+   * Retrive a sub-resource related to the current resource. For instance, retrieve
+   * an image resource for a mesh. The relative_path should be relative to the
+   * parent directory containing the current resource.
+   *
+   * This function is optional, and will only be available on resource locators
+   * that support retrieving relative resources.
+   *
+   * @param relative_path Path relative to the parent directory of the current resource
+   * @return Resource::Ptr The located resource, or nullptr if not found
+   */
+  virtual Resource::Ptr locateSubResource(const std::string& relative_path) { return nullptr; }
 };
 
 class BytesResource : public tesseract_common::Resource

tesseract/tesseract_common/include/tesseract_common/types.h

@@ -54,6 +54,7 @@ using AlignedUnorderedMap = std::unordered_map<Key,
 using VectorIsometry3d = AlignedVector<Eigen::Isometry3d>;
 using VectorVector4d = AlignedVector<Eigen::Vector4d>;
 using VectorVector3d = std::vector<Eigen::Vector3d>;
+using VectorVector2d = AlignedVector<Eigen::Vector2d>;
 using TransformMap = AlignedMap<std::string, Eigen::Isometry3d>;
 
 using TrajArray = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;

tesseract/tesseract_geometry/CMakeLists.txt

@@ -41,6 +41,14 @@ if(NOT TARGET octomath)
   set_target_properties(octomath PROPERTIES INTERFACE_LINK_LIBRARIES "${OCTOMAP_LIBRARIES}")
 endif()
 
+find_file(ASSIMP_PBR_MATERIAL_FOUND assimp/pbrmaterial.h HINTS ${assimp_INCLUDE_DIRS})
+
+if(ASSIMP_PBR_MATERIAL_FOUND)
+set(TESSERACT_ASSIMP_USE_PBRMATERIAL TESSERACT_ASSIMP_USE_PBRMATERIAL=1)
+else()
+set(TESSERACT_ASSIMP_USE_PBRMATERIAL)
+endif()
+
 initialize_code_coverage()
 set(COVERAGE_EXCLUDE /usr/* /opt/* ${CMAKE_CURRENT_LIST_DIR}/test/* /*/gtest/*)
 add_code_coverage_all_targets(EXCLUDE ${COVERAGE_EXCLUDE})
@@ -51,7 +59,7 @@ tesseract_variables()
 add_library(${PROJECT_NAME} INTERFACE)
 target_link_libraries(${PROJECT_NAME} INTERFACE tesseract::tesseract_common console_bridge::console_bridge octomap octomath ${assimp_LIBRARIES})
 target_compile_options(${PROJECT_NAME} INTERFACE ${TESSERACT_COMPILE_OPTIONS_PUBLIC})
-target_compile_definitions(${PROJECT_NAME} INTERFACE ${TESSERACT_COMPILE_DEFINITIONS})
+target_compile_definitions(${PROJECT_NAME} INTERFACE ${TESSERACT_COMPILE_DEFINITIONS} ${TESSERACT_ASSIMP_USE_PBRMATERIAL})
 target_clang_tidy(${PROJECT_NAME} ARGUMENTS ${TESSERACT_CLANG_TIDY_ARGS} ENABLE ${TESSERACT_ENABLE_CLANG_TIDY})
 target_cxx_version(${PROJECT_NAME} INTERFACE VERSION ${TESSERACT_CXX_VERSION})
 target_code_coverage(${PROJECT_NAME} INTERFACE ALL EXCLUDE ${COVERAGE_EXCLUDE} ENABLE ${TESSERACT_ENABLE_CODE_COVERAGE})

tesseract/tesseract_geometry/include/tesseract_geometry/geometries.h

@@ -59,6 +59,7 @@
 %include <tesseract_geometry/impl/capsule.h>
 %include <tesseract_geometry/impl/cone.h>
 %include <tesseract_geometry/impl/plane.h>
+%include <tesseract_geometry/impl/mesh_material.h>
 %include <tesseract_geometry/impl/mesh.h>
 %include <tesseract_geometry/impl/convex_mesh.h>
 %include <tesseract_geometry/impl/octree.h>

tesseract/tesseract_geometry/include/tesseract_geometry/impl/convex_mesh.h

@@ -35,6 +35,7 @@ TESSERACT_COMMON_IGNORE_WARNINGS_POP
 #include <tesseract_geometry/geometry.h>
 #include <tesseract_common/types.h>
 #include <tesseract_common/resource.h>
+#include <tesseract_geometry/impl/mesh_material.h>
 
 #ifdef SWIG
 %shared_ptr(tesseract_geometry::ConvexMesh)
@@ -43,10 +44,6 @@ TESSERACT_COMMON_IGNORE_WARNINGS_POP
 
 namespace tesseract_geometry
 {
-#ifdef SWIG
-%nodefaultctor ConvexMesh;
-#endif  // SWIG
-
 class ConvexMesh : public Geometry
 {
 public:
@@ -55,7 +52,6 @@ class ConvexMesh : public Geometry
   using Ptr = std::shared_ptr<ConvexMesh>;
   using ConstPtr = std::shared_ptr<const ConvexMesh>;
 
-#ifndef SWIG
   /**
    * @brief Convex Mesh geometry
    * @param vertices A vector of vertices associated with the mesh
@@ -65,16 +61,28 @@ class ConvexMesh : public Geometry
    *              three vertices that define this face followed by three indices.
    * @param resource A resource locator for locating resource
    * @param scale Scale the mesh
+   * @param normals A vector of normals for the vertices (optional)
+   * @param vertex_colors A vector of colors (RGBA) for the vertices (optional)
+   * @param mesh_material A MeshMaterial describing the color and material properties of the mesh (optional)
+   * @param mesh_textures A vector of MeshTexture to apply to the mesh (optional)
    */
   ConvexMesh(std::shared_ptr<const tesseract_common::VectorVector3d> vertices,
              std::shared_ptr<const Eigen::VectorXi> faces,
              tesseract_common::Resource::Ptr resource = nullptr,
-             Eigen::Vector3d scale = Eigen::Vector3d(1, 1, 1))
+             Eigen::Vector3d scale = Eigen::Vector3d(1, 1, 1),
+             std::shared_ptr<const tesseract_common::VectorVector3d> normals = nullptr,
+             std::shared_ptr<const tesseract_common::VectorVector4d> vertex_colors = nullptr,
+             MeshMaterial::Ptr mesh_material = nullptr,
+             std::shared_ptr<const std::vector<MeshTexture::Ptr>> mesh_textures = nullptr)
     : Geometry(GeometryType::CONVEX_MESH)
     , vertices_(std::move(vertices))
     , faces_(std::move(faces))
     , resource_(std::move(resource))
     , scale_(std::move(scale))
+    , normals_(std::move(normals))
+    , vertex_colors_(std::move(vertex_colors))
+    , mesh_material_(std::move(mesh_material))
+    , mesh_textures_(std::move(mesh_textures))
   {
     vertice_count_ = static_cast<int>(vertices_->size());
 
@@ -97,46 +105,40 @@ class ConvexMesh : public Geometry
    * @param face_count Provide the number of faces. This is faster because it does not need to loop over triangles.
    * @param resource A resource locator for locating resource
    * @param scale Scale the mesh
+   * @param normals A vector of normals for the vertices (optional)
+   * @param vertex_colors A vector of colors (RGBA) for the vertices (optional)
+   * @param mesh_material A MeshMaterial describing the color and material properties of the mesh (optional)
+   * @param mesh_textures A vector of MeshTexture to apply to the mesh (optional)
    */
   ConvexMesh(std::shared_ptr<const tesseract_common::VectorVector3d> vertices,
              std::shared_ptr<const Eigen::VectorXi> faces,
              int face_count,
              tesseract_common::Resource::Ptr resource = nullptr,
-             Eigen::Vector3d scale = Eigen::Vector3d(1, 1, 1))
+             Eigen::Vector3d scale = Eigen::Vector3d(1, 1, 1),
+             std::shared_ptr<const tesseract_common::VectorVector3d> normals = nullptr,
+             std::shared_ptr<const tesseract_common::VectorVector4d> vertex_colors = nullptr,
+             MeshMaterial::Ptr mesh_material = nullptr,
+             std::shared_ptr<const std::vector<MeshTexture::Ptr>> mesh_textures = nullptr)
     : Geometry(GeometryType::CONVEX_MESH)
     , vertices_(std::move(vertices))
     , faces_(std::move(faces))
     , face_count_(face_count)
     , resource_(std::move(resource))
     , scale_(std::move(scale))
+    , normals_(std::move(normals))
+    , vertex_colors_(std::move(vertex_colors))
+    , mesh_material_(std::move(mesh_material))
+    , mesh_textures_(std::move(mesh_textures))
   {
     vertice_count_ = static_cast<int>(vertices_->size());
   }
 
-#endif  // SWIG
-
-#ifdef SWIG
-  %extend
-  {
-    ConvexMesh(const tesseract_common::VectorVector3d& vertices,
-       const Eigen::VectorXi& triangles,
-       tesseract_common::Resource::Ptr resource = nullptr,
-       Eigen::Vector3d scale = Eigen::Vector3d(1, 1, 1))
-    {
-      return new tesseract_geometry::ConvexMesh(std::make_shared<tesseract_common::VectorVector3d>(vertices),
-        std::make_shared<Eigen::VectorXi>(triangles),
-        resource, scale);
-    }
-  }
-#endif  // SWIG
-
   ~ConvexMesh() override = default;
   ConvexMesh(const ConvexMesh&) = delete;
   ConvexMesh& operator=(const ConvexMesh&) = delete;
   ConvexMesh(ConvexMesh&&) = delete;
   ConvexMesh& operator=(ConvexMesh&&) = delete;
 
-#ifndef SWIG
   /**
    * @brief Get convex mesh vertices
    * @return A vector of vertices
@@ -149,17 +151,6 @@ class ConvexMesh : public Geometry
    */
   const std::shared_ptr<const Eigen::VectorXi>& getFaces() const { return faces_; }
 
-#else   // SWIG
-  // clang-format off
-  %extend
-  {
-    tesseract_common::VectorVector3d getVertices() { return *$self->getVertices(); }
-
-    Eigen::VectorXi getFaces() { return *$self->getFaces(); }
-  }
-  // clang-format on
-#endif  // SWIG
-
   /**
    * @brief Get vertice count
    * @return Number of vertices
@@ -187,6 +178,46 @@ class ConvexMesh : public Geometry
    */
   const Eigen::Vector3d& getScale() const { return scale_; }
 
+  /**
+   * @brief Get the vertice normal vectors
+   *
+   * Optional, may be nullptr
+   *
+   * @return The vertice normal vector
+   */
+  std::shared_ptr<const tesseract_common::VectorVector3d> getNormals() const { return normals_; }
+
+  /**
+   * @brief Get the vertex colors
+   *
+   * Optional, may be nullptr
+   *
+   * @return Vertex colors
+   */
+  std::shared_ptr<const tesseract_common::VectorVector4d> getVertexColors() const { return vertex_colors_; }
+
+  /**
+   * @brief Get material data extracted from the mesh file
+   *
+   * Mesh files contain material information. The mesh parser will
+   * extract the material information and store it in a MeshMaterial structure.
+   *
+   * @return The MeshMaterial data extracted from mesh file
+   */
+  MeshMaterial::ConstPtr getMaterial() const { return mesh_material_; }
+
+  /**
+   * @brief Get textures extracted from the mesh file
+   *
+   * Mesh files contain (or reference) image files that form textures on the surface
+   * of the mesh. UV coordinates specify how the image is applied to the mesh. The
+   * MeshTexture structure contains a resource to the image, and the UV coordinates.
+   * Currently only jpg and png image formats are supported.
+   *
+   * @return Vector of mesh textures
+   */
+  std::shared_ptr<const std::vector<MeshTexture::Ptr>> getTextures() const { return mesh_textures_; }
+
   Geometry::Ptr clone() const override
   {
     return std::make_shared<ConvexMesh>(vertices_, faces_, face_count_, resource_, scale_);
@@ -200,6 +231,10 @@ class ConvexMesh : public Geometry
   int face_count_;
   tesseract_common::Resource::Ptr resource_;
   Eigen::Vector3d scale_;
+  std::shared_ptr<const tesseract_common::VectorVector3d> normals_;
+  std::shared_ptr<const tesseract_common::VectorVector4d> vertex_colors_;
+  MeshMaterial::Ptr mesh_material_;
+  std::shared_ptr<const std::vector<MeshTexture::Ptr>> mesh_textures_;
 };
 }  // namespace tesseract_geometry
 #endif