[software] convertMesh: Use Texturing to load and export mesh/material

This allows `convertMesh` to convert textured or not textured mesh.
Mesh can now be converted at any steps of the MVS pipeline (Meshing, MeshFiltering and now Texturing).
Add options for texture files copy and flip normals.
Update compatible mesh files list.

Author: gregoire-dl

src/software/convert/main_convertMesh.cpp

@@ -22,7 +22,7 @@
 
 // These constants define the current software version.
 // They must be updated when the command line is changed.
-#define ALICEVISION_SOFTWARE_VERSION_MAJOR 1
+#define ALICEVISION_SOFTWARE_VERSION_MAJOR 2
 #define ALICEVISION_SOFTWARE_VERSION_MINOR 0
 
 using namespace aliceVision;
@@ -36,25 +36,39 @@ namespace fs = std::filesystem;
 int aliceVision_main(int argc, char** argv)
 {
     // timer initialization
-
     system::Timer timer;
 
-    // command-line parameters
+    // command-line required parameters 
     std::string inputMeshPath;
-    std::string outputFilePath;
+    std::string outputMeshPath;
+
+    // command-line optional parameters 
+    bool flipNormals = false;
+    bool copyTextures = true;
 
     // clang-format off
     po::options_description requiredParams("Required parameters");
     requiredParams.add_options()
-        ("inputMesh", po::value<std::string>(&inputMeshPath)->default_value(inputMeshPath),
-         "Mesh file path (*.obj, *.mesh, *.meshb, *.ply, *.off, *.stl).")
-        ("output,o", po::value<std::string>(&outputFilePath)->default_value(outputFilePath),
-         "Output file path for the new mesh file (*.obj, *.mesh, *.meshb, *.ply, *.off, *.stl).");
+        ("inputMesh", po::value<std::string>(&inputMeshPath)->required(),
+         "Mesh file path (*.obj, *.fbx, *.gltf, *.glb, *.stl, *.ply).")
+        ("output,o", po::value<std::string>(&outputMeshPath)->required(),
+         "Output file path (*.obj, *.fbx, *.gltf, *.glb, *.stl *.ply).");
+
+    po::options_description optionalParams("Optional parameters");
+    optionalParams.add_options()
+        ("flipNormals", po::value<bool>(&flipNormals)->default_value(flipNormals),
+         "Flip face normals. It can be needed as it depends on the vertices order in triangles and the "
+         "convention changes from one software to another.")
+        ("copyTextures", po::value<bool>(&copyTextures)->default_value(copyTextures),
+         "Copy input mesh texture files to the output mesh folder.");
     // clang-format on
 
     CmdLine cmdline("The program allows to convert a mesh to another mesh format.\n"
                     "AliceVision convertMesh");
+
     cmdline.add(requiredParams);
+    cmdline.add(optionalParams);
+
     if (!cmdline.execute(argc, argv))
     {
         return EXIT_FAILURE;
@@ -68,15 +82,15 @@ int aliceVision_main(int argc, char** argv)
     }
 
     // check output file path
-    if (outputFilePath.empty())
+    if (outputMeshPath.empty())
     {
         ALICEVISION_LOG_ERROR("Invalid output");
         return EXIT_FAILURE;
     }
 
     // ensure output folder exists
     {
-        const std::string outputFolderPart = fs::path(outputFilePath).parent_path().string();
+        const std::string outputFolderPart = fs::path(outputMeshPath).parent_path().string();
 
         if (!outputFolderPart.empty() && !utils::exists(outputFolderPart))
         {
@@ -89,26 +103,61 @@ int aliceVision_main(int argc, char** argv)
     }
 
     // load input mesh
+    ALICEVISION_LOG_INFO("Loading input mesh.");
     mesh::Texturing texturing;
-    texturing.loadWithAtlas(inputMeshPath);
+    texturing.loadWithMaterial(inputMeshPath, flipNormals);
     mesh::Mesh* inputMesh = texturing.mesh;
 
+    // check if mesh is loaded
     if (!inputMesh)
     {
         ALICEVISION_LOG_ERROR("Unable to read input mesh from the file: " << inputMeshPath);
         return EXIT_FAILURE;
     }
 
+    // check if mesh is not empty
     if (inputMesh->pts.empty() || inputMesh->tris.empty())
     {
-        ALICEVISION_LOG_ERROR("Error: empty mesh from the file " << inputMeshPath);
+        ALICEVISION_LOG_ERROR("Empty input mesh from the file: " << inputMeshPath);
         ALICEVISION_LOG_ERROR("Input mesh: " << inputMesh->pts.size() << " vertices and " << inputMesh->tris.size() << " facets.");
         return EXIT_FAILURE;
     }
 
+    // copy textures files from the input mesh folder to the output mesh folder
+    if (copyTextures)
+    {
+        const std::string outTypeStr = std::filesystem::path(outputMeshPath).extension().string().substr(1);
+        const mesh::EFileType outType = mesh::EFileType_stringToEnum(outTypeStr);
+
+        // only copy textures for mesh formats that support textures
+        if (outType == mesh::EFileType::OBJ || 
+            outType == mesh::EFileType::FBX || 
+            outType == mesh::EFileType::GLTF || 
+            outType == mesh::EFileType::GLB)
+        {
+            std::vector<std::string> texturePaths;
+            texturing.material.getAllTexturePaths(texturePaths);
+
+            for (const auto& texturePath : texturePaths)
+            {
+                ALICEVISION_LOG_DEBUG("Copying texture file: " << texturePath);
+
+                const fs::path srcPath = fs::path(inputMeshPath).parent_path() / texturePath;
+                const fs::path dstPath = fs::path(outputMeshPath).parent_path() / texturePath;
+
+                fs::copy(srcPath, dstPath);
+            }
+        }
+    }
+    
     // save output mesh
-    ALICEVISION_LOG_INFO("Convert mesh.");
-    inputMesh->save(outputFilePath);
+    ALICEVISION_LOG_INFO("Saving output mesh.");
+    {
+        const auto outPath = std::filesystem::path(outputMeshPath);
+        const mesh::EFileType outFileType = mesh::EFileType_stringToEnum(outPath.extension().string().substr(1));
+
+        texturing.saveAs(outPath.parent_path().string(), outPath.stem().string(), outFileType);
+    }
 
     ALICEVISION_LOG_INFO("Task done in (s): " + std::to_string(timer.elapsed()));