Merge pull request #1 from lanxinger/claude/extend-meshdenoiser-formats-011CUpST8rYKaNpbw1ZrCaFm

Add USD format support (usd, usda, usdc, usdz) using tinyusdz

Author: lanxinger

README.md

@@ -13,8 +13,9 @@ Dependencies are handled per‑platform (OpenMesh sources are bundled by the ups
 MeshSDFilter requires:
 - **Eigen 3.3+** (header-only)
 - **OpenMP** (optional, if compiler supports it)
-- **OpenMesh** sources – the upstream MeshSDFilter CMake builds a static OpenMesh from its bundled `external/OpenMesh` folder.
-- **tinygltf** (header-only, fetched automatically) to allow loading `.gltf` and `.glb` meshes when running `MeshDenoiser`.
+- **OpenMesh 11.0** – fetched and built automatically from source
+- **tinygltf** v2.9.6 (header-only, fetched automatically) to allow loading `.gltf` and `.glb` meshes when running `MeshDenoiser`
+- **tinyusdz** (fetched automatically) to allow loading USD formats (`.usd`, `.usda`, `.usdc`, `.usdz`) when running `MeshDenoiser`
 
 OpenMP is an open standard for shared-memory parallelism; compilers that support it (e.g. GCC, Clang with `libomp`, MSVC) let MeshSDFilter run heavy loops across multiple CPU cores.
 
@@ -93,4 +94,9 @@ MeshSDFilter FilteringOptions.txt input_mesh.ply output_mesh.ply
 MeshDenoiser DenoisingOptions.txt input_mesh.ply output_mesh.ply
 ```
 - A detail-preserving MeshDenoiser preset is in `MeshDenoiserDefaults.txt` (outer iterations 1, lambda 0.15, eta 2.2, mu 0.2, nu 0.25). Copy it to your working folder or pass it directly; raise lambda/eta or the iteration count only if you want stronger smoothing.
-- `MeshDenoiser` accepts OBJ, PLY, OFF, STL, and now `.gltf/.glb` inputs (thanks to tinygltf). If the glTF mesh contains multiple nodes, transforms are applied automatically before filtering.
+- `MeshDenoiser` accepts:
+  - Traditional formats: OBJ, PLY, OFF, STL (via OpenMesh)
+  - glTF formats: `.gltf`, `.glb` (via tinygltf)
+  - USD formats: `.usd`, `.usda`, `.usdc`, `.usdz` (via tinyusdz)
+
+  For glTF and USD files with multiple meshes or transforms, all geometry is combined and transforms are applied automatically before filtering.

cmake/FetchMeshSDFilter.cmake

@@ -25,12 +25,11 @@ if(NOT alicevision_src_POPULATED)
   FetchContent_Populate(alicevision_src)
 endif()
 
-set(_OPENMESH_URL "https://www.graphics.rwth-aachen.de/media/openmesh_static/Releases/10.0/OpenMesh-10.0.0.tar.bz2")
+set(_OPENMESH_URL "https://www.graphics.rwth-aachen.de/media/openmesh_static/Releases/11.0/OpenMesh-11.0.0.tar.gz")
 FetchContent_Declare(
   openmesh
   URL "${_OPENMESH_URL}"
   DOWNLOAD_EXTRACT_TIMESTAMP TRUE
-  URL_HASH SHA256=af22520a474bb6a3b355eb0867449c6b995126f97632d1ee5ff9c7ebd322fedb
 )
 FetchContent_GetProperties(openmesh)
 if(NOT openmesh_POPULATED)
@@ -56,6 +55,23 @@ if(NOT tinygltf_POPULATED)
   FetchContent_Populate(tinygltf)
 endif()
 
+set(_TINYUSDZ_URL "https://github.com/lighttransport/tinyusdz/archive/refs/heads/release.zip")
+
+# TinyUSDZ build options must be set BEFORE FetchContent
+set(TINYUSDZ_PRODUCTION_BUILD ON CACHE BOOL "" FORCE)
+set(TINYUSDZ_WITH_OPENSUBDIV OFF CACHE BOOL "" FORCE)
+set(TINYUSDZ_WITH_AUDIO OFF CACHE BOOL "" FORCE)
+set(TINYUSDZ_WITH_EXR OFF CACHE BOOL "" FORCE)
+set(TINYUSDZ_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+set(TINYUSDZ_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+
+FetchContent_Declare(
+  tinyusdz
+  URL "${_TINYUSDZ_URL}"
+  DOWNLOAD_EXTRACT_TIMESTAMP TRUE
+)
+FetchContent_MakeAvailable(tinyusdz)
+
 set(MESHSD_DIR "${alicevision_src_SOURCE_DIR}/src/dependencies/MeshSDFilter")
 
 if(NOT EXISTS "${MESHSD_DIR}/CMakeLists.txt")
@@ -73,10 +89,16 @@ if(EXISTS "${_override_dir}")
   endforeach()
 endif()
 
+# Add include directories globally before building MeshSDFilter
+# This ensures tinygltf and tinyusdz headers are available during compilation
+include_directories("${tinygltf_SOURCE_DIR}")
+include_directories("${tinyusdz_SOURCE_DIR}/src")
+
 add_subdirectory("${MESHSD_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/MeshSDFilter-build")
 
+# Link tinyusdz to the targets after they're created
 foreach(_mesh_target MeshSDFilter MeshDenoiser)
   if(TARGET ${_mesh_target})
-    target_include_directories(${_mesh_target} PRIVATE "${tinygltf_SOURCE_DIR}")
+    target_link_libraries(${_mesh_target} tinyusdz_static)
   endif()
 endforeach()

overrides/MeshSDFilter/MeshDenoiser.cpp

@@ -52,9 +52,15 @@
 #define TINYGLTF_USE_CPP14
 #include <tiny_gltf.h>
 
+#include "tinyusdz.hh"
+#include "tydra/render-data.hh"
+#include "tydra/scene-access.hh"
+
 namespace
 {
 
+using namespace tinyusdz;  // For tydra namespace access
+
 std::string to_lower_copy(std::string str)
 {
 	std::transform(str.begin(), str.end(), str.begin(), [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
@@ -388,14 +394,180 @@ bool load_gltf_mesh(const std::string &filename, TriMesh &mesh, std::string &war
 	return true;
 }
 
+bool load_usd_mesh(const std::string &filename, TriMesh &mesh, std::string &warning, std::string &error)
+{
+	tinyusdz::Stage stage;
+	std::string warn, err;
+
+	// Load USD file based on extension
+	bool success = false;
+	if(has_extension(filename, ".usdz")){
+		success = tinyusdz::LoadUSDZFromFile(filename, &stage, &warn, &err);
+	}
+	else if(has_extension(filename, ".usdc")){
+		success = tinyusdz::LoadUSDCFromFile(filename, &stage, &warn, &err);
+	}
+	else if(has_extension(filename, ".usda")){
+		success = tinyusdz::LoadUSDAFromFile(filename, &stage, &warn, &err);
+	}
+	else if(has_extension(filename, ".usd")){
+		// Generic .usd extension - auto-detect format (ASCII or binary)
+		success = tinyusdz::LoadUSDFromFile(filename, &stage, &warn, &err);
+	}
+	else{
+		error = "Unsupported USD file extension. Supported: .usd, .usda, .usdc, .usdz";
+		return false;
+	}
+
+	if(!warn.empty()){
+		warning += warn;
+	}
+	if(!err.empty()){
+		error += err;
+	}
+	if(!success){
+		if(error.empty()){
+			error = "Unable to parse USD file.";
+		}
+		return false;
+	}
+
+	// Convert USD stage to RenderScene using Tydra
+	tydra::RenderScene render_scene;
+	tydra::RenderSceneConverter converter;
+	tydra::RenderSceneConverterEnv env(stage);
+
+	if(!converter.ConvertToRenderScene(env, &render_scene)){
+		error = "Failed to convert USD stage to render scene.";
+		return false;
+	}
+
+	if(render_scene.meshes.empty()){
+		error = "No meshes found in USD file.";
+		return false;
+	}
+
+	// Clear and prepare the output mesh
+	mesh.clear();
+	mesh.request_face_normals();
+	mesh.request_vertex_normals();
+
+	// Process all meshes in the render scene
+	for(const auto &render_mesh : render_scene.meshes){
+		if(render_mesh.points.empty()){
+			continue;
+		}
+
+		// Add vertices
+		std::vector<TriMesh::VertexHandle> vertex_handles;
+		vertex_handles.reserve(render_mesh.points.size());
+
+		for(const auto &point : render_mesh.points){
+			TriMesh::Point p(point[0], point[1], point[2]);
+			vertex_handles.push_back(mesh.add_vertex(p));
+		}
+
+		// Determine which indices to use
+		const std::vector<uint32_t> *face_indices = nullptr;
+		const std::vector<uint32_t> *face_counts = nullptr;
+
+		if(!render_mesh.triangulatedFaceVertexIndices.empty()){
+			// Use triangulated indices if available
+			face_indices = &render_mesh.triangulatedFaceVertexIndices;
+			face_counts = &render_mesh.triangulatedFaceVertexCounts;
+		}
+		else{
+			// Use original indices
+			face_indices = &render_mesh.usdFaceVertexIndices;
+			face_counts = &render_mesh.usdFaceVertexCounts;
+		}
+
+		if(face_indices->empty() || face_counts->empty()){
+			continue;
+		}
+
+		// Add faces
+		size_t index_offset = 0;
+		for(uint32_t count : *face_counts){
+			if(count == 3){
+				// Triangle - add directly
+				std::vector<TriMesh::VertexHandle> face_verts;
+				face_verts.reserve(3);
+
+				bool valid = true;
+				for(uint32_t i = 0; i < 3; ++i){
+					uint32_t idx = (*face_indices)[index_offset + i];
+					if(idx >= vertex_handles.size()){
+						valid = false;
+						break;
+					}
+					face_verts.push_back(vertex_handles[idx]);
+				}
+
+				if(valid){
+					mesh.add_face(face_verts);
+				}
+			}
+			else if(count > 3){
+				// Polygon - triangulate by fan method
+				std::vector<uint32_t> poly_indices;
+				poly_indices.reserve(count);
+
+				bool valid = true;
+				for(uint32_t i = 0; i < count; ++i){
+					uint32_t idx = (*face_indices)[index_offset + i];
+					if(idx >= vertex_handles.size()){
+						valid = false;
+						break;
+					}
+					poly_indices.push_back(idx);
+				}
+
+				if(valid){
+					// Simple fan triangulation from first vertex
+					for(uint32_t i = 1; i + 1 < count; ++i){
+						std::vector<TriMesh::VertexHandle> face_verts;
+						face_verts.push_back(vertex_handles[poly_indices[0]]);
+						face_verts.push_back(vertex_handles[poly_indices[i]]);
+						face_verts.push_back(vertex_handles[poly_indices[i + 1]]);
+						mesh.add_face(face_verts);
+					}
+				}
+			}
+
+			index_offset += count;
+		}
+	}
+
+	if(mesh.n_faces() == 0){
+		error = "No valid triangles found in USD mesh.";
+		return false;
+	}
+
+	mesh.garbage_collection();
+	return true;
+}
+
 } // anonymous namespace
 
 
 int main(int argc, char **argv)
 {
 	if(argc != 4)
 	{
-		std::cout << "Usage:\tMeshDenoiser  OPTION_FILE  INPUT_MESH  OUTPUT_MESH" << std::endl;
+		std::cout << "MeshDenoiser - Mesh normal denoising filter" << std::endl;
+		std::cout << std::endl;
+		std::cout << "Usage:  MeshDenoiser  OPTION_FILE  INPUT_MESH  OUTPUT_MESH" << std::endl;
+		std::cout << std::endl;
+		std::cout << "Supported input formats:" << std::endl;
+		std::cout << "  - OBJ, PLY, OFF, STL (via OpenMesh)" << std::endl;
+		std::cout << "  - glTF (.gltf, .glb)" << std::endl;
+		std::cout << "  - USD (.usd, .usda, .usdc, .usdz)" << std::endl;
+		std::cout << std::endl;
+		std::cout << "Example:" << std::endl;
+		std::cout << "  MeshDenoiser options.txt input.obj output.obj" << std::endl;
+		std::cout << "  MeshDenoiser options.txt model.gltf denoised.obj" << std::endl;
+		std::cout << "  MeshDenoiser options.txt scene.usdz clean.ply" << std::endl;
 		return 1;
 	}
 
@@ -411,6 +583,10 @@ int main(int argc, char **argv)
 	if(has_extension(input_mesh_path, ".gltf") || has_extension(input_mesh_path, ".glb")){
 		load_success = load_gltf_mesh(input_mesh_path, mesh, warning, error);
 	}
+	else if(has_extension(input_mesh_path, ".usd") || has_extension(input_mesh_path, ".usda") ||
+	        has_extension(input_mesh_path, ".usdc") || has_extension(input_mesh_path, ".usdz")){
+		load_success = load_usd_mesh(input_mesh_path, mesh, warning, error);
+	}
 	else{
 		load_success = OpenMesh::IO::read_mesh(mesh, input_mesh_path);
 		if(!load_success){