Revert "feat: setting for carveMultipleVolumes (CURA-2712)"

This reverts commit b2d837efde.

src/FffGcodeWriter.cpp

@@ -1077,6 +1077,7 @@ void FffGcodeWriter::addSupportRoofsToGCode(SliceDataStorage& storage, GCodePlan
 
     int skin_extruder_nr = getSettingAsIndex("support_interface_extruder_nr");
     const ExtruderTrain& interface_extr = *storage.meshgroup->getExtruderTrain(skin_extruder_nr);
+    setExtruder_addPrime(storage, gcode_layer, layer_nr, skin_extruder_nr);
 
     EFillMethod pattern = interface_extr.getSettingAsFillMethod("support_interface_pattern");
     int support_line_distance = interface_extr.getSettingInMicrons("support_interface_line_distance");
@@ -1114,11 +1115,6 @@ void FffGcodeWriter::addSupportRoofsToGCode(SliceDataStorage& storage, GCodePlan
     Polygons support_lines;
     infill_comp.generate(support_polygons, support_lines);
 
-    if (support_polygons.size() == 0 && support_lines.size() == 0)
-    {
-        return;
-    }
-    setExtruder_addPrime(storage, gcode_layer, layer_nr, skin_extruder_nr);
     gcode_layer.addPolygonsByOptimizer(support_polygons, &storage.support_skin_config);
     gcode_layer.addLinesByOptimizer(support_lines, &storage.support_skin_config, (pattern == EFillMethod::ZIG_ZAG)? SpaceFillType::PolyLines : SpaceFillType::Lines);
 }

src/FffPolygonGenerator.cpp

@@ -107,7 +107,7 @@ bool FffPolygonGenerator::sliceModel(MeshGroup* meshgroup, TimeKeeper& timeKeepe
     for(unsigned int meshIdx=0; meshIdx < slicerList.size(); meshIdx++)
     {
         Mesh& mesh = storage.meshgroup->meshes[meshIdx];
-        if (mesh.getSettingBoolean("conical_overhang_enabled") && !mesh.getSettingBoolean("anti_overhang_mesh"))
+        if (mesh.getSettingBoolean("conical_overhang_enabled"))
         {
             ConicalOverhang::apply(slicerList[meshIdx], mesh.getSettingInAngleRadians("conical_overhang_angle"), layer_thickness);
         }
@@ -116,53 +116,15 @@ bool FffPolygonGenerator::sliceModel(MeshGroup* meshgroup, TimeKeeper& timeKeepe
     Progress::messageProgressStage(Progress::Stage::PARTS, &timeKeeper);
 
     carveMultipleVolumes(slicerList);
-
-    AreaSupport::handleSupportMeshes(storage, slicerList);
-
     generateMultipleVolumesOverlap(slicerList);
 
-    size_t max_layer_count = 0;
-    for (unsigned int meshIdx = 0; meshIdx < slicerList.size(); meshIdx++)
-    {
-        Mesh& mesh = storage.meshgroup->meshes[meshIdx];
-        Slicer* slicer = slicerList[meshIdx];
-        if (!mesh.getSettingBoolean("anti_overhang_mesh") && !mesh.getSettingBoolean("infill_mesh"))
-        {
-            max_layer_count = std::max(max_layer_count, slicer->layers.size());
-        }
-    }
-    storage.support.supportLayers.resize(max_layer_count);
-
     storage.meshes.reserve(slicerList.size()); // causes there to be no resize in meshes so that the pointers in sliceMeshStorage._config to retraction_config don't get invalidated.
     for (unsigned int meshIdx = 0; meshIdx < slicerList.size(); meshIdx++)
     {
         Slicer* slicer = slicerList[meshIdx];
-        Mesh& mesh = storage.meshgroup->meshes[meshIdx];
-
-        // always make a new SliceMeshStorage, so that they have the same ordering / indexing as meshgroup.meshes
         storage.meshes.emplace_back(&meshgroup->meshes[meshIdx], slicer->layers.size()); // new mesh in storage had settings from the Mesh
         SliceMeshStorage& meshStorage = storage.meshes.back();
-
-        if (mesh.getSettingBoolean("anti_overhang_mesh"))
-        {
-            for (unsigned int layer_nr = 0; layer_nr < slicer->layers.size(); layer_nr++)
-            {
-                SupportLayer& support_layer = storage.support.supportLayers[layer_nr];
-                SlicerLayer& slicer_layer = slicer->layers[layer_nr];
-                support_layer.anti_overhang = support_layer.anti_overhang.unionPolygons(slicer_layer.polygons);
-            }
-            continue;
-        }
-        if (mesh.getSettingBoolean("support_mesh"))
-        {
-            for (unsigned int layer_nr = 0; layer_nr < slicer->layers.size(); layer_nr++)
-            {
-                SupportLayer& support_layer = storage.support.supportLayers[layer_nr];
-                SlicerLayer& slicer_layer = slicer->layers[layer_nr];
-                support_layer.support_mesh.add(slicer_layer.polygons);
-            }
-            continue;
-        }
+        Mesh& mesh = storage.meshgroup->meshes[meshIdx];
 
         createLayerParts(meshStorage, slicer, mesh.getSettingBoolean("meshfix_union_all"), mesh.getSettingBoolean("meshfix_union_all_remove_holes"));
         delete slicerList[meshIdx];
@@ -206,7 +168,7 @@ void FffPolygonGenerator::slices2polygons(SliceDataStorage& storage, TimeKeeper&
     unsigned int slice_layer_count = 0;
     for (SliceMeshStorage& mesh : storage.meshes)
     {
-        if (!mesh.getSettingBoolean("infill_mesh") && !mesh.getSettingBoolean("anti_overhang_mesh"))
+        if (!mesh.getSettingBoolean("infill_mesh"))
         {
             slice_layer_count = std::max<unsigned int>(slice_layer_count, mesh.layers.size());
         }

src/FffProcessor.cpp

@@ -60,7 +60,7 @@ bool FffProcessor::processMeshGroup(MeshGroup* meshgroup)
     bool empty = true;
     for (Mesh& mesh : meshgroup->meshes)
     {
-        if (!mesh.getSettingBoolean("infill_mesh") && !mesh.getSettingBoolean("anti_overhang_mesh"))
+        if (!mesh.getSettingBoolean("infill_mesh"))
         {
             empty = false;
         }

src/multiVolumes.cpp

@@ -9,20 +9,14 @@ void carveMultipleVolumes(std::vector<Slicer*> &volumes)
     for (unsigned int volume_1_idx = 0; volume_1_idx < volumes.size(); volume_1_idx++)
     {
         Slicer& volume_1 = *volumes[volume_1_idx];
-        if (volume_1.mesh->getSettingBoolean("infill_mesh") 
-            || volume_1.mesh->getSettingBoolean("anti_overhang_mesh")
-            || volume_1.mesh->getSettingBoolean("support_mesh")
-            )
+        if (volume_1.mesh->getSettingBoolean("infill_mesh"))
         {
             continue;
         }
         for (unsigned int volume_2_idx = 0; volume_2_idx < volume_1_idx; volume_2_idx++)
         {
             Slicer& volume_2 = *volumes[volume_2_idx];
-            if (volume_2.mesh->getSettingBoolean("infill_mesh")
-                || volume_2.mesh->getSettingBoolean("anti_overhang_mesh")
-                || volume_2.mesh->getSettingBoolean("support_mesh")
-                )
+            if (volume_2.mesh->getSettingBoolean("infill_mesh"))
             {
                 continue;
             }
@@ -54,8 +48,6 @@ void generateMultipleVolumesOverlap(std::vector<Slicer*> &volumes)
     {
         int overlap = volume->mesh->getSettingInMicrons("multiple_mesh_overlap");
         if (volume->mesh->getSettingBoolean("infill_mesh")
-            || volume->mesh->getSettingBoolean("anti_overhang_mesh")
-            || volume->mesh->getSettingBoolean("support_mesh")
             || overlap == 0)
         {
             continue;
@@ -68,8 +60,6 @@ void generateMultipleVolumesOverlap(std::vector<Slicer*> &volumes)
             for (Slicer* other_volume : volumes)
             {
                 if (other_volume->mesh->getSettingBoolean("infill_mesh")
-                    || other_volume->mesh->getSettingBoolean("anti_overhang_mesh")
-                    || other_volume->mesh->getSettingBoolean("support_mesh")
                     || !other_volume->mesh->getAABB().hit(aabb)
                     || other_volume == volume
                 )

src/sliceDataStorage.cpp

@@ -142,7 +142,7 @@ Polygons SliceDataStorage::getLayerOutlines(int layer_nr, bool include_helper_pa
         {
             for (const SliceMeshStorage& mesh : meshes)
             {
-                if (mesh.getSettingBoolean("infill_mesh") || mesh.getSettingBoolean("anti_overhang_mesh"))
+                if (mesh.getSettingBoolean("infill_mesh"))
                 {
                     continue;
                 }

src/sliceDataStorage.h

@@ -125,8 +125,6 @@ class SupportLayer
 public:
     Polygons supportAreas; //!< normal support areas
     Polygons skin; //!< the support areas which are to be printed as denser roofs and/or bottoms. Note that the roof/bottom areas and support areas should be mutually exclusive.
-    Polygons support_mesh; //!< Areas from support meshes
-    Polygons anti_overhang; //!< Areas where no overhang should be detected.
 };
 
 class SupportStorage

src/support.cpp

@@ -11,28 +11,8 @@
 
 namespace cura 
 {
-
-void AreaSupport::handleSupportMeshes(SliceDataStorage& storage, std::vector<Slicer*>& volumes)
-{
-    assert(volumes.size() == storage.meshes.size() && "There should be the same amount of meshes as sliced meshes!");
-    for (unsigned int mesh_idx = 0; mesh_idx < volumes.size(); mesh_idx++)
-    {
-        SliceMeshStorage& mesh = storage.meshes[mesh_idx];
-        if (!mesh.getSettingBoolean("support_mesh"))
-        {
-            continue;
-        }
-
-        Slicer& slicer = *volumes[mesh_idx];
-        for (unsigned int layer_nr = 0; layer_nr < slicer.layers.size(); layer_nr++)
-        {
-            SlicerLayer& slicer_layer = slicer.layers[layer_nr];
-            SupportLayer& support_layer = storage.support.supportLayers[layer_nr];
-//             support_layer.
-        }
-    }
-}
-
+    
+    
 Polygons AreaSupport::join(Polygons& supportLayer_up, Polygons& supportLayer_this, int64_t supportJoinDistance, int64_t smoothing_distance, int max_smoothing_angle, bool conical_support, int64_t conical_support_offset, int64_t conical_smallest_breadth)
 {
     Polygons joined;
@@ -85,32 +65,14 @@ Polygons AreaSupport::join(Polygons& supportLayer_up, Polygons& supportLayer_thi
 
 void AreaSupport::generateSupportAreas(SliceDataStorage& storage, unsigned int layer_count)
 {
-    int max_layer_nr_support_mesh_filled;
-    for (max_layer_nr_support_mesh_filled = storage.support.supportLayers.size() - 1; max_layer_nr_support_mesh_filled >= 0; max_layer_nr_support_mesh_filled--)
-    {
-        const SupportLayer& support_layer = storage.support.supportLayers[max_layer_nr_support_mesh_filled];
-        if (support_layer.supportAreas.size() > 0)
-        {
-            break;
-        }
-    }
-    storage.support.layer_nr_max_filled_layer = std::max(storage.support.layer_nr_max_filled_layer, (int)max_layer_nr_support_mesh_filled);
-    for (int layer_nr = 0; layer_nr < max_layer_nr_support_mesh_filled; layer_nr++)
-    {
-        SupportLayer& support_layer = storage.support.supportLayers[max_layer_nr_support_mesh_filled];
-        support_layer.support_mesh = support_layer.support_mesh.unionPolygons();
-    }
-
     // initialization of supportAreasPerLayer
-    if (layer_count > storage.support.supportLayers.size())
-    { // there might alsready be anti_overhang_area data in the supportLayers
-        storage.support.supportLayers.resize(layer_count);
-    }
-
-    for (unsigned int mesh_idx = 0; mesh_idx < storage.meshes.size(); mesh_idx++)
+    for (unsigned int layer_idx = 0; layer_idx < layer_count ; layer_idx++)
+        storage.support.supportLayers.emplace_back();
+    
+    for(unsigned int mesh_idx = 0; mesh_idx < storage.meshes.size(); mesh_idx++)
     {
         SliceMeshStorage& mesh = storage.meshes[mesh_idx];
-        if (mesh.getSettingBoolean("infill_mesh") || mesh.getSettingBoolean("anti_overhang_mesh"))
+        if (mesh.getSettingBoolean("infill_mesh"))
         {
             continue;
         }
@@ -285,9 +247,8 @@ void AreaSupport::generateSupportAreas(SliceDataStorage& storage, unsigned int m
         { // join with support from layer up                
             supportLayer_this = AreaSupport::join(supportLayer_last, supportLayer_this, join_distance, smoothing_distance, max_smoothing_angle, conical_support, conical_support_offset, conical_smallest_breadth);
         }
-
-        supportLayer_this = supportLayer_this.unionPolygons(storage.support.supportLayers[layer_idx].support_mesh);
-
+        
+        
         // move up from model
         if (layerZdistanceBottom > 0 && layer_idx >= layerZdistanceBottom)
         {
@@ -388,9 +349,6 @@ std::pair<Polygons, Polygons> AreaSupport::computeBasicAndFullOverhang(const Sli
     Polygons supportLayer_supported =  supportLayer_supporter.offset(max_dist_from_lower_layer);
     Polygons basic_overhang = supportLayer_supportee.difference(supportLayer_supported);
 
-    const SupportLayer& support_layer = storage.support.supportLayers[layer_idx];
-    basic_overhang = basic_overhang.difference(support_layer.anti_overhang);
-
 //     Polygons support_extension = basic_overhang.offset(max_dist_from_lower_layer);
 //     support_extension = support_extension.intersection(supportLayer_supported);
 //     support_extension = support_extension.intersection(supportLayer_supportee);
@@ -430,17 +388,12 @@ void AreaSupport::detectOverhangPoints(
                 
                 if (part_poly.size() > 0)
                 {
-                    Polygons part_poly_recomputed = part_poly.difference(storage.support.supportLayers[layer_idx].anti_overhang);
-                    if (part_poly_recomputed.size() == 0)
-                    {
-                        continue;
-                    }
                     if (overhang_points.size() > 0 && overhang_points.back().first == layer_idx)
-                        overhang_points.back().second.push_back(part_poly_recomputed);
+                        overhang_points.back().second.push_back(part_poly);
                     else 
                     {
                         std::vector<Polygons> small_part_polys;
-                        small_part_polys.push_back(part_poly_recomputed);
+                        small_part_polys.push_back(part_poly);
                         overhang_points.emplace_back<std::pair<int, std::vector<Polygons>>>(std::make_pair(layer_idx, small_part_polys));
                     }
                 }

src/support.h

@@ -5,19 +5,11 @@
 #include "sliceDataStorage.h"
 #include "MeshGroup.h"
 #include "commandSocket.h"
-#include "slicer.h"
 
 namespace cura {
 
 class AreaSupport {
 public:
-    /*!
-     * Move support mesh from slicer data into the support storage
-     * 
-     * \param[out] storage Where to store the support areas
-     * \param volumes All sliced volumes in the meshgroup
-     */
-    static void handleSupportMeshes(SliceDataStorage& storage, std::vector<Slicer*>& volumes);
 
     /*!
      * Generate the support areas and support skin areas for all models.
@@ -25,6 +17,7 @@ public:
      * \param layer_count total number of layers
      */
     static void generateSupportAreas(SliceDataStorage& storage, unsigned int layer_count);
+        
 private:
     /*!
      * Generate support polygons over all layers for one object.