Generate NormalMaps and HeightMaps

.gitignore

@@ -1,5 +1,6 @@
 # temporary files
 *~
+.nfs*
 .*.swp # vim
 *.flc # xemacs
 .DS_Store # MacOS

src/aliceVision/fuseCut/DelaunayGraphCut.cpp

@@ -3271,7 +3271,7 @@ void DelaunayGraphCut::voteFullEmptyScore(const StaticVector<int>& cams, const s
         if(false)
         {
             std::unique_ptr<mesh::Mesh> meshf(createTetrahedralMesh(false, 0.9f, [](const fuseCut::GC_cellInfo& c) { return c.emptinessScore; }));
-            meshf->saveToObj(folderName + "tetrahedralMesh_beforeForceTEdge_emptiness.obj");
+            meshf->save(folderName + "tetrahedralMesh_beforeForceTEdge_emptiness");
         }
 
         if(forceTEdge)
@@ -3789,47 +3789,47 @@ void DelaunayGraphCut::exportDebugMesh(const std::string& filename, const Point3
     }
 
     const std::string tempDirPath = boost::filesystem::temp_directory_path().generic_string();
-    mesh->saveToObj(tempDirPath + "/" + filename + ".obj");
-    meshf->saveToObj(tempDirPath + "/" + filename + "Filtered.obj");
+    mesh->save(tempDirPath + "/" + filename);
+    meshf->save(tempDirPath + "/" + filename);
 }
 
 void DelaunayGraphCut::exportFullScoreMeshs(const std::string& outputFolder, const std::string& name) const
 {
-    const std::string nameExt = (name.empty() ? "" : "_" + name) + ".obj";
+    const std::string nameExt = (name.empty() ? "" : "_" + name);
     {
         std::unique_ptr<mesh::Mesh> meshEmptiness(
             createTetrahedralMesh(false, 0.999f, [](const GC_cellInfo& c) { return c.emptinessScore; }));
-        meshEmptiness->saveToObj(outputFolder + "/mesh_emptiness" + nameExt);
+        meshEmptiness->save(outputFolder + "/mesh_emptiness" + nameExt);
     }
     {
         std::unique_ptr<mesh::Mesh> meshFullness(
             createTetrahedralMesh(false, 0.999f, [](const GC_cellInfo& c) { return c.fullnessScore; }));
-        meshFullness->saveToObj(outputFolder + "/mesh_fullness" + nameExt);
+        meshFullness->save(outputFolder + "/mesh_fullness" + nameExt);
     }
     {
         std::unique_ptr<mesh::Mesh> meshSWeight(
             createTetrahedralMesh(false, 0.999f, [](const GC_cellInfo& c) { return c.cellSWeight; }));
-        meshSWeight->saveToObj(outputFolder + "/mesh_sWeight" + nameExt);
+        meshSWeight->save(outputFolder + "/mesh_sWeight" + nameExt);
     }
     {
         std::unique_ptr<mesh::Mesh> meshTWeight(
             createTetrahedralMesh(false, 0.999f, [](const GC_cellInfo& c) { return c.cellTWeight; }));
-        meshTWeight->saveToObj(outputFolder + "/mesh_tWeight" + nameExt);
+        meshTWeight->save(outputFolder + "/mesh_tWeight" + nameExt);
     }
     {
         std::unique_ptr<mesh::Mesh> meshOn(
             createTetrahedralMesh(false, 0.999f, [](const GC_cellInfo& c) { return c.on; }));
-        meshOn->saveToObj(outputFolder + "/mesh_on" + nameExt);
+        meshOn->save(outputFolder + "/mesh_on" + nameExt);
     }
     {
         std::unique_ptr<mesh::Mesh> mesh(createTetrahedralMesh(
             false, 0.99f, [](const fuseCut::GC_cellInfo& c) { return c.fullnessScore - c.emptinessScore; }));
-        mesh->saveToObj(outputFolder + "/mesh_fullness-emptiness" + nameExt);
+        mesh->save(outputFolder + "/mesh_fullness-emptiness" + nameExt);
     }
     {
         std::unique_ptr<mesh::Mesh> mesh(createTetrahedralMesh(
             false, 0.99f, [](const fuseCut::GC_cellInfo& c) { return c.cellSWeight - c.cellTWeight; }));
-        mesh->saveToObj(outputFolder + "/mesh_s-t" + nameExt);
+        mesh->save(outputFolder + "/mesh_s-t" + nameExt);
     }
 }
 

src/aliceVision/mesh/Mesh.cpp

@@ -14,6 +14,7 @@
 #include <geogram/points/kd_tree.h>
 
 #include <boost/filesystem.hpp>
+#include <boost/algorithm/string/case_conv.hpp> 
 
 #include <assimp/Importer.hpp>
 #include <assimp/Exporter.hpp>
@@ -36,9 +37,56 @@ Mesh::~Mesh()
 {
 }
 
-void Mesh::saveToObj(const std::string& filename)
+
+std::string EFileType_enumToString(const EFileType meshFileType)
+{
+    switch(meshFileType)
+    {
+        case EFileType::OBJ:
+            return "obj";
+        case EFileType::FBX:
+            return "fbx";
+        case EFileType::STL:
+            return "stl";
+        case EFileType::GLTF:
+            return "gltf";
+    }
+    throw std::out_of_range("Unrecognized EMeshFileType");
+}
+
+EFileType EFileType_stringToEnum(const std::string& meshFileType)
+{
+    std::string m = meshFileType;
+    boost::to_lower(m);
+
+    if(m == "obj")
+        return EFileType::OBJ;
+    if(m == "fbx")
+        return EFileType::FBX;
+    if(m == "stl")
+        return EFileType::STL;
+    if(m == "gltf")
+        return EFileType::GLTF;
+    throw std::out_of_range("Invalid mesh file type " + meshFileType);
+}
+
+std::ostream& operator<<(std::ostream& os, EFileType meshFileType)
+{
+    return os << EFileType_enumToString(meshFileType);
+}
+std::istream& operator>>(std::istream& in, EFileType& meshFileType)
 {
-    ALICEVISION_LOG_INFO("Writing obj and mtl file.");
+    std::string token;
+    in >> token;
+    meshFileType = EFileType_stringToEnum(token);
+    return in;
+}
+
+void Mesh::save(const std::string& filename, EFileType filetype)
+{
+    const std::string filetypeStr = EFileType_enumToString(filetype);
+
+    ALICEVISION_LOG_INFO("Save " << filetypeStr << " mesh file");
 
     aiScene scene;
 
@@ -85,10 +133,26 @@ void Mesh::saveToObj(const std::string& filename)
         }
     }
 
+    std::string formatId;
+    // If gltf, use gltf 2.0
+    if (filetypeStr == "gltf")
+    {
+        formatId = "gltf2";
+    }
+    // If obj, do not use material
+    else if (filetypeStr == "obj")
+    {
+        formatId = "objnomtl";
+    }
+    else
+    {
+        formatId = filetypeStr;
+    }
+
     Assimp::Exporter exporter;
-    exporter.Export(&scene, "objnomtl", filename);
+    exporter.Export(&scene, formatId, filename);
 
-    ALICEVISION_LOG_INFO("Save mesh to obj done.");
+    ALICEVISION_LOG_INFO("Save mesh to " << filetypeStr << " done.");
 }
 
 bool Mesh::loadFromBin(const std::string& binFileName)

src/aliceVision/mesh/Mesh.hpp

@@ -41,6 +41,22 @@ ALICEVISION_BITMASK(EVisibilityRemappingMethod);
 EVisibilityRemappingMethod EVisibilityRemappingMethod_stringToEnum(const std::string& method);
 std::string EVisibilityRemappingMethod_enumToString(EVisibilityRemappingMethod method);
 
+/**
+ * @brief File type available for exporting mesh
+ */
+enum class EFileType
+{
+    OBJ = 0,
+    FBX,
+    GLTF,
+    STL
+};
+
+EFileType EFileType_stringToEnum(const std::string& filetype);
+std::string EFileType_enumToString(const EFileType filetype);
+std::istream& operator>>(std::istream& in, EFileType& meshFileType);
+std::ostream& operator<<(std::ostream& os, EFileType meshFileType);
+
 
 class Mesh
 {
@@ -148,7 +164,7 @@ class Mesh
     Mesh();
     ~Mesh();
 
-    void saveToObj(const std::string& filename);
+    void save(const std::string& filename, EFileType filetype = EFileType::GLTF);
 
     bool loadFromBin(const std::string& binFileName);
     void saveToBin(const std::string& binFileName);

src/aliceVision/mesh/MeshEnergyOpt.cpp

@@ -105,7 +105,7 @@ bool MeshEnergyOpt::optimizeSmooth(float lambda, int niter, StaticVectorBool& pt
         ALICEVISION_LOG_INFO("Optimizing mesh smooth: iteration " << i);
         updateGradientParallel(lambda, LU, RD, ptsCanMove);
         //if(saveDebug)
-        //    saveToObj(folder + "mesh_smoothed_" + std::to_string(i) + ".obj");
+        //    save(folder + "mesh_smoothed_" + std::to_string(i));
     }
 
     return true;