CURA-12810 Make the multi-material progress reporting aware of multiple meshes (#2260)

Author: HellAholic

include/MeshMaterialSplitter.h

@@ -15,10 +15,9 @@ namespace MeshMaterialSplitter
 
 /*!
  * Generate a modifier mesh for every extruder other than 0, that has some user-painted texture data
- * @param mesh The mesh being sliced
- * @param meshgroup The group to add the modifier meshes to
+ * @param meshgroup The group to take the sliced meshes from and add the modifier meshes to
  */
-void makeMaterialModifierMeshes(const Mesh& mesh, MeshGroup* meshgroup);
+void makeMaterialModifierMeshes(MeshGroup* meshgroup);
 
 } // namespace MeshMaterialSplitter
 

src/FffPolygonGenerator.cpp

@@ -62,11 +62,7 @@ namespace cura
 
 bool FffPolygonGenerator::generateAreas(SliceDataStorage& storage, MeshGroup* meshgroup, TimeKeeper& timeKeeper)
 {
-    std::vector<Mesh> initial_meshes = meshgroup->meshes; // Make a copy, because splitting is going to insert new meshes
-    for (const Mesh& mesh : initial_meshes)
-    {
-        MeshMaterialSplitter::makeMaterialModifierMeshes(mesh, meshgroup);
-    }
+    MeshMaterialSplitter::makeMaterialModifierMeshes(meshgroup);
 
     if (! sliceModel(meshgroup, timeKeeper, storage))
     {

src/MeshMaterialSplitter.cpp

@@ -6,6 +6,7 @@
 
 #include <boost/unordered/concurrent_flat_map.hpp>
 #include <boost/unordered/concurrent_flat_set.hpp>
+#include <range/v3/numeric/accumulate.hpp>
 #include <range/v3/view/map.hpp>
 #include <spdlog/spdlog.h>
 #include <spdlog/stopwatch.h>
@@ -33,6 +34,18 @@
 namespace cura::MeshMaterialSplitter
 {
 
+/*!
+ * Utility structure that contains pre-calculated data to generate the multi-material modifiers of a mesh
+ */
+struct MeshGeneratorData
+{
+    const Mesh& mesh; //!< The mesh for which a material modifier is to be generated
+    AABB3D bounding_box; //!< The bounding box of the mesh
+    size_t estimated_iterations; //!< The roughly estimated number of voxels-propagation iterations (for progress reporting)
+    coord_t depth; //!< The propagation depth retrieved from the mesh settings
+    coord_t resolution; //!< The points cloud resolution retrieved from the mesh settings
+};
+
 /*!
  * Utility structure to store values in a map that are grouped by unique z-height and extruder number combinations
  */
@@ -525,21 +538,25 @@ void findBoundaryVoxels(boost::concurrent_flat_set<VoxelGrid::LocalCoordinates>&
  * @param texture_data The lookup containing the rasterized texture data
  * @param depth_squared The maximum propagation depth, squared
  * @param mesh_extruder_nr The main mesh extruder number
+ * @param delta_iterations The number of already processed iterations over the total, for progress reporting
+ * @param total_estimated_iterations The total number of iterations to be processed, for progress reporting
  */
 void propagateVoxels(
     VoxelGrid& voxel_grid,
     boost::concurrent_flat_set<VoxelGrid::LocalCoordinates>& evaluated_voxels,
-    const coord_t estimated_iterations,
+    const size_t estimated_iterations,
     const std::vector<Shape>& sliced_mesh,
     const SpatialLookup& texture_data,
     const coord_t depth_squared,
-    const uint8_t mesh_extruder_nr)
+    const uint8_t mesh_extruder_nr,
+    const size_t delta_iterations,
+    const size_t total_estimated_iterations)
 {
-    uint32_t iteration = 0;
+    size_t iteration = 0;
 
     while (! evaluated_voxels.empty())
     {
-        Progress::messageProgress(Progress::Stage::SPLIT_MULTIMATERIAL, iteration, estimated_iterations);
+        Progress::messageProgress(Progress::Stage::SPLIT_MULTIMATERIAL, std::min(iteration, estimated_iterations) + delta_iterations, total_estimated_iterations);
 
         // Make the list of new voxels to be evaluated, based on which were evaluated before
         spdlog::debug("Finding voxels around {} voxels for iteration {}", evaluated_voxels.size(), iteration);
@@ -560,29 +577,30 @@ void propagateVoxels(
 
 /*!
  * Generate a modifier mesh for every extruder other than 0, that has some user-painted texture data
- * @param mesh The mesh being sliced
+ * @param mesh_data The generation data for the mesh to be processed
  * @param texture_data_provider The provider containing the texture painted data
+ * @param delta_iterations The number of already processed iterations over the total, for progress reporting
+ * @param total_estimated_iterations The total number of iterations to be processed, for progress reporting
  * @return A list of modifier meshes to be added to the slicing process
  */
-std::vector<Mesh> makeModifierMeshes(const Mesh& mesh, const std::shared_ptr<TextureDataProvider>& texture_data_provider)
+std::vector<Mesh> makeModifierMeshes(
+    const MeshGeneratorData& mesh_data,
+    const std::shared_ptr<TextureDataProvider>& texture_data_provider,
+    const size_t delta_iterations,
+    const size_t total_estimated_iterations)
 {
-    const Settings& settings = mesh.settings_;
+    const Settings& settings = mesh_data.mesh.settings_;
     const uint8_t mesh_extruder_nr = static_cast<uint8_t>(settings.get<size_t>("extruder_nr"));
 
     // Fill a first voxel grid by rasterizing the triangles of the mesh in 3D, and assign the extruders according to the texture. This way we can later evaluate which extruder
     // to assign any point in 3D space just by finding the closest outside point and see what extruder it is assigned to.
     spdlog::debug("Fill original voxels based on texture data");
-    auto resolution = settings.get<coord_t>("multi_material_paint_resolution");
-    AABB3D bounding_box;
-    for (const MeshVertex& vertex : mesh.vertices_)
-    {
-        bounding_box.include(vertex.p_);
-    }
-    bounding_box.expand(resolution * 8);
+    AABB3D bounding_box = mesh_data.bounding_box;
+    bounding_box.expand(mesh_data.resolution * 8);
 
     // Create the voxel grid and initially fill it with the rasterized mesh triangles, which will be used as spatial reference for the texture data
-    VoxelGrid voxel_grid(bounding_box, resolution);
-    if (! makeVoxelGridFromTexture(mesh, texture_data_provider, voxel_grid, mesh_extruder_nr))
+    VoxelGrid voxel_grid(bounding_box, mesh_data.resolution);
+    if (! makeVoxelGridFromTexture(mesh_data.mesh, texture_data_provider, voxel_grid, mesh_extruder_nr))
     {
         // Texture is filled with the main extruder, don't bother doing anything
         return {};
@@ -591,11 +609,10 @@ std::vector<Mesh> makeModifierMeshes(const Mesh& mesh, const std::shared_ptr<Tex
     spdlog::debug("Prepare spatial lookup for texture data");
     const SpatialLookup texture_data = SpatialLookup::makeSpatialLookupFromVoxelGrid(voxel_grid);
 
-    const auto depth = settings.get<coord_t>("multi_material_paint_depth");
-    const coord_t depth_squared = depth * depth;
+    const coord_t depth_squared = mesh_data.depth * mesh_data.depth;
 
     // Create a slice of the mesh so that we can quickly check for points insideness
-    const std::vector<Shape> sliced_mesh = sliceMesh(mesh, voxel_grid);
+    const std::vector<Shape> sliced_mesh = sliceMesh(mesh_data.mesh, voxel_grid);
 
     spdlog::debug("Get initially filled voxels");
     boost::concurrent_flat_set<VoxelGrid::LocalCoordinates> previously_evaluated_voxels;
@@ -608,35 +625,92 @@ std::vector<Mesh> makeModifierMeshes(const Mesh& mesh, const std::shared_ptr<Tex
             };
         });
 
-    // Make a rough estimation of the max number of iterations, by calculating how deep we may propagate inside the mesh
-    const double bounding_box_max_depth = std::max({ bounding_box.spanX() / 2.0, bounding_box.spanY() / 2.0, bounding_box.spanZ() / 2.0 });
-    const double estimated_min_depth = std::min(static_cast<double>(depth), bounding_box_max_depth);
-    const coord_t estimated_iterations = estimated_min_depth / resolution;
-    spdlog::debug("Estimated {} iterations", estimated_iterations);
-
-    propagateVoxels(voxel_grid, previously_evaluated_voxels, estimated_iterations, sliced_mesh, texture_data, depth_squared, mesh_extruder_nr);
+    propagateVoxels(
+        voxel_grid,
+        previously_evaluated_voxels,
+        mesh_data.estimated_iterations,
+        sliced_mesh,
+        texture_data,
+        depth_squared,
+        mesh_extruder_nr,
+        delta_iterations,
+        total_estimated_iterations);
 
     return makeMeshesFromVoxelsGrid(voxel_grid, mesh_extruder_nr);
 }
 
-void makeMaterialModifierMeshes(const Mesh& mesh, MeshGroup* meshgroup)
+/*!
+ * Pre-calculate multi-material mesh generation data for the meshes in the given group
+ * @param meshgroup The group containing the meshes to be processed
+ * @return The list of mesh generation data for meshes that contain relevant information
+ */
+std::vector<MeshGeneratorData> makeInitialMeshesGenerationData(const MeshGroup* meshgroup)
 {
-    if (mesh.texture_ == nullptr || mesh.texture_data_mapping_ == nullptr || ! mesh.texture_data_mapping_->contains("extruder"))
+    std::vector<MeshGeneratorData> result;
+
+    for (const Mesh& mesh : meshgroup->meshes)
     {
-        return;
+        if (mesh.texture_ == nullptr || mesh.texture_data_mapping_ == nullptr || ! mesh.texture_data_mapping_->contains("extruder"))
+        {
+            continue;
+        }
+
+        const Settings& settings = mesh.settings_;
+        MeshGeneratorData mesh_data{ .mesh = mesh,
+                                     .depth = settings.get<coord_t>("multi_material_paint_depth"),
+                                     .resolution = settings.get<coord_t>("multi_material_paint_resolution") };
+
+        for (const MeshVertex& vertex : mesh.vertices_)
+        {
+            mesh_data.bounding_box.include(vertex.p_);
+        }
+
+        // Make a rough estimation of the max number of iterations, by calculating how deep we may propagate inside the mesh
+        const double bounding_box_max_depth = std::max({ mesh_data.bounding_box.spanX() / 2.0, mesh_data.bounding_box.spanY() / 2.0, mesh_data.bounding_box.spanZ() / 2.0 });
+        const double estimated_min_depth = std::min(static_cast<double>(mesh_data.depth), bounding_box_max_depth);
+        mesh_data.estimated_iterations = estimated_min_depth / mesh_data.resolution;
+        spdlog::debug("Estimated {} iterations for {}", mesh_data.estimated_iterations, mesh.mesh_name_);
+
+        result.push_back(mesh_data);
     }
 
-    const spdlog::stopwatch timer;
-    spdlog::info("Start multi-material mesh generation");
+    return result;
+}
 
-    const auto texture_data_provider = std::make_shared<TextureDataProvider>(nullptr, mesh.texture_, mesh.texture_data_mapping_);
+void makeMaterialModifierMeshes(MeshGroup* meshgroup)
+{
+    const std::vector<MeshGeneratorData> mesh_generation_data = makeInitialMeshesGenerationData(meshgroup);
+    size_t delta_iterations = 0;
+    const size_t total_estimated_iterations = ranges::accumulate(
+        mesh_generation_data,
+        0,
+        [](const size_t total_iterations, const MeshGeneratorData& mesh_data)
+        {
+            return total_iterations + mesh_data.estimated_iterations;
+        });
 
-    for (const Mesh& modifier_mesh : makeModifierMeshes(mesh, texture_data_provider))
+    std::vector<Mesh> modifier_meshes;
+    for (const MeshGeneratorData& mesh_data : mesh_generation_data)
     {
-        meshgroup->meshes.push_back(modifier_mesh);
+        const Mesh& mesh = mesh_data.mesh;
+        const spdlog::stopwatch timer;
+        spdlog::info("Start multi-material mesh generation for {}", mesh.mesh_name_);
+
+        const auto texture_data_provider = std::make_shared<TextureDataProvider>(nullptr, mesh.texture_, mesh.texture_data_mapping_);
+        for (const Mesh& modifier_mesh : makeModifierMeshes(mesh_data, texture_data_provider, delta_iterations, total_estimated_iterations))
+        {
+            modifier_meshes.push_back(std::move(modifier_mesh));
+        }
+
+        delta_iterations += mesh_data.estimated_iterations;
+        spdlog::info("Multi-material mesh generation for {} took {} seconds", mesh.mesh_name_, timer.elapsed().count());
     }
 
-    spdlog::info("Multi-material mesh generation took {} seconds", timer.elapsed().count());
+    // Add meshes to group afterwards to avoid re-allocating the meshes in the vector
+    for (Mesh& modifier_mesh : modifier_meshes)
+    {
+        meshgroup->meshes.push_back(std::move(modifier_mesh));
+    }
 }
 
 } // namespace cura::MeshMaterialSplitter