Only include OpenMP headers if we are actually compiling with OpenMP

Fixes building on OSX with Clang

CMakeLists.txt

@@ -42,6 +42,16 @@ if(NOT APPLE AND NOT WIN32)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libstdc++")
 endif()
 
+option (ENABLE_OPENMP
+    "Use OpenMP for parallel code" ON)
+
+if (ENABLE_OPENMP)
+    FIND_PACKAGE( OpenMP )
+    if( OPENMP_FOUND )
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}" )
+    endif()
+endif()
+
 include_directories(${CMAKE_CURRENT_BINARY_DIR} libs)
 
 add_library(clipper STATIC libs/clipper/clipper.cpp)
@@ -54,16 +64,17 @@ set(engine_SRCS # Except main.cpp.
     src/FffGcodeWriter.cpp
     src/FffPolygonGenerator.cpp
     src/FffProcessor.cpp
-    src/FuzzyWalls.cpp
     src/gcodeExport.cpp
     src/GCodePathConfig.cpp
     src/gcodePlanner.cpp
     src/infill.cpp
     src/WallsComputation.cpp
+    src/layerPart.cpp
     src/LayerPlanBuffer.cpp
     src/MergeInfillLines.cpp
     src/mesh.cpp
     src/MeshGroup.cpp
+    src/multiVolumes.cpp
     src/pathOrderOptimizer.cpp
     src/Preheat.cpp
     src/PrimeTower.cpp
@@ -71,6 +82,7 @@ set(engine_SRCS # Except main.cpp.
     src/skin.cpp
     src/SkirtBrim.cpp
     src/sliceDataStorage.cpp
+    src/slicer.cpp
     src/support.cpp
     src/timeEstimate.cpp
     src/WallsComputation.cpp
@@ -85,18 +97,6 @@ set(engine_SRCS # Except main.cpp.
     src/infill/ZigzagConnectorProcessorNoEndPieces.cpp
     src/infill/SubDivCube.cpp
 
-    src/slicer/LayerPart.cpp
-    src/slicer/MultiVolumes.cpp
-    src/slicer/SlicerLayer.cpp
-    src/slicer/Slicer.cpp
-
-    src/textureProcessing/FaceNormalStorage.cpp
-    src/textureProcessing/Material.cpp
-    src/textureProcessing/MaterialBase.cpp
-    src/textureProcessing/TexturedMesh.cpp
-    src/textureProcessing/TextureBumpMapProcessor.cpp
-    src/textureProcessing/TextureProximityProcessor.cpp
-
     src/pathPlanning/Comb.cpp
     src/pathPlanning/GCodePath.cpp
     src/pathPlanning/LinePolygonsCrossings.cpp

libs/stb/source.txt

@@ -1,5 +0,0 @@
-https://github.com/nothings/stb
-
-Thanks to Sean T. Barrett
-
-license: public domain

src/ConicalOverhang.h

@@ -2,7 +2,7 @@
 #ifndef CONICAL_OVERHANG_H
 #define CONICAL_OVERHANG_H
 
-#include "slicer/Slicer.h"
+#include "slicer.h"
 
 
 namespace cura {

src/FffGcodeWriter.cpp

@@ -6,7 +6,6 @@
 #include "FffProcessor.h"
 #include "progress/Progress.h"
 #include "wallOverlap.h"
-#include "FuzzyWalls.h"
 #include "utils/orderOptimizer.h"
 
 namespace cura
@@ -195,7 +194,17 @@ void FffGcodeWriter::initConfigs(SliceDataStorage& storage)
         mesh.inset0_config.init(mesh.getSettingInMillimetersPerSecond("speed_wall_0"), mesh.getSettingInMillimetersPerSecond("acceleration_wall_0"), mesh.getSettingInMillimetersPerSecond("jerk_wall_0"), mesh.getSettingInMicrons("wall_line_width_0"), mesh.getSettingInPercentage("material_flow"));
         mesh.insetX_config.init(mesh.getSettingInMillimetersPerSecond("speed_wall_x"), mesh.getSettingInMillimetersPerSecond("acceleration_wall_x"), mesh.getSettingInMillimetersPerSecond("jerk_wall_x"), mesh.getSettingInMicrons("wall_line_width_x"), mesh.getSettingInPercentage("material_flow"));
         mesh.skin_config.init(mesh.getSettingInMillimetersPerSecond("speed_topbottom"), mesh.getSettingInMillimetersPerSecond("acceleration_topbottom"), mesh.getSettingInMillimetersPerSecond("jerk_topbottom"), mesh.getSettingInMicrons("skin_line_width"), mesh.getSettingInPercentage("material_flow"));
-    
+
+        // The perimeter gap config follows the skin config, but has a different line width:
+        // wall_line_width_x divided by two because the gaps are between 0 and 1 times the wall line width
+        const int perimeter_gaps_line_width = mesh.getSettingInMicrons("wall_line_width_x") / 2;
+        double perimeter_gaps_speed = mesh.getSettingInMillimetersPerSecond("speed_topbottom");
+        if (mesh.getSettingBoolean("speed_equalize_flow_enabled"))
+        {
+            perimeter_gaps_speed = perimeter_gaps_speed * mesh.getSettingInMicrons("skin_line_width") / perimeter_gaps_line_width;
+        }
+        mesh.perimeter_gap_config.init(perimeter_gaps_speed, mesh.getSettingInMillimetersPerSecond("acceleration_topbottom"), mesh.getSettingInMillimetersPerSecond("jerk_topbottom"), perimeter_gaps_line_width, mesh.getSettingInPercentage("material_flow"));
+
         for (unsigned int idx = 0; idx < MAX_INFILL_COMBINE; idx++)
         {
             mesh.infill_config[idx].init(mesh.getSettingInMillimetersPerSecond("speed_infill"), mesh.getSettingInMillimetersPerSecond("acceleration_infill"), mesh.getSettingInMillimetersPerSecond("jerk_infill"), mesh.getSettingInMicrons("infill_line_width") * (idx + 1), mesh.getSettingInPercentage("material_flow"));
@@ -697,7 +706,7 @@ std::vector<unsigned int> FffGcodeWriter::calculateMeshOrder(SliceDataStorage& s
         SliceMeshStorage& mesh = storage.meshes[mesh_idx];
         if (mesh.getSettingAsIndex("extruder_nr") == extruder_nr)
         {
-            Mesh& mesh_data = *storage.meshgroup->meshes[mesh_idx];
+            Mesh& mesh_data = storage.meshgroup->meshes[mesh_idx];
             Point3 middle = (mesh_data.getAABB().min + mesh_data.getAABB().max) / 2;
             mesh_idx_order_optimizer.addItem(Point(middle.x, middle.y), mesh_idx);
         }
@@ -738,24 +747,9 @@ void FffGcodeWriter::addMeshLayerToGCode_meshSurfaceMode(SliceDataStorage& stora
         polygons.add(layer->parts[partNr].outline);
     }
 
-    PolygonFlowAdjuster* flow_adjuster(nullptr);
-    if (mesh->getSettingBoolean("fuzz_map_enabled") || mesh->getSettingBoolean("magic_fuzzy_skin_enabled"))
-    {
-        FuzzyWalls* fuzzy_processor = new FuzzyWalls(*mesh);
-        flow_adjuster = fuzzy_processor;
-        polygons = fuzzy_processor->makeFuzzy(*mesh, layer_nr, polygons);
-    } else if (mesh->getSettingBoolean("compensate_overlap_0"))
-    {
-        flow_adjuster = new WallOverlapComputation(polygons, mesh->getSettingInMicrons("wall_line_width_0"));
-    }
-
     EZSeamType z_seam_type = mesh->getSettingAsZSeamType("z_seam_type");
     Point z_seam_pos(mesh->getSettingInMicrons("z_seam_x"), mesh->getSettingInMicrons("z_seam_y"));
-    gcode_layer.addPolygonsByOptimizer(polygons, &mesh->inset0_config, flow_adjuster, z_seam_type, z_seam_pos, mesh->getSettingInMicrons("wall_0_wipe_dist"), mesh->getSettingBoolean("magic_spiralize"));
-    if (flow_adjuster)
-    {
-        delete flow_adjuster;
-    }
+    gcode_layer.addPolygonsByOptimizer(polygons, &mesh->inset0_config, nullptr, z_seam_type, z_seam_pos, mesh->getSettingInMicrons("wall_0_wipe_dist"), mesh->getSettingBoolean("magic_spiralize"));
 
     addMeshOpenPolyLinesToGCode(storage, mesh, gcode_layer, layer_nr);
 }
@@ -880,7 +874,9 @@ void FffGcodeWriter::addMeshPartToGCode(SliceDataStorage& storage, SliceMeshStor
         processSingleLayerInfill(gcode_layer, mesh, part, layer_nr, infill_line_distance, infill_overlap, infill_angle);
     }
 
-    EFillMethod skin_pattern = mesh->getSettingAsFillMethod("top_bottom_pattern");
+    EFillMethod skin_pattern = (layer_nr == 0)?
+        mesh->getSettingAsFillMethod("top_bottom_pattern_0") :
+        mesh->getSettingAsFillMethod("top_bottom_pattern");
     int skin_angle = 45;
     if ((skin_pattern == EFillMethod::LINES || skin_pattern == EFillMethod::ZIG_ZAG) && layer_nr & 1)
     {
@@ -1013,7 +1009,7 @@ void FffGcodeWriter::processInsets(GCodePlanner& gcode_layer, SliceMeshStorage*
             { // on the last normal layer first make the outer wall normally and then start a second outer wall from the same hight, but gradually moving upward
                 WallOverlapComputation* wall_overlap_computation(nullptr);
                 int wall_0_wipe_dist(0);
-                gcode_layer.addPolygonsByOptimizer(part.insets[0], &mesh->insetX_config, wall_overlap_computation, EZSeamType::SHORTEST, z_seam_pos, mesh->getSettingInMicrons("wall_0_wipe_dist"), wall_0_wipe_dist);
+                gcode_layer.addPolygonsByOptimizer(part.insets[0], &mesh->insetX_config, wall_overlap_computation, EZSeamType::SHORTEST, z_seam_pos, wall_0_wipe_dist, spiralize);
             }
         }
         int processed_inset_number = -1;
@@ -1026,23 +1022,16 @@ void FffGcodeWriter::processInsets(GCodePlanner& gcode_layer, SliceMeshStorage*
             }
             if (processed_inset_number == 0)
             {
-                Polygons* outer_wall = &part.insets[0];
-                Polygons fuzzy_outer_wall;
-                PolygonFlowAdjuster* flow_adjuster(nullptr);
-                if (mesh->getSettingBoolean("fuzz_map_enabled") || mesh->getSettingBoolean("magic_fuzzy_skin_enabled"))
+                if (!compensate_overlap_0)
                 {
-                    FuzzyWalls* fuzzy_processor = new FuzzyWalls(*mesh);
-                    flow_adjuster = fuzzy_processor;
-                    fuzzy_outer_wall = fuzzy_processor->makeFuzzy(*mesh, layer_nr, *outer_wall);
-                    outer_wall = &fuzzy_outer_wall;
-                } else if (compensate_overlap_0)
-                {
-                    flow_adjuster = new WallOverlapComputation(*outer_wall, mesh->getSettingInMicrons("wall_line_width_0"));
+                    WallOverlapComputation* wall_overlap_computation(nullptr);
+                    gcode_layer.addPolygonsByOptimizer(part.insets[0], &mesh->inset0_config, wall_overlap_computation, z_seam_type, z_seam_pos, mesh->getSettingInMicrons("wall_0_wipe_dist"), spiralize);
                 }
-                gcode_layer.addPolygonsByOptimizer(*outer_wall, &mesh->inset0_config, flow_adjuster, z_seam_type, z_seam_pos, mesh->getSettingInMicrons("wall_0_wipe_dist"), spiralize);
-                if (flow_adjuster)
+                else
                 {
-                    delete flow_adjuster;
+                    Polygons& outer_wall = part.insets[0];
+                    WallOverlapComputation wall_overlap_computation(outer_wall, mesh->getSettingInMicrons("wall_line_width_0"));
+                    gcode_layer.addPolygonsByOptimizer(outer_wall, &mesh->inset0_config, &wall_overlap_computation, z_seam_type, z_seam_pos, mesh->getSettingInMicrons("wall_0_wipe_dist"), spiralize);
                 }
             }
             else
@@ -1067,9 +1056,11 @@ void FffGcodeWriter::processSkinAndPerimeterGaps(GCodePlanner& gcode_layer, Slic
 {
     int64_t z = layer_nr * getSettingInMicrons("layer_height");
     const unsigned int skin_line_width = mesh->skin_config.getLineWidth();
+    const unsigned int perimeter_gaps_line_width = mesh->perimeter_gap_config.getLineWidth();
 
     constexpr int perimeter_gaps_extra_offset = 15; // extra offset so that the perimeter gaps aren't created everywhere due to rounding errors
-    bool fill_perimeter_gaps = mesh->getSettingAsFillPerimeterGapMode("fill_perimeter_gaps") != FillPerimeterGapMode::NOWHERE;
+    bool fill_perimeter_gaps = mesh->getSettingAsFillPerimeterGapMode("fill_perimeter_gaps") != FillPerimeterGapMode::NOWHERE
+                            && !mesh->getSettingBoolean("magic_spiralize");
 
     Point z_seam_pos(0, 0); // not used
     PathOrderOptimizer part_order_optimizer(gcode_layer.getLastPosition(), z_seam_pos, EZSeamType::SHORTEST);
@@ -1087,7 +1078,9 @@ void FffGcodeWriter::processSkinAndPerimeterGaps(GCodePlanner& gcode_layer, Slic
         Polygons skin_polygons;
         Polygons skin_lines;
         
-        EFillMethod pattern = mesh->getSettingAsFillMethod("top_bottom_pattern");
+        EFillMethod pattern = (layer_nr == 0)?
+            mesh->getSettingAsFillMethod("top_bottom_pattern_0") :
+            mesh->getSettingAsFillMethod("top_bottom_pattern");
         int bridge = -1;
         if (layer_nr > 0)
             bridge = bridgeAngle(skin_part.outline, &mesh->layers[layer_nr-1]);
@@ -1139,13 +1132,6 @@ void FffGcodeWriter::processSkinAndPerimeterGaps(GCodePlanner& gcode_layer, Slic
         Infill infill_comp(pattern, *inner_skin_outline, offset_from_inner_skin_outline, skin_line_width, skin_line_width, skin_overlap, skin_angle, z, extra_infill_shift, perimeter_gaps_output);
         infill_comp.generate(skin_polygons, skin_lines);
 
-        if (fill_perimeter_gaps)
-        { // handle perimeter_gaps of skin insets
-            int offset = 0;
-            Infill infill_comp(EFillMethod::LINES, perimeter_gaps, offset, skin_line_width, skin_line_width, skin_overlap, skin_angle, z, extra_infill_shift);
-            infill_comp.generate(skin_polygons, skin_lines);
-        }
-
         gcode_layer.addPolygonsByOptimizer(skin_polygons, &mesh->skin_config);
 
         if (pattern == EFillMethod::GRID || pattern == EFillMethod::LINES || pattern == EFillMethod::TRIANGLES)
@@ -1156,6 +1142,16 @@ void FffGcodeWriter::processSkinAndPerimeterGaps(GCodePlanner& gcode_layer, Slic
         {
             gcode_layer.addLinesByOptimizer(skin_lines, &mesh->skin_config, (pattern == EFillMethod::ZIG_ZAG)? SpaceFillType::PolyLines : SpaceFillType::Lines);
         }
+
+        if (fill_perimeter_gaps)
+        { // handle perimeter_gaps of skin insets
+            Polygons gap_polygons; // will remain empty
+            Polygons gap_lines;
+            int offset = 0;
+            Infill infill_comp(EFillMethod::LINES, perimeter_gaps, offset, perimeter_gaps_line_width, perimeter_gaps_line_width, skin_overlap, skin_angle, z, extra_infill_shift);
+            infill_comp.generate(gap_polygons, gap_lines);
+            gcode_layer.addLinesByOptimizer(gap_lines, &mesh->perimeter_gap_config, SpaceFillType::Lines);
+        }
     }
 
     if (fill_perimeter_gaps)
@@ -1164,10 +1160,6 @@ void FffGcodeWriter::processSkinAndPerimeterGaps(GCodePlanner& gcode_layer, Slic
         int line_width = mesh->inset0_config.getLineWidth();
         for (unsigned int inset_idx = 0; inset_idx < part.insets.size() - 1; inset_idx++)
         {
-            if (inset_idx == 0 && (mesh->getSettingBoolean("fuzz_map_enabled") || mesh->getSettingBoolean("magic_fuzzy_skin_enabled")))
-            {
-                continue;
-            }
             const Polygons outer = part.insets[inset_idx].offset(-1 * line_width / 2 - perimeter_gaps_extra_offset);
             line_width = mesh->insetX_config.getLineWidth();
 
@@ -1175,7 +1167,10 @@ void FffGcodeWriter::processSkinAndPerimeterGaps(GCodePlanner& gcode_layer, Slic
             perimeter_gaps.add(outer.difference(inner));
         }
         { // gap between inner wall and skin/infill
-            if (mesh->getSettingInMicrons("infill_line_distance") > 0 && !mesh->getSettingBoolean("infill_hollow"))
+            if (mesh->getSettingInMicrons("infill_line_distance") > 0
+                && !mesh->getSettingBoolean("infill_hollow")
+                && mesh->getSettingInMicrons("infill_overlap_mm") >= 0
+            )
             {
                 const Polygons outer = part.insets.back().offset(-1 * line_width / 2 - perimeter_gaps_extra_offset);
 
@@ -1184,18 +1179,19 @@ void FffGcodeWriter::processSkinAndPerimeterGaps(GCodePlanner& gcode_layer, Slic
                 {
                     inner.add(skin_part.outline);
                 }
+                inner = inner.unionPolygons();
                 perimeter_gaps.add(outer.difference(inner));
             }
         }
 
-        Polygons skin_polygons; // unused
-        Polygons skin_lines; // soon to be generated gap filler lines
+        Polygons gap_polygons; // unused
+        Polygons gap_lines; // soon to be generated gap filler lines
         int offset = 0;
         int extra_infill_shift = 0;
-        Infill infill_comp(EFillMethod::LINES, perimeter_gaps, offset, skin_line_width, skin_line_width, skin_overlap, skin_angle, z, extra_infill_shift);
-        infill_comp.generate(skin_polygons, skin_lines);
+        Infill infill_comp(EFillMethod::LINES, perimeter_gaps, offset, perimeter_gaps_line_width, perimeter_gaps_line_width, skin_overlap, skin_angle, z, extra_infill_shift);
+        infill_comp.generate(gap_polygons, gap_lines);
 
-        gcode_layer.addLinesByOptimizer(skin_lines, &mesh->skin_config, SpaceFillType::Lines);
+        gcode_layer.addLinesByOptimizer(gap_lines, &mesh->perimeter_gap_config, SpaceFillType::Lines);
     }
 }
 

src/FffGcodeWriter.h

@@ -37,7 +37,7 @@ class FffGcodeWriter : public SettingsMessenger, NoCopy
 {
     friend class FffProcessor; // cause WireFrame2Gcode uses the member [gcode] (TODO)
 private:
-    coord_t max_object_height; //!< The maximal height of all previously sliced meshgroups, used to avoid collision when moving to the next meshgroup to print.
+    int max_object_height; //!< The maximal height of all previously sliced meshgroups, used to avoid collision when moving to the next meshgroup to print.
 
     /*
      * Buffer for all layer plans (of type GCodePlanner)

src/FffPolygonGenerator.cpp

@@ -2,19 +2,20 @@
 
 #include <algorithm>
 #include <map> // multimap (ordered map allowing duplicate keys)
-#include <functional> // function
+
+#ifdef _OPENMP
+    #include <omp.h>"
+#endif
 
 #include "utils/math.h"
-#include "slicer/Slicer.h"
 #include "utils/algorithm.h"
+#include "slicer.h"
 #include "utils/gettime.h"
 #include "utils/logoutput.h"
 #include "MeshGroup.h"
 #include "support.h"
-#include "slicer/MultiVolumes.h"
-#include "slicer/LayerPart.h"
-#include "textureProcessing/TextureBumpMapProcessor.h"
-#include "textureProcessing/TextureProximityProcessor.h"
+#include "multiVolumes.h"
+#include "layerPart.h"
 #include "WallsComputation.h"
 #include "SkirtBrim.h"
 #include "skin.h"
@@ -88,28 +89,11 @@ bool FffPolygonGenerator::sliceModel(MeshGroup* meshgroup, TimeKeeper& timeKeepe
         return true; //This is NOT an error state!
     }
 
-    
-    storage.meshes.reserve(meshgroup->meshes.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 < meshgroup->meshes.size(); meshIdx++)
-    {
-        // always make a new SliceMeshStorage, so that they have the same ordering / indexing as meshgroup.meshes
-        // even make a mesh for a support mesh, which doesn't introduce any parts.
-        storage.meshes.emplace_back(meshgroup->meshes[meshIdx], slice_layer_count); // new mesh in storage had settings from the Mes
-    }
-    // ^ needs to be set already for fuzzy wall texture map processing
-
     std::vector<Slicer*> slicerList;
     for(unsigned int mesh_idx = 0; mesh_idx < meshgroup->meshes.size(); mesh_idx++)
     {
-        Mesh& mesh = *meshgroup->meshes[mesh_idx];
-        if (mesh.getSettingBoolean("fuzz_map_enabled"))
-        {
-            TextureProximityProcessor::Settings texture_proximity_processor_settings(mesh.getSettingInMicrons("wall_line_width_0"));
-            storage.meshes[mesh_idx].texture_proximity_processor = new TextureProximityProcessor(texture_proximity_processor_settings, slice_layer_count);
-        }
-        bool keep_open_polylines = mesh.getSettingBoolean("meshfix_keep_open_polygons");
-        bool extensive_stitching = mesh.getSettingBoolean("meshfix_extensive_stitching");
-        Slicer* slicer = new Slicer(&mesh, initial_slice_z, layer_thickness, slice_layer_count, keep_open_polylines, extensive_stitching, storage.meshes[mesh_idx].texture_proximity_processor);
+        Mesh& mesh = meshgroup->meshes[mesh_idx];
+        Slicer* slicer = new Slicer(&mesh, initial_slice_z, layer_thickness, slice_layer_count, mesh.getSettingBoolean("meshfix_keep_open_polygons"), mesh.getSettingBoolean("meshfix_extensive_stitching"));
         slicerList.push_back(slicer);
         /*
         for(SlicerLayer& layer : slicer->layers)
@@ -127,7 +111,7 @@ bool FffPolygonGenerator::sliceModel(MeshGroup* meshgroup, TimeKeeper& timeKeepe
 
     for(unsigned int meshIdx=0; meshIdx < slicerList.size(); meshIdx++)
     {
-        Mesh& mesh = *storage.meshgroup->meshes[meshIdx];
+        Mesh& mesh = storage.meshgroup->meshes[meshIdx];
         if (mesh.getSettingBoolean("conical_overhang_enabled") && !mesh.getSettingBoolean("anti_overhang_mesh"))
         {
             ConicalOverhang::apply(slicerList[meshIdx], mesh.getSettingInAngleRadians("conical_overhang_angle"), layer_thickness);
@@ -136,7 +120,6 @@ bool FffPolygonGenerator::sliceModel(MeshGroup* meshgroup, TimeKeeper& timeKeepe
 
     Progress::messageProgressStage(Progress::Stage::PARTS, &timeKeeper);
 
-
     if (storage.getSettingBoolean("carve_multiple_volumes"))
     {
         carveMultipleVolumes(slicerList, storage.getSettingBoolean("alternate_carve_order"));
@@ -146,7 +129,7 @@ bool FffPolygonGenerator::sliceModel(MeshGroup* meshgroup, TimeKeeper& timeKeepe
     storage.print_layer_count = 0;
     for (unsigned int meshIdx = 0; meshIdx < slicerList.size(); meshIdx++)
     {
-        Mesh& mesh = *storage.meshgroup->meshes[meshIdx];
+        Mesh& mesh = storage.meshgroup->meshes[meshIdx];
         Slicer* slicer = slicerList[meshIdx];
         if (!mesh.getSettingBoolean("anti_overhang_mesh") && !mesh.getSettingBoolean("infill_mesh"))
         {
@@ -155,12 +138,15 @@ bool FffPolygonGenerator::sliceModel(MeshGroup* meshgroup, TimeKeeper& timeKeepe
     }
     storage.support.supportLayers.resize(storage.print_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];
+        Mesh& mesh = storage.meshgroup->meshes[meshIdx];
 
-       SliceMeshStorage& meshStorage = storage.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"))
         {
@@ -169,6 +155,10 @@ bool FffPolygonGenerator::sliceModel(MeshGroup* meshgroup, TimeKeeper& timeKeepe
                 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);
+                meshStorage.layers[layer_nr].printZ =
+                    slicer_layer.z
+                    + getSettingInMicrons("layer_height_0")
+                    - initial_slice_z;
             }
             continue;
         }
@@ -179,6 +169,10 @@ bool FffPolygonGenerator::sliceModel(MeshGroup* meshgroup, TimeKeeper& timeKeepe
                 SupportLayer& support_layer = storage.support.supportLayers[layer_nr];
                 SlicerLayer& slicer_layer = slicer->layers[layer_nr];
                 support_layer.support_mesh.add(slicer_layer.polygons);
+                meshStorage.layers[layer_nr].printZ =
+                    slicer_layer.z
+                    + getSettingInMicrons("layer_height_0")
+                    - initial_slice_z;
             }
             continue;
         }
@@ -355,12 +349,24 @@ void FffPolygonGenerator::processBasicWallsSkinInfill(SliceDataStorage& storage,
     
     
     // walls
+    unsigned int processed_layer_count = 0;
+#pragma omp parallel for default(none) shared(mesh_layer_count, mesh, inset_skin_progress_estimate, processed_layer_count) schedule(dynamic)
     for (unsigned int layer_number = 0; layer_number < mesh.layers.size(); layer_number++)
     {
         logDebug("Processing insets for layer %i of %i\n", layer_number, mesh_layer_count);
         processInsets(mesh, layer_number);
-        double progress = inset_skin_progress_estimate.progress(layer_number);
-        Progress::messageProgress(Progress::Stage::INSET_SKIN, progress * 100, 100);
+#ifdef _OPENMP
+        if (omp_get_thread_num() == 0)
+#endif
+        { // progress estimation is done only in one thread so that no two threads message progress at the same time
+            int _processed_layer_count;
+#pragma omp atomic read
+                _processed_layer_count = processed_layer_count;
+            double progress = inset_skin_progress_estimate.progress(_processed_layer_count);
+            Progress::messageProgress(Progress::Stage::INSET_SKIN, progress * 100, 100);
+        }
+#pragma omp atomic
+        processed_layer_count++;
     }
 
     ProgressEstimatorLinear* skin_estimator = new ProgressEstimatorLinear(mesh_layer_count);
@@ -375,8 +381,8 @@ void FffPolygonGenerator::processBasicWallsSkinInfill(SliceDataStorage& storage,
             SliceMeshStorage& other_mesh = storage.meshes[other_mesh_idx];
             if (other_mesh.getSettingBoolean("infill_mesh"))
             {
-                AABB3D aabb = storage.meshgroup->meshes[mesh_idx]->getAABB();
-                AABB3D other_aabb = storage.meshgroup->meshes[other_mesh_idx]->getAABB();
+                AABB3D aabb = storage.meshgroup->meshes[mesh_idx].getAABB();
+                AABB3D other_aabb = storage.meshgroup->meshes[other_mesh_idx].getAABB();
                 if (aabb.hit(other_aabb))
                 {
                     process_infill = true;
@@ -391,16 +397,33 @@ void FffPolygonGenerator::processBasicWallsSkinInfill(SliceDataStorage& storage,
     {
         mesh_max_bottom_layer_count = std::max(mesh_max_bottom_layer_count, mesh.getSettingAsCount("bottom_layers"));
     }
-    for (unsigned int layer_number = 0; layer_number < mesh.layers.size(); layer_number++)
+
+    processed_layer_count = 0;
+#pragma omp parallel default(none) shared(mesh_layer_count, mesh, mesh_max_bottom_layer_count, process_infill, inset_skin_progress_estimate, processed_layer_count)
     {
-        logDebug("Processing skins and infill layer %i of %i\n", layer_number, mesh_layer_count);
-        if (!mesh.getSettingBoolean("magic_spiralize") || static_cast<int>(layer_number) < mesh_max_bottom_layer_count)    //Only generate up/downskin and infill for the first X layers when spiralize is choosen.
+
+#pragma omp for schedule(dynamic)
+        for (unsigned int layer_number = 0; layer_number < mesh.layers.size(); layer_number++)
         {
-            processSkinsAndInfill(mesh, layer_number, process_infill);
+            logDebug("Processing skins and infill layer %i of %i\n", layer_number, mesh_layer_count);
+            if (!mesh.getSettingBoolean("magic_spiralize") || static_cast<int>(layer_number) < mesh_max_bottom_layer_count)    //Only generate up/downskin and infill for the first X layers when spiralize is choosen.
+            {
+                processSkinsAndInfill(mesh, layer_number, process_infill);
+            }
+#ifdef _OPENMP
+            if (omp_get_thread_num() == 0)
+#endif
+            { // progress estimation is done only in one thread so that no two threads message progress at the same time
+                int _processed_layer_count;
+#pragma omp atomic read
+                    _processed_layer_count = processed_layer_count;
+                double progress = inset_skin_progress_estimate.progress(_processed_layer_count);
+                Progress::messageProgress(Progress::Stage::INSET_SKIN, progress * 100, 100);
+            }
+#pragma omp atomic
+                processed_layer_count++;
+        }
         }
-        double progress = inset_skin_progress_estimate.progress(layer_number);
-        Progress::messageProgress(Progress::Stage::INSET_SKIN, progress * 100, 100);
-    }
 }
 
 void FffPolygonGenerator::processInfillMesh(SliceDataStorage& storage, unsigned int mesh_order_idx, std::vector<unsigned int>& mesh_order)
@@ -488,8 +511,20 @@ void FffPolygonGenerator::processDerivedWallsSkinInfill(SliceMeshStorage& mesh)
     // combine infill
     unsigned int combined_infill_layers = std::max(1U, round_divide(mesh.getSettingInMicrons("infill_sparse_thickness"), std::max(getSettingInMicrons("layer_height"), (coord_t)1))); //How many infill layers to combine to obtain the requested sparse thickness.
     combineInfillLayers(mesh,combined_infill_layers);
+
+    // fuzzy skin
+    if (mesh.getSettingBoolean("magic_fuzzy_skin_enabled"))
+    {
+        processFuzzyWalls(mesh);
+    }
 }
 
+/*
+ * This function is executed in a parallel region based on layer_nr.
+ * When modifying make sure any changes does not introduce data races.
+ *
+ * processInsets only reads and writes data for the current layer
+ */
 void FffPolygonGenerator::processInsets(SliceMeshStorage& mesh, unsigned int layer_nr) 
 {
     SliceLayer* layer = &mesh.layers[layer_nr];
@@ -528,11 +563,19 @@ void FffPolygonGenerator::removeEmptyFirstLayers(SliceDataStorage& storage, cons
         for (SliceMeshStorage& mesh : storage.meshes)
         {
             SliceLayer& layer = mesh.layers[layer_idx];
-            if (layer.parts.size() > 0 || (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") != ESurfaceMode::NORMAL && layer.openPolyLines.size() > 0) )
+            if (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") != ESurfaceMode::NORMAL && layer.openPolyLines.size() > 0)
             {
                 layer_is_empty = false;
                 break;
             }
+            for (const SliceLayerPart& part : layer.parts)
+            {
+                if (part.print_outline.size() > 0)
+                {
+                    layer_is_empty = false;
+                    break;
+                }
+            }
         }
         
         if (layer_is_empty) 
@@ -563,8 +606,18 @@ void FffPolygonGenerator::removeEmptyFirstLayers(SliceDataStorage& storage, cons
         support_layers.erase(support_layers.begin(), support_layers.begin() + n_empty_first_layers);
     }
 }
-  
-void FffPolygonGenerator::processSkinsAndInfill(SliceMeshStorage& mesh, unsigned int layer_nr, bool process_infill) 
+
+/*
+ * This function is executed in a parallel region based on layer_nr.
+ * When modifying make sure any changes does not introduce data races.
+ *
+ * generateSkins read (depend on) data from mesh.layers[*].parts[*].insets and write mesh.layers[n].parts[*].skin_parts
+ * generateInfill read mesh.layers[n].parts[*].{insets,skin_parts,boundingBox} and write mesh.layers[n].parts[*].infill_area
+ *
+ * processSkinsAndInfill read (depend on) mesh.layers[*].parts[*].{insets,boundingBox}.
+ *                       write mesh.layers[n].parts[*].{skin_parts,infill_area}.
+ */
+void FffPolygonGenerator::processSkinsAndInfill(SliceMeshStorage& mesh, unsigned int layer_nr, bool process_infill)
 {
     if (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") == ESurfaceMode::SURFACE) 
     { 
@@ -718,4 +771,66 @@ void FffPolygonGenerator::processPlatformAdhesion(SliceDataStorage& storage)
 }
 
 
+void FffPolygonGenerator::processFuzzyWalls(SliceMeshStorage& mesh)
+{
+    if (mesh.getSettingAsCount("wall_line_count") == 0)
+    {
+        return;
+    }
+    int64_t fuzziness = mesh.getSettingInMicrons("magic_fuzzy_skin_thickness");
+    int64_t avg_dist_between_points = mesh.getSettingInMicrons("magic_fuzzy_skin_point_dist");
+    int64_t min_dist_between_points = avg_dist_between_points * 3 / 4; // hardcoded: the point distance may vary between 3/4 and 5/4 the supplied value
+    int64_t range_random_point_dist = avg_dist_between_points / 2;
+    for (unsigned int layer_nr = 0; layer_nr < mesh.layers.size(); layer_nr++)
+    {
+        SliceLayer& layer = mesh.layers[layer_nr];
+        for (SliceLayerPart& part : layer.parts)
+        {
+            Polygons results;
+            Polygons& skin = (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") == ESurfaceMode::SURFACE)? part.outline : part.insets[0];
+            for (PolygonRef poly : skin)
+            {
+                // generate points in between p0 and p1
+                PolygonRef result = results.newPoly();
+                
+                int64_t dist_left_over = rand() % (min_dist_between_points / 2); // the distance to be traversed on the line before making the first new point
+                Point* p0 = &poly.back();
+                for (Point& p1 : poly)
+                { // 'a' is the (next) new point between p0 and p1
+                    Point p0p1 = p1 - *p0;
+                    int64_t p0p1_size = vSize(p0p1);    
+                    int64_t dist_last_point = dist_left_over + p0p1_size * 2; // so that p0p1_size - dist_last_point evaulates to dist_left_over - p0p1_size
+                    for (int64_t p0pa_dist = dist_left_over; p0pa_dist < p0p1_size; p0pa_dist += min_dist_between_points + rand() % range_random_point_dist)
+                    {
+                        int r = rand() % (fuzziness * 2) - fuzziness;
+                        Point perp_to_p0p1 = turn90CCW(p0p1);
+                        Point fuzz = normal(perp_to_p0p1, r);
+                        Point pa = *p0 + normal(p0p1, p0pa_dist) + fuzz;
+                        result.add(pa);
+                        dist_last_point = p0pa_dist;
+                    }
+                    dist_left_over = p0p1_size - dist_last_point;
+                    
+                    p0 = &p1;
+                }
+                while (result.size() < 3 )
+                {
+                    unsigned int point_idx = poly.size() - 2;
+                    result.add(poly[point_idx]);
+                    if (point_idx == 0) { break; }
+                    point_idx--;
+                }
+                if (result.size() < 3)
+                {
+                    result.clear();
+                    for (Point& p : poly)
+                        result.add(p);
+                }
+            }
+            skin = results;
+        }
+    }
+}
+
+
 }//namespace cura

src/FffProcessor.cpp

@@ -38,7 +38,7 @@ std::string FffProcessor::getAllSettingsString(MeshGroup& meshgroup, bool first_
     }
     for (unsigned int mesh_idx = 0; mesh_idx < meshgroup.meshes.size(); mesh_idx++)
     {
-        Mesh& mesh = *meshgroup.meshes[mesh_idx];
+        Mesh& mesh = meshgroup.meshes[mesh_idx];
         sstream << " -e" << mesh.getSettingAsIndex("extruder_nr") << " -l \"" << mesh_idx << "\"" << mesh.getAllLocalSettingsString();
     }
     sstream << "\n";
@@ -58,9 +58,9 @@ bool FffProcessor::processMeshGroup(MeshGroup* meshgroup)
     gcode_writer.setParent(meshgroup);
 
     bool empty = true;
-    for (Mesh* mesh : meshgroup->meshes)
+    for (Mesh& mesh : meshgroup->meshes)
     {
-        if (!mesh->getSettingBoolean("infill_mesh") && !mesh->getSettingBoolean("anti_overhang_mesh"))
+        if (!mesh.getSettingBoolean("infill_mesh") && !mesh.getSettingBoolean("anti_overhang_mesh"))
         {
             empty = false;
         }

src/FuzzyWalls.cpp

@@ -1,218 +0,0 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-#include "FuzzyWalls.h"
-
-#define NORMAL_LENGTH 10000
-
-namespace cura 
-{
-
-FuzzyWalls::FuzzyWalls(const SliceMeshStorage& mesh)
-: settings(&mesh)
-{
-    if (mesh.getSettingBoolean("fuzz_map_enabled"))
-    {
-        assert(mesh.texture_proximity_processor && "texture_proximity_processor should have been initialized");
-        getAmplitude = [&mesh, this](const unsigned int layer_nr, const Point p)
-        {
-            assert(mesh.texture_proximity_processor && "When fuzz_map_enabled there has to be a texture proximity processor!");
-            TextureProximityProcessor& texture_proximity_processor = *mesh.texture_proximity_processor;
-            float color = texture_proximity_processor.getColor(p, layer_nr, settings.color_usage, 0.0); // TODO change default 0.0
-            coord_t ret = color * settings.max_amplitude;
-            return ret;
-        };
-    }
-    else
-    {
-        getAmplitude = [this](const unsigned int layer_nr, const Point p)
-        {
-            return settings.max_amplitude;
-        };
-    }
-}
-
-Polygons FuzzyWalls::makeFuzzy(const SliceMeshStorage& mesh, const unsigned int layer_nr, const Polygons& in)
-{
-    Polygons results;
-    if (in.size() == 0)
-    {
-        return results;
-    }
-
-    flows.reserve(in.size());
-    for (const PolygonRef poly : const_cast<Polygons&>(in))
-    {
-        assert(poly.size() >= 3);
-        // generate points in between p0 and p1
-        PolygonRef result = results.newPoly();
-        flows.emplace_back(); // keep flows aligned with the result
-        flows.back().reserve(poly.size());
-
-        Point p0 = poly[poly.size() - 2];
-        Point p1 = poly.back();
-        for (int p0_idx = poly.size() - 2; p0_idx >= 0; p0_idx--)
-        { // p0 is the last point before p1 which is different from p1
-            p0 = poly[p0_idx];
-        }
-        CarryOver carry_over;
-        carry_over.dist_left_over = (settings.min_dist_between_points + rand() % settings.range_random_point_dist) / 2;
-        carry_over.step_size = carry_over.dist_left_over;
-        carry_over.offset_random = 0.0; // unused in the first iteration since carry_over.step_size = carry_over.dist_left_over; see makeCornerFuzzy
-        carry_over.next_offset_random = static_cast<float>(rand()) / static_cast<float>(RAND_MAX) * 2.0 - 1.0;
-        carry_over.p0p1_perp = turn90CCW(p1 - p0);
-        // 'x' is the previous location from where a randomly offsetted new point between p-1 and p0 was created
-        for (Point p2 : poly)
-        {
-            if (p2 == p1)
-            {
-                continue;
-            }
-            makeCornerFuzzy(layer_nr, p0, p1, p2, carry_over, result);
-            makeSegmentFuzzy(layer_nr, p1, p2, result, carry_over);
-            p0 = p1;
-            p1 = p2;
-        }
-        while (result.size() < 3 )
-        {
-            unsigned int point_idx = poly.size() - 2;
-            result.add(poly[point_idx]);
-            flows.back().push_back(1.0);
-            if (point_idx == 0)
-            {
-                break;
-            }
-            point_idx--;
-        }
-        if (result.size() > 0)
-        { // compute flow of the newly introduced segment
-            const Point p0 = result.back();
-            const Point p1 = result.back();
-            const coord_t length = vSize(p1 - p0);
-            const coord_t pxpa_dist = carry_over.step_size - carry_over.dist_left_over;
-            const float flow_here = (length < 10 || std::abs(length - pxpa_dist) < 5)? 1.0 : std::min(1.0, INT2MM(pxpa_dist) / INT2MM(length));
-            flows.back().push_back(flow_here);
-        }
-        if (result.size() < 3)
-        {
-            result.clear();
-            flows.back().clear();
-            for (const Point& p : poly)
-            {
-                result.add(p);
-                flows.back().push_back(1.0);
-            }
-        }
-        assert(result.size() == flows.back().size());
-    }
-    return results;
-}
-
-void FuzzyWalls::makeCornerFuzzy(const unsigned int layer_nr, const Point p0, const Point p1, const Point p2, const CarryOver carry_over, PolygonRef result)
-{
-    const Point p0p1_perp = carry_over.p0p1_perp;
-    const Point p1p2 = p2 - p1;
-    const Point p1p2_perp = turn90CCW(p1p2);
-    const Point corner_normal = normal(p0p1_perp, NORMAL_LENGTH) + normal(p1p2_perp, NORMAL_LENGTH);
-
-    // x is the last point which was offsetted
-    // a is the next point to be offsetted
-    //
-    //             step_size
-    //        ^^^^^^^^^^^^^^^^^^^^
-    //                   p1pa_dist
-    //        pxp1_dist  ^^^^^^^^^
-    //        ^^^^^^^^^^
-    //                  ┬                    > amplitudes
-    //                  |
-    //                  |
-    //        ┬         |
-    //        ┥         |                    > previous random offset within amplitude
-    //        |         ┥pr       ┬          > corner offset computed by weighted average based on pxp0_dist, p0pa_dist and the amplitudes
-    //        |         |         |
-    // -------x---------p1--------a-------
-    //        |         |         ┥          > next random offset within amplitude
-    //        |         |         ┴
-    //        |         |
-    //        ┴         |
-    //                  |
-    //                  |
-    //                  ┴
-    //
-    // assuming all amplitudes are the same and x, p1, a are on a straight line, pr will also be on a straight line between the previous and next offsetted points
-
-    const coord_t corner_amplitude = getAmplitude(layer_nr, p1);
-    // randFloat = offset / amplitude
-    // offset weighted by relative amplitudes and distance to p0
-    assert(carry_over.step_size > 0);
-    const coord_t pxp1_dist = (carry_over.step_size - carry_over.dist_left_over);
-    assert(pxp1_dist >= 0);
-    const coord_t p1pa_dist = carry_over.dist_left_over;
-    const coord_t offset_contribution_0 = corner_amplitude * pxp1_dist * carry_over.offset_random;
-    const coord_t offset_contribution_2 = corner_amplitude * p1pa_dist * carry_over.next_offset_random;
-    const coord_t offset = (offset_contribution_0 + offset_contribution_2) / carry_over.step_size;
-
-    Point fuzz = normal(corner_normal, offset);
-    Point pr = p1 + fuzz;
-    if (result.size() > 0)
-    { // compute flow of the newly introduced segment
-        const Point last = result.back();
-        const coord_t length = vSize(last - pr);
-        const float flow_here = (length < 10 || std::abs(length - pxp1_dist) < 5)? 1.0 : std::min(1.0, INT2MM(pxp1_dist) / INT2MM(length));
-        // limit the flow to 1.0,
-        // internal corners where the offset is negative could result in such a case,
-        // but it is then better to not cause over extrusion there
-        flows.back().push_back(flow_here);
-    }
-    result.add(pr);
-}
-
-void FuzzyWalls::makeSegmentFuzzy(const unsigned int layer_nr, const Point p0, const Point p1, PolygonRef result, CarryOver& carry_over)
-{
-    // 'a' is the (next) new point between p0 and p1, offsetted from the point
-    // 'x', which is on the line segment p0p1
-    const Point p0p1 = p1 - p0;
-    carry_over.p0p1_perp = turn90CCW(p0p1);
-    const int64_t p0p1_size = vSize(p0p1);
-    coord_t dist_to_prev_point = carry_over.dist_left_over; // distance from the last introduced point to the newly introduced one
-    int64_t dist_last_point = carry_over.dist_left_over - carry_over.step_size; // so that 'carry_over.step_size - (p0p1_size - dist_last_point)' evaulates to 'dist_left_over - p0p1_size'
-    for (int64_t p0pa_dist = carry_over.dist_left_over; p0pa_dist < p0p1_size; p0pa_dist += carry_over.step_size)
-    {
-        const Point px = p0 + normal(p0p1, p0pa_dist);
-        coord_t amplitude = getAmplitude(layer_nr, px);
-        if (amplitude == 0)
-        {
-            amplitude = 1;
-        }
-        carry_over.offset_random = carry_over.next_offset_random;
-        carry_over.next_offset_random = static_cast<float>(rand()) / static_cast<float>(RAND_MAX) * 2.0 - 1.0;
-        const coord_t offset = carry_over.offset_random * amplitude;
-        Point fuzz = normal(carry_over.p0p1_perp, offset);
-        Point pa = px + fuzz;
-        if (result.size() > 0)
-        { // compute flow of the newly introduced segment
-            const Point last = result.back();
-            const coord_t length = vSize(last - pa);
-            const float flow_here = (length < 10 || std::abs(length - dist_to_prev_point) < 5)? 1.0 : std::min(1.0, INT2MM(dist_to_prev_point) / INT2MM(length));
-            flows.back().push_back(flow_here);
-        }
-        result.add(pa);
-        dist_last_point = p0pa_dist;
-        carry_over.step_size = settings.min_dist_between_points + rand() % settings.range_random_point_dist;
-        dist_to_prev_point = carry_over.step_size;
-    }
-    carry_over.dist_left_over = carry_over.step_size - (p0p1_size - dist_last_point);
-    assert(carry_over.dist_left_over >= 0);
-    assert(carry_over.dist_left_over < carry_over.step_size);
-}
-
-float FuzzyWalls::getFlow(const Polygons& from, unsigned int poly_idx, unsigned int from_point_idx, unsigned int to_point_idx)
-{
-    assert(from.size() == flows.size());
-    assert(poly_idx < flows.size());
-    assert(from[poly_idx].size() == flows[poly_idx].size());
-    assert((from_point_idx + 1) % flows[poly_idx].size() == to_point_idx);
-    return flows[poly_idx][from_point_idx];
-}
-
-
-
-}//namespace cura

src/FuzzyWalls.h

@@ -1,52 +0,0 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-#ifndef FUZZY_WALLS_H
-#define FUZZY_WALLS_H
-
-#include "sliceDataStorage.h"
-#include "PolygonFlowAdjuster.h"
-
-namespace cura {
-
-class FuzzyWalls : public PolygonFlowAdjuster
-{
-public:
-    struct Settings
-    {
-        coord_t max_amplitude;
-        coord_t avg_dist_between_points;
-        ColourUsage color_usage;
-        coord_t min_dist_between_points;
-        coord_t range_random_point_dist;
-        Settings(const SettingsBaseVirtual* settings_base)
-        : max_amplitude(settings_base->getSettingInMicrons("magic_fuzzy_skin_thickness"))
-        , avg_dist_between_points(settings_base->getSettingInMicrons("magic_fuzzy_skin_point_dist"))
-        , color_usage(settings_base->getSettingAsColourUsage("fuzz_map_texture_color"))
-        , min_dist_between_points(avg_dist_between_points * 3 / 4) // hardcoded: the point distance may vary between 3/4 and 5/4 the supplied value
-        , range_random_point_dist(avg_dist_between_points / 2)
-        {
-        }
-    };
-    FuzzyWalls(const SliceMeshStorage& mesh);
-    Polygons makeFuzzy(const SliceMeshStorage& mesh, const unsigned int layer_nr, const Polygons& in);
-    float getFlow(const Polygons& from, unsigned int poly_idx, unsigned int from_point_idx, unsigned int to_point_idx);
-protected:
-    struct CarryOver
-    {
-        coord_t dist_left_over;
-        float offset_random; // [-1,1]
-        float next_offset_random; // [-1,1]
-        coord_t step_size;
-        Point p0p1_perp;
-    };
-    Settings settings;
-    std::function<coord_t (const unsigned int, const Point)> getAmplitude;
-
-    std::vector<std::vector<float>> flows; //!< The flow per segment per polygon in the input
-
-    void makeCornerFuzzy(const unsigned int layer_nr, const Point p0, const Point p1, const Point p2, const CarryOver carry_over, PolygonRef result);
-    void makeSegmentFuzzy(const unsigned int layer_nr, const Point p0, const Point p1, PolygonRef result, CarryOver& carry_over);
-};
-
-}//namespace cura
-
-#endif//FUZZY_WALLS_H

src/MeshGroup.cpp

@@ -25,10 +25,6 @@ void* fgets_(char* ptr, size_t len, FILE* f)
             *ptr = '\0';
             return ptr;
         }
-        else if (*ptr =='\0')
-        {
-            return ptr;
-        }
         ptr++;
         len--;
     }
@@ -49,10 +45,6 @@ MeshGroup::~MeshGroup()
             delete extruders[extruder];
         }
     }
-    for (Mesh* mesh : meshes)
-    {
-        delete mesh;
-    }
 }
 
 int MeshGroup::getExtruderCount() const
@@ -98,10 +90,10 @@ Point3 MeshGroup::min() const
     {
         return Point3(0, 0, 0);
     }
-    Point3 ret = meshes[0]->min();
-    for (unsigned int i = 1; i < meshes.size(); i++)
+    Point3 ret = meshes[0].min();
+    for(unsigned int i=1; i<meshes.size(); i++)
     {
-        Point3 v = meshes[i]->min();
+        Point3 v = meshes[i].min();
         ret.x = std::min(ret.x, v.x);
         ret.y = std::min(ret.y, v.y);
         ret.z = std::min(ret.z, v.z);
@@ -115,10 +107,10 @@ Point3 MeshGroup::max() const
     {
         return Point3(0, 0, 0);
     }
-    Point3 ret = meshes[0]->max();
-    for (unsigned int i = 1; i < meshes.size(); i++)
+    Point3 ret = meshes[0].max();
+    for(unsigned int i=1; i<meshes.size(); i++)
     {
-        Point3 v = meshes[i]->max();
+        Point3 v = meshes[i].max();
         ret.x = std::max(ret.x, v.x);
         ret.y = std::max(ret.y, v.y);
         ret.z = std::max(ret.z, v.z);
@@ -128,9 +120,9 @@ Point3 MeshGroup::max() const
 
 void MeshGroup::clear()
 {
-    for (Mesh* m : meshes)
+    for(Mesh& m : meshes)
     {
-        m->clear();
+        m.clear();
     }
 }
 
@@ -148,9 +140,9 @@ void MeshGroup::finalize()
             continue;
         }
 
-        for (const Mesh* mesh : meshes)
+        for (const Mesh& mesh : meshes)
         {
-            if (mesh->getSettingBoolean("support_enable")
+            if (mesh.getSettingBoolean("support_enable")
                 && (
                     getSettingAsIndex("support_infill_extruder_nr") == extruder_nr
                     || getSettingAsIndex("support_extruder_nr_layer_0") == extruder_nr
@@ -164,13 +156,13 @@ void MeshGroup::finalize()
         }
     }
 
-    for (const Mesh* mesh : meshes)
+    for (const Mesh& mesh : meshes)
     {
-        if (!mesh->getSettingBoolean("anti_overhang_mesh")
-            && !mesh->getSettingBoolean("support_mesh")
+        if (!mesh.getSettingBoolean("anti_overhang_mesh")
+            && !mesh.getSettingBoolean("support_mesh")
         )
         {
-            getExtruderTrain(mesh->getSettingAsIndex("extruder_nr"))->setIsUsed(true);
+            getExtruderTrain(mesh.getSettingAsIndex("extruder_nr"))->setIsUsed(true);
         }
     }
 
@@ -183,17 +175,17 @@ void MeshGroup::finalize()
     }
     
     // If a mesh position was given, put the mesh at this position in 3D space. 
-    for (Mesh* mesh : meshes)
+    for(Mesh& mesh : meshes)
     {
-        Point3 mesh_offset(mesh->getSettingInMicrons("mesh_position_x"), mesh->getSettingInMicrons("mesh_position_y"), mesh->getSettingInMicrons("mesh_position_z"));
-        if (mesh->getSettingBoolean("center_object"))
+        Point3 mesh_offset(mesh.getSettingInMicrons("mesh_position_x"), mesh.getSettingInMicrons("mesh_position_y"), mesh.getSettingInMicrons("mesh_position_z"));
+        if (mesh.getSettingBoolean("center_object"))
         {
-            Point3 object_min = mesh->min();
-            Point3 object_max = mesh->max();
+            Point3 object_min = mesh.min();
+            Point3 object_max = mesh.max();
             Point3 object_size = object_max - object_min;
             mesh_offset += Point3(-object_min.x - object_size.x / 2, -object_min.y - object_size.y / 2, -object_min.z);
         }
-        mesh->offset(mesh_offset + meshgroup_offset);
+        mesh.offset(mesh_offset + meshgroup_offset);
     }
 }
 
@@ -337,128 +329,6 @@ bool loadMeshSTL(Mesh* mesh, const char* filename, const FMatrix3x3& matrix)
     return loadMeshSTL_binary(mesh, filename, matrix);
 }
 
-void loadMaterialBase(TexturedMesh* mesh, const char* filename)
-{
-    FILE* f = fopen(filename, "rt");
-    if (f == nullptr)
-    {
-        logError("ERROR: Couldn't load MTL file %s.\n", filename);
-        return;
-    }
-    char buffer[1024];
-    char mat_name [100];
-    char mat_file [100];
-    char map_type [10];
-    Material* last_mat = nullptr;
-    while(fgets_(buffer, sizeof(buffer), f))
-    {
-        if (buffer[0] == '#')
-        {
-            continue;
-        }
-        if (sscanf(buffer, "map_%s %s", map_type, mat_file) == 2 // we don't care what type of map it specifies (currently)
-            || sscanf(buffer, "bump %s", mat_file) == 1
-            || sscanf(buffer, "disp %s", mat_file) == 1
-            || sscanf(buffer, "decal %s", mat_file) == 1
-            || sscanf(buffer, "refl %s", mat_file) == 1
-        )
-        {
-            std::string parent_dir = std::string(filename).substr(0, std::string(filename).find_last_of("/\\"));
-            std::string mtl_file = parent_dir + "/" + mat_file;
-            if (last_mat)
-            {
-                last_mat->loadImage(mtl_file.c_str());
-            }
-        }
-        else if (sscanf(buffer, "newmtl %s", mat_name) == 1)
-        {
-            last_mat = mesh->addMaterial(mat_name);
-        }
-    }
-    fclose(f);
-}
-
-bool loadMeshOBJ(TexturedMesh* mesh, const char* filename, const FMatrix3x3& matrix)
-{
-    FILE* f = fopen(filename, "rt");
-    if (f == nullptr)
-    {
-        return false;
-    }
-    char buffer[1024];
-    FPoint3 vertex;
-    int vertex_indices[3];
-    float texture_x;
-    float texture_y;
-    float temp;
-    char face_index_buffer_1 [100];
-    char face_index_buffer_2 [100];
-    char face_index_buffer_3 [100];
-    char str_buffer [100];
-    while(fgets_(buffer, sizeof(buffer), f))
-    {
-        if (buffer[0] == '#')
-        {
-            continue;
-        }
-        if (sscanf(buffer, "v %f %f %f", &vertex.x, &vertex.y, &vertex.z) == 3)
-        {
-            Point3 v = matrix.apply(vertex);
-            mesh->addVertex(v);
-        }
-        else if (sscanf(buffer, "vt %f %f", &texture_x, &texture_y) == 2)
-        {
-            mesh->addTextureCoord(texture_x, texture_y);
-        }
-        else if (sscanf(buffer, "f %s %s %s", face_index_buffer_1, face_index_buffer_2, face_index_buffer_3) == 3)
-        {
-            int normal_vector_index; // unused
-            int texture_indices[3]; // becomes -1 if no texture data supplied
-            int n_scanned_1 = sscanf(face_index_buffer_1, "%d/%d/%d", &vertex_indices[0], &texture_indices[0], &normal_vector_index);
-            int n_scanned_2 = sscanf(face_index_buffer_2, "%d/%d/%d", &vertex_indices[1], &texture_indices[1], &normal_vector_index);
-            int n_scanned_3 = sscanf(face_index_buffer_3, "%d/%d/%d", &vertex_indices[2], &texture_indices[2], &normal_vector_index);
-            if (n_scanned_1 >= 2 && n_scanned_2 >= 2 && n_scanned_3 >= 2)
-            {
-                mesh->addFace(vertex_indices[0] - 1, vertex_indices[1] - 1, vertex_indices[2] - 1, texture_indices[0] - 1, texture_indices[1] - 1, texture_indices[2] - 1);
-                // obj files count vertex indices starting from 1!
-            }
-            else if (n_scanned_1 >= 1 && n_scanned_2 >= 1 && n_scanned_3 >= 1)
-            {
-                mesh->addFace(vertex_indices[0] - 1, vertex_indices[1] - 1, vertex_indices[2] - 1);
-            }
-        }
-        else if (sscanf(buffer, "mtllib %s", str_buffer) == 1)
-        {
-            std::string parent_dir = std::string(filename).substr(0, std::string(filename).find_last_of("/\\"));
-            std::string mtl_file = parent_dir + "/" + str_buffer;
-            loadMaterialBase(mesh, mtl_file.c_str());
-        }
-        else if (sscanf(buffer, "usemtl %s", str_buffer) == 1)
-        {
-            mesh->setMaterial(str_buffer);
-        }
-        else if (sscanf(buffer, "vn %f %f %f", &temp, &temp, &temp) == 3)
-        {
-            // do nothing with vertex normals
-        }
-        else if (sscanf(buffer, "g %s", str_buffer) == 1)
-        {
-            // do nothing with polygon groups
-        }
-        else if (buffer[0] == '\0')
-        {
-            // empty line, do nothing
-        }
-        else
-        {
-            logError("Cannot parse line \"%s\"\n", buffer);
-        }
-    }
-    fclose(f);
-    mesh->finish();
-    return true;
-}
-
 bool loadMeshIntoMeshGroup(MeshGroup* meshgroup, const char* filename, const FMatrix3x3& transformation, SettingsBaseVirtual* object_parent_settings)
 {
     TimeKeeper load_timer;
@@ -466,32 +336,14 @@ bool loadMeshIntoMeshGroup(MeshGroup* meshgroup, const char* filename, const FMa
     const char* ext = strrchr(filename, '.');
     if (ext && (strcmp(ext, ".stl") == 0 || strcmp(ext, ".STL") == 0))
     {
-        Mesh* mesh = new Mesh(object_parent_settings ? object_parent_settings : meshgroup); //If we have object_parent_settings, use them as parent settings. Otherwise, just use meshgroup.
-        if (loadMeshSTL(mesh,filename,transformation)) //Load it! If successful...
+        Mesh mesh = object_parent_settings ? Mesh(object_parent_settings) : Mesh(meshgroup); //If we have object_parent_settings, use them as parent settings. Otherwise, just use meshgroup.
+        if(loadMeshSTL(&mesh,filename,transformation)) //Load it! If successful...
         {
             meshgroup->meshes.push_back(mesh);
             log("loading '%s' took %.3f seconds\n",filename,load_timer.restart());
             return true;
         }
-        else
-        {
-            delete mesh;
-        }
     }
-    else if (ext && (strcmp(ext, ".obj") == 0 || strcmp(ext, ".OBJ") == 0))
-    {
-        TexturedMesh* mesh = new TexturedMesh(object_parent_settings ? object_parent_settings : meshgroup); //If we have object_parent_settings, use them as parent settings. Otherwise, just use meshgroup.
-        if (loadMeshOBJ(mesh,filename,transformation)) //Load it! If successful...
-        {
-            meshgroup->meshes.push_back(mesh);
-            return true;
-        }
-        else 
-        {
-            delete mesh;
-        }
-    }
-        
     return false;
 }
 

src/MeshGroup.h

@@ -4,7 +4,6 @@
 
 #include "utils/NoCopy.h"
 #include "mesh.h"
-#include "textureProcessing/TexturedMesh.h"
 #include "ExtruderTrain.h"
 
 namespace cura
@@ -36,7 +35,7 @@ public:
 
     const ExtruderTrain* getExtruderTrain(unsigned int extruder_nr) const;
 
-    std::vector<Mesh*> meshes;
+    std::vector<Mesh> meshes;
 
     Point3 min() const; //! minimal corner of bounding box
     Point3 max() const; //! maximal corner of bounding box

src/PolygonFlowAdjuster.h

@@ -1,41 +0,0 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-#ifndef POLYGON_FLOW_ADJUSTER_H
-#define POLYGON_FLOW_ADJUSTER_H
-
-#include "utils/intpoint.h"
-#include "utils/polygon.h"
-
-namespace cura 
-{
-
-/*!
- * Class for computing and compensating the flow of line segments in a polygon.
- * 
- */
-class PolygonFlowAdjuster
-{
-public:
-    /*!
-     * Compute the flow for a given line segment in the polygons
-     * 
-     * \warning should only be called once for each line segment in a polygon!
-     * 
-     * \param from the polygons from which to get the segment of a flow, which should be the same polygons as the ones which the PolygonFlowAdjuster was constructed with
-     * \param poly_idx Index to the polygon in which to find the line segment
-     * \param from_point_idx The index to the beginning of the line segment
-     * \param to_point_idx The index to the ending of the line segment
-     * \return a value between zero and one representing the reduced flow of the line segment
-     */
-    virtual float getFlow(const Polygons& from, unsigned int poly_idx, unsigned int from_point_idx, unsigned int to_point_idx) = 0;
-
-    virtual ~PolygonFlowAdjuster()
-    {
-    }
-};
-
-
-}//namespace cura
-
-
-
-#endif//POLYGON_FLOW_ADJUSTER_H

src/SkirtBrim.cpp

@@ -58,6 +58,10 @@ void SkirtBrim::getFirstLayerOutline(SliceDataStorage& storage, const unsigned i
     constexpr int smallest_line_length = 200;
     constexpr int largest_error_of_removed_point = 50;
     first_layer_outline.simplify(smallest_line_length, largest_error_of_removed_point); // simplify for faster processing of the brim lines
+    if (first_layer_outline.size() == 0)
+    {
+        logError("Couldn't generate skirt / brim! No polygons on first layer.");
+    }
 }
 
 int SkirtBrim::generatePrimarySkirtBrimLines(SliceDataStorage& storage, int start_distance, unsigned int primary_line_count, const int primary_extruder_skirt_brim_line_width, const int64_t primary_extruder_minimal_length, const Polygons& first_layer_outline, Polygons& skirt_brim_primary_extruder)

src/WallsComputation.cpp

@@ -12,6 +12,12 @@ WallsComputation::WallsComputation(int wall_0_inset, int line_width_0, int line_
 {
 }
 
+/*
+ * This function is executed in a parallel region based on layer_nr.
+ * When modifying make sure any changes does not introduce data races.
+ *
+ * generateInsets only reads and writes data for the current layer
+ */
 void WallsComputation::generateInsets(SliceLayerPart* part)
 {
     if (insetCount == 0)
@@ -58,6 +64,12 @@ void WallsComputation::generateInsets(SliceLayerPart* part)
     }
 }
 
+/*
+ * This function is executed in a parallel region based on layer_nr.
+ * When modifying make sure any changes does not introduce data races.
+ *
+ * generateInsets only reads and writes data for the current layer
+ */
 void WallsComputation::generateInsets(SliceLayer* layer)
 {
     for(unsigned int partNr = 0; partNr < layer->parts.size(); partNr++)

src/Weaver.cpp

@@ -23,9 +23,9 @@ void Weaver::weave(MeshGroup* meshgroup)
 
     std::vector<cura::Slicer*> slicerList;
 
-    for (Mesh* mesh : meshgroup->meshes)
+    for(Mesh& mesh : meshgroup->meshes)
     {
-        cura::Slicer* slicer = new cura::Slicer(mesh, initial_layer_thickness, connectionHeight, layer_count, mesh->getSettingBoolean("meshfix_keep_open_polygons"), mesh->getSettingBoolean("meshfix_extensive_stitching"), nullptr);
+        cura::Slicer* slicer = new cura::Slicer(&mesh, initial_layer_thickness, connectionHeight, layer_count, mesh.getSettingBoolean("meshfix_keep_open_polygons"), mesh.getSettingBoolean("meshfix_extensive_stitching"));
         slicerList.push_back(slicer);
     }
 

src/Weaver.h

@@ -6,7 +6,7 @@
 #include "settings/settings.h"
 
 #include "MeshGroup.h"
-#include "slicer/Slicer.h"
+#include "slicer.h"
 
 #include "utils/NoCopy.h"
 #include "utils/polygon.h"

src/Wireframe2gcode.cpp

@@ -247,7 +247,7 @@ void Wireframe2gcode::strategy_retract(WeaveLayer& layer, WeaveConnectionPart& p
     retraction_config.retraction_min_travel_distance = getSettingInMicrons("retraction_min_travel");
 
     double top_retract_pause = 2.0;
-    coord_t retract_hop_dist = 1000;
+    int retract_hop_dist = 1000;
     bool after_retract_hop = false;
     //bool go_horizontal_first = true;
     bool lower_retract_start = true;

src/Wireframe2gcode.h

@@ -11,7 +11,7 @@
 #include "settings/settings.h"
 
 #include "MeshGroup.h"
-#include "slicer/Slicer.h"
+#include "slicer.h"
 
 #include "utils/polygon.h"
 #include "Weaver.h"
@@ -29,37 +29,37 @@ private:
     static const int STRATEGY_KNOT = 1;
     static const int STRATEGY_RETRACT = 2;
     
-    coord_t initial_layer_thickness;
-    coord_t filament_diameter;
-    coord_t line_width;
+    int initial_layer_thickness;
+    int filament_diameter;
+    int line_width;
     double flowConnection;
     double flowFlat; 
     double extrusion_mm3_per_mm_connection;
     double extrusion_mm3_per_mm_flat;
-    coord_t nozzle_outer_diameter;
-    coord_t nozzle_head_distance;
+    int nozzle_outer_diameter;
+    int nozzle_head_distance;
     double nozzle_expansion_angle;
-    coord_t nozzle_clearance;
-    coord_t nozzle_top_diameter;
+    int nozzle_clearance;
+    int nozzle_top_diameter;
     double moveSpeed;
     double speedBottom;
     double speedUp;
     double speedDown;
     double speedFlat;
-    coord_t connectionHeight;
-    coord_t roof_inset;
+    int connectionHeight;
+    int roof_inset;
     double flat_delay;
     double bottom_delay;
     double top_delay;
-    coord_t up_dist_half_speed;
-    coord_t top_jump_dist;
-    coord_t fall_down;
-    coord_t drag_along;
+    int up_dist_half_speed;
+    int top_jump_dist;
+    int fall_down;
+    int drag_along;
     int strategy;
     double go_back_to_last_top;
-    coord_t straight_first_when_going_down;
-    coord_t roof_fall_down;
-    coord_t roof_drag_along;
+    int straight_first_when_going_down;
+    int roof_fall_down;
+    int roof_drag_along;
     double roof_outer_delay;
     
     RetractionConfig standard_retraction_config; //!< The standard retraction settings used for moves between parts etc.

src/commandSocket.cpp

@@ -346,9 +346,9 @@ void CommandSocket::connect(const std::string& ip, int port)
                         continue;
                     }
                     const ExtruderTrain* settings_base = meshgroup->getExtruderTrain(extruder_nr); //The extruder train that the setting should fall back to.
-                    for (Mesh* mesh : meshgroup->meshes)
+                    for (Mesh& mesh : meshgroup->meshes)
                     {
-                        mesh->setSettingInheritBase(setting_extruder.name(), *settings_base);
+                        mesh.setSettingInheritBase(setting_extruder.name(), *settings_base);
                     }
                 }
             }
@@ -455,8 +455,8 @@ void CommandSocket::handleObjectList(cura::proto::ObjectList* list, const google
         }
         SettingsBase* extruder_train = meshgroup->getExtruderTrain(extruder_train_nr);
 
-        meshgroup->meshes.push_back(new Mesh(extruder_train)); //Construct a new mesh (with the corresponding extruder train as settings parent object) and put it into MeshGroup's mesh list.
-        Mesh& mesh = *meshgroup->meshes.back();
+        meshgroup->meshes.push_back(extruder_train); //Construct a new mesh (with the corresponding extruder train as settings parent object) and put it into MeshGroup's mesh list.
+        Mesh& mesh = meshgroup->meshes.back();
 
         for (int i = 0; i < face_count; ++i)
         {
@@ -642,6 +642,7 @@ void CommandSocket::sendLayerData()
     {
         for (std::pair<const int, std::shared_ptr<cura::proto::Layer>> entry : data.slice_data) //Note: This is in no particular order!
         {
+            logDebug("Sending layer data for layer %i of %i.\n", entry.first, data.slice_data.size());
             private_data->socket->sendMessage(entry.second); //Send the actual layers.
         }
         data.sliced_objects = 0;
@@ -667,6 +668,7 @@ void CommandSocket::sendOptimizedLayerData()
     {
         for (std::pair<const int, std::shared_ptr<cura::proto::LayerOptimized>> entry : data.slice_data) //Note: This is in no particular order!
         {
+            logDebug("Sending layer data for layer %i of %i.\n", entry.first, data.slice_data.size());
             private_data->socket->sendMessage(entry.second); //Send the actual layers.
         }
         data.sliced_objects = 0;

src/gcodeExport.cpp

@@ -51,13 +51,13 @@ void GCodeExport::preSetup(const MeshGroup* meshgroup)
 
     extruder_count = meshgroup->getSettingAsCount("machine_extruder_count");
 
-    for (const Mesh* mesh : meshgroup->meshes)
+    for (const Mesh& mesh : meshgroup->meshes)
     {
-        if (!mesh->getSettingBoolean("anti_overhang_mesh")
-            && !mesh->getSettingBoolean("support_mesh")
+        if (!mesh.getSettingBoolean("anti_overhang_mesh")
+            && !mesh.getSettingBoolean("support_mesh")
         )
         {
-            extruder_attr[mesh->getSettingAsIndex("extruder_nr")].is_used = true;
+            extruder_attr[mesh.getSettingAsIndex("extruder_nr")].is_used = true;
         }
     }
 
@@ -69,11 +69,11 @@ void GCodeExport::preSetup(const MeshGroup* meshgroup)
         {
             extruder_attr[extruder_nr].is_used = true;
         }
-        for (const Mesh* mesh : meshgroup->meshes)
+        for (const Mesh& mesh : meshgroup->meshes)
         {
-            if ((mesh->getSettingBoolean("support_enable") && mesh->getSettingBoolean("support_interface_enable") && meshgroup->getSettingAsIndex("support_interface_extruder_nr") == int(extruder_nr))
-                || (mesh->getSettingBoolean("support_enable") && meshgroup->getSettingAsIndex("support_infill_extruder_nr") == int(extruder_nr))
-                || (mesh->getSettingBoolean("support_enable") && meshgroup->getSettingAsIndex("support_extruder_nr_layer_0") == int(extruder_nr))
+            if ((mesh.getSettingBoolean("support_enable") && mesh.getSettingBoolean("support_interface_enable") && meshgroup->getSettingAsIndex("support_interface_extruder_nr") == int(extruder_nr))
+                || (mesh.getSettingBoolean("support_enable") && meshgroup->getSettingAsIndex("support_infill_extruder_nr") == int(extruder_nr))
+                || (mesh.getSettingBoolean("support_enable") && meshgroup->getSettingAsIndex("support_extruder_nr_layer_0") == int(extruder_nr))
                 )
             {
                 extruder_attr[extruder_nr].is_used = true;
@@ -556,8 +556,6 @@ void GCodeExport::writeMove(int x, int y, int z, double speed, double extrusion_
     assert((Point3(x,y,z) - currentPosition).vSize() < MM2INT(300)); // no crazy positions (this code should not be compiled for release)
 #endif //ASSERT_INSANE_OUTPUT
 
-    total_bounding_box.include(Point3(x, y, z));
-
     if (extrusion_mm3_per_mm < 0)
         logWarning("Warning! Negative extrusion move!");
 
@@ -570,6 +568,7 @@ void GCodeExport::writeMove(int x, int y, int z, double speed, double extrusion_
     double extrusion_per_mm = mm3ToE(extrusion_mm3_per_mm);
 
     Point gcode_pos = getGcodePos(x,y, current_extruder);
+    total_bounding_box.include(Point3(gcode_pos.X, gcode_pos.Y, z));
 
     if (extrusion_mm3_per_mm > 0.000001)
     {
@@ -729,7 +728,7 @@ void GCodeExport::writeZhopStart(int hop_height)
     {
         isZHopped = hop_height;
         *output_stream << "G1 Z" << MMtoStream{currentPosition.z + isZHopped} << new_line;
-        total_bounding_box.include(currentPosition + Point3(0, 0, isZHopped));
+        total_bounding_box.includeZ(currentPosition.z + isZHopped);
     }
 }
 
@@ -923,7 +922,7 @@ void GCodeExport::finalize(const char* endCode)
 {
     writeFanCommand(0);
     writeCode(endCode);
-    long print_time = getTotalPrintTime();
+    int64_t print_time = getTotalPrintTime();
     int mat_0 = getTotalFilamentUsed(0);
     log("Print time: %d\n", print_time);
     log("Print time (readable): %dh %dm %ds\n", print_time / 60 / 60, (print_time / 60) % 60, print_time % 60);

src/gcodePlanner.cpp

@@ -355,25 +355,21 @@ void GCodePlanner::addExtrusionMove(Point p, GCodePathConfig* config, SpaceFillT
     lastPosition = p;
 }
 
-void GCodePlanner::addPolygon(Polygons& polygons, unsigned int poly_idx, int start_idx, GCodePathConfig* config, PolygonFlowAdjuster* wall_overlap_computation, coord_t wall_0_wipe_dist, bool spiralize)
+void GCodePlanner::addPolygon(PolygonRef polygon, int start_idx, GCodePathConfig* config, WallOverlapComputation* wall_overlap_computation, coord_t wall_0_wipe_dist, bool spiralize)
 {
-    PolygonRef polygon = polygons[poly_idx];
-    unsigned int p0_idx = start_idx;
-    Point p0 = polygon[p0_idx];
+    Point p0 = polygon[start_idx];
     addTravel(p0);
     for (unsigned int point_idx = 1; point_idx < polygon.size(); point_idx++)
     {
-        unsigned int p1_idx = (start_idx + point_idx) % polygon.size();
-        Point p1 = polygon[p1_idx];
-        float flow = (wall_overlap_computation)? wall_overlap_computation->getFlow(polygons, poly_idx, p0_idx, p1_idx) : 1.0;
+        Point p1 = polygon[(start_idx + point_idx) % polygon.size()];
+        float flow = (wall_overlap_computation)? wall_overlap_computation->getFlow(p0, p1) : 1.0;
         addExtrusionMove(p1, config, SpaceFillType::Polygons, flow, spiralize);
         p0 = p1;
-        p0_idx = p1_idx;
     }
     if (polygon.size() > 2)
     {
         Point& p1 = polygon[start_idx];
-        float flow = (wall_overlap_computation)? wall_overlap_computation->getFlow(polygons, poly_idx, p0_idx, start_idx) : 1.0;
+        float flow = (wall_overlap_computation)? wall_overlap_computation->getFlow(p0, p1) : 1.0;
         addExtrusionMove(p1, config, SpaceFillType::Polygons, flow, spiralize);
 
         if (wall_0_wipe_dist > 0)
@@ -407,7 +403,7 @@ void GCodePlanner::addPolygon(Polygons& polygons, unsigned int poly_idx, int sta
     }
 }
 
-void GCodePlanner::addPolygonsByOptimizer(Polygons& polygons, GCodePathConfig* config, PolygonFlowAdjuster* flow_adjuster, EZSeamType z_seam_type, Point z_seam_pos, coord_t wall_0_wipe_dist, bool spiralize)
+void GCodePlanner::addPolygonsByOptimizer(Polygons& polygons, GCodePathConfig* config, WallOverlapComputation* wall_overlap_computation, EZSeamType z_seam_type, Point z_seam_pos, coord_t wall_0_wipe_dist, bool spiralize)
 {
     if (polygons.size() == 0)
     {
@@ -421,7 +417,7 @@ void GCodePlanner::addPolygonsByOptimizer(Polygons& polygons, GCodePathConfig* c
     orderOptimizer.optimize();
     for (unsigned int poly_idx : orderOptimizer.polyOrder)
     {
-        addPolygon(polygons, poly_idx, orderOptimizer.polyStart[poly_idx], config, flow_adjuster, wall_0_wipe_dist, spiralize);
+        addPolygon(polygons[poly_idx], orderOptimizer.polyStart[poly_idx], config, wall_overlap_computation, wall_0_wipe_dist, spiralize);
     }
 }
 void GCodePlanner::addLinesByOptimizer(Polygons& polygons, GCodePathConfig* config, SpaceFillType space_fill_type, int wipe_dist)
@@ -901,6 +897,7 @@ void GCodePlanner::completeConfigs()
 
         mesh.insetX_config.setLayerHeight(layer_thickness);
         mesh.skin_config.setLayerHeight(layer_thickness);
+        mesh.perimeter_gap_config.setLayerHeight(layer_thickness);
         for(unsigned int idx=0; idx<MAX_INFILL_COMBINE; idx++)
         {
             mesh.infill_config[idx].setLayerHeight(layer_thickness);
@@ -959,6 +956,7 @@ void GCodePlanner::processInitialLayersSpeedup()
 
             //Skin speed (per mesh).
             mesh.skin_config.smoothSpeed(initial_layer_speed_config, layer_nr, initial_speedup_layers);
+            mesh.perimeter_gap_config.smoothSpeed(initial_layer_speed_config, layer_nr, initial_speedup_layers);
 
             for (unsigned int idx = 0; idx < MAX_INFILL_COMBINE; idx++)
             {
@@ -980,6 +978,7 @@ void GCodePlanner::processInitialLayersSpeedup()
             mesh.inset0_config.setSpeedIconic();
             mesh.insetX_config.setSpeedIconic();
             mesh.skin_config.setSpeedIconic();
+            mesh.perimeter_gap_config.setSpeedIconic();
             for (unsigned int idx = 0; idx < MAX_INFILL_COMBINE; idx++)
             {
                 mesh.infill_config[idx].setSpeedIconic();

src/gcodePlanner.h

@@ -11,7 +11,7 @@
 #include "pathPlanning/TimeMaterialEstimates.h"
 #include "utils/polygon.h"
 #include "utils/logoutput.h"
-#include "PolygonFlowAdjuster.h"
+#include "wallOverlap.h"
 #include "commandSocket.h"
 #include "FanSpeedLayerTime.h"
 #include "SpaceFillType.h"
@@ -381,15 +381,14 @@ public:
 
     /*!
      * Add polygon to the gcode starting at vertex \p startIdx
-     * \param polygon The polygons from which to get the polygon
-     * \param polygon The index of the polygon in \p polygons
+     * \param polygon The polygon
      * \param startIdx The index of the starting vertex of the \p polygon
      * \param config The config with which to print the polygon lines
-     * \param flow_adjuster Construct yielding the flow of each segment added (optionally nullptr)
+     * \param wall_overlap_computation The wall overlap compensation calculator for each given segment (optionally nullptr)
      * \param wall_0_wipe_dist The distance to travel along the polygon after it has been laid down, in order to wipe the start and end of the wall together
      * \param spiralize Whether to gradually increase the z height from the normal layer height to the height of the next layer over this polygon
      */
-    void addPolygon(Polygons& polygons, unsigned int poly_idx, int startIdx, GCodePathConfig* config, PolygonFlowAdjuster* flow_adjuster = nullptr, coord_t wall_0_wipe_dist = 0, bool spiralize = false);
+    void addPolygon(PolygonRef polygon, int startIdx, GCodePathConfig* config, WallOverlapComputation* wall_overlap_computation = nullptr, coord_t wall_0_wipe_dist = 0, bool spiralize = false);
 
     /*!
      * Add polygons to the gcode with optimized order.
@@ -402,13 +401,13 @@ public:
      * 
      * \param polygons The polygons
      * \param config The config with which to print the polygon lines
-     * \param flow_adjuster Construct yielding the flow of each segment added (optionally nullptr)
+     * \param wall_overlap_computation The wall overlap compensation calculator for each given segment (optionally nullptr)
      * \param z_seam_type The seam type / poly start optimizer
      * \param z_seam_pos The location near where to start each part in case \p z_seam_type is 'back'
      * \param wall_0_wipe_dist The distance to travel along each polygon after it has been laid down, in order to wipe the start and end of the wall together
      * \param spiralize Whether to gradually increase the z height from the normal layer height to the height of the next layer over each polygon printed
      */
-    void addPolygonsByOptimizer(Polygons& polygons, GCodePathConfig* config, PolygonFlowAdjuster* flow_adjuster = nullptr, EZSeamType z_seam_type = EZSeamType::SHORTEST, Point z_seam_pos = Point(0, 0), coord_t wall_0_wipe_dist = 0, bool spiralize = false);
+    void addPolygonsByOptimizer(Polygons& polygons, GCodePathConfig* config, WallOverlapComputation* wall_overlap_computation = nullptr, EZSeamType z_seam_type = EZSeamType::SHORTEST, Point z_seam_pos = Point(0, 0), coord_t wall_0_wipe_dist = 0, bool spiralize = false);
 
     /*!
      * Add lines to the gcode with optimized order.

src/infill/SubDivCube.cpp

@@ -174,7 +174,7 @@ SubDivCube::SubDivCube(SliceMeshStorage& mesh, Point3& center, unsigned int dept
     rel_child_centers.emplace_back(-1, -1, 1);
     for (Point3 rel_child_center : rel_child_centers)
     {
-        child_center = center + rotation_matrix.apply(rel_child_center * coord_t(cube_properties.side_length / 4));
+        child_center = center + rotation_matrix.apply(rel_child_center * int32_t(cube_properties.side_length / 4));
         if (isValidSubdivision(mesh, child_center, radius))
         {
             children[child_nr] = new SubDivCube(mesh, child_center, depth - 1);
@@ -186,15 +186,15 @@ SubDivCube::SubDivCube(SliceMeshStorage& mesh, Point3& center, unsigned int dept
 bool SubDivCube::isValidSubdivision(SliceMeshStorage& mesh, Point3& center, int64_t radius)
 {
     int64_t distance2;
-    long int sphere_slice_radius2;//!< squared radius of bounding sphere slice on target layer
+    coord_t sphere_slice_radius2;//!< squared radius of bounding sphere slice on target layer
     bool inside_somewhere = false;
     bool outside_somewhere = false;
     int inside;
     double part_dist;//what percentage of the radius the target layer is away from the center along the z axis. 0 - 1
-    const long int layer_height = mesh.getSettingInMicrons("layer_height");
-    long int bottom_layer = (center.z - radius) / layer_height;
-    long int top_layer = (center.z + radius) / layer_height;
-    for (long int test_layer = bottom_layer; test_layer <= top_layer; test_layer += 3) // steps of three. Low-hanging speed gain.
+    const coord_t layer_height = mesh.getSettingInMicrons("layer_height");
+    int bottom_layer = (center.z - radius) / layer_height;
+    int top_layer = (center.z + radius) / layer_height;
+    for (int test_layer = bottom_layer; test_layer <= top_layer; test_layer += 3) // steps of three. Low-hanging speed gain.
     {
         part_dist = (double)(test_layer * layer_height - center.z) / radius;
         sphere_slice_radius2 = radius * radius * (1.0 - (part_dist * part_dist));
@@ -221,9 +221,9 @@ bool SubDivCube::isValidSubdivision(SliceMeshStorage& mesh, Point3& center, int6
     return false;
 }
 
-int SubDivCube::distanceFromPointToMesh(SliceMeshStorage& mesh, long int layer_nr, Point& location, int64_t* distance2)
+int SubDivCube::distanceFromPointToMesh(SliceMeshStorage& mesh, int layer_nr, Point& location, int64_t* distance2)
 {
-    if (layer_nr < 0 || (unsigned long int)layer_nr >= mesh.layers.size()) //!< this layer is outside of valid range
+    if (layer_nr < 0 || (unsigned int)layer_nr >= mesh.layers.size()) //!< this layer is outside of valid range
     {
         return 2;
     }

src/infill/SubDivCube.h

@@ -74,7 +74,7 @@ private:
      * \param[out] distance2 the squared distance to the infill border
      * \return Code 0: outside, 1: inside, 2: boundary does not exist at specified layer
      */
-    static int distanceFromPointToMesh(SliceMeshStorage& mesh, long int layer_nr, Point& location, int64_t* distance2);
+    static int distanceFromPointToMesh(SliceMeshStorage& mesh, int layer_nr, Point& location, int64_t* distance2);
 
     /*!
      * Adds the defined line to the specified polygons. It assumes that the specified polygons are all parallel lines. Combines line segments with touching ends closer than epsilon.

src/layerPart.cpp

@@ -1,10 +1,10 @@
 /** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
 
-#include "LayerPart.h"
-#include "../settings/settings.h"
-#include "../progress/Progress.h"
+#include "layerPart.h"
+#include "settings/settings.h"
+#include "progress/Progress.h"
 
-#include "../utils/SVG.h" // debug output
+#include "utils/SVG.h" // debug output
 
 /*
 The layer-part creation step is the first step in creating actual useful data for 3D printing.
@@ -44,7 +44,10 @@ void createLayerWithParts(SliceLayer& storageLayer, SlicerLayer* layer, bool uni
 }
 void createLayerParts(SliceMeshStorage& mesh, Slicer* slicer, bool union_layers, bool union_all_remove_holes)
 {
-    for(unsigned int layer_nr = 0; layer_nr < slicer->layers.size(); layer_nr++)
+    const auto total_layers = slicer->layers.size();
+    assert(mesh.layers.size() == total_layers);
+#pragma omp parallel for default(none) shared(mesh,slicer) firstprivate(union_layers,union_all_remove_holes) schedule(dynamic)
+    for(unsigned int layer_nr = 0; layer_nr < total_layers; layer_nr++)
     {
         mesh.layers[layer_nr].sliceZ = slicer->layers[layer_nr].z;
         mesh.layers[layer_nr].printZ = slicer->layers[layer_nr].z;

src/layerPart.h

@@ -1,10 +1,10 @@
 /** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
-#ifndef SLICER_LAYERPART_H
-#define SLICER_LAYERPART_H
+#ifndef LAYERPART_H
+#define LAYERPART_H
 
-#include "../sliceDataStorage.h"
-#include "Slicer.h"
-#include "../commandSocket.h"
+#include "sliceDataStorage.h"
+#include "slicer.h"
+#include "commandSocket.h"
 
 /*
 The layer-part creation step is the first step in creating actual useful data for 3D printing.
@@ -28,4 +28,4 @@ void layerparts2HTML(SliceDataStorage& mesh, const char* filename, bool all_laye
 
 }//namespace cura
 
-#endif//SLICER_LAYERPART_H
+#endif//LAYERPART_H

src/main.cpp

@@ -11,7 +11,6 @@
 #include <stddef.h>
 #include <vector>
 
-
 #include "utils/gettime.h"
 #include "utils/logoutput.h"
 #include "utils/string.h"
@@ -21,6 +20,10 @@
 
 #include "settings/SettingsToGV.h"
 
+#ifdef _OPENMP
+    #include <omp.h> // omp_get_num_threads
+#endif
+
 namespace cura
 {
     
@@ -211,7 +214,7 @@ void slice(int argc, char **argv)
                         }
                         else 
                         {
-                            last_settings_object = meshgroup->meshes.back();
+                            last_settings_object = &(meshgroup->meshes.back()); // pointer is valid until a new object is added, so this is OK
                         }
                         break;
                     case 'o':
@@ -329,7 +332,19 @@ int main(int argc, char **argv)
         print_usage();
         exit(1);
     }
-    
+
+#pragma omp parallel
+    {
+#pragma omp master
+        {
+#ifdef _OPENMP
+            log("OpenMP multithreading enabled, likely number of threads to be used: %u\n", omp_get_num_threads());
+#else
+            log("OpenMP multithreading disabled\n");
+#endif
+        }
+    }
+
     if (stringcasecompare(argv[1], "connect") == 0)
     {
         connect(argc, argv);
@@ -424,4 +439,4 @@ int main(int argc, char **argv)
     }
     
     return 0;
-}
+}

src/mesh.cpp

@@ -19,21 +19,12 @@ Mesh::Mesh(SettingsBaseVirtual* parent)
 {
 }
 
-bool Mesh::addFace(Point3& v0, Point3& v1, Point3& v2)
+void Mesh::addFace(Point3& v0, Point3& v1, Point3& v2)
 {
     int vi0 = findIndexOfVertex(v0);
     int vi1 = findIndexOfVertex(v1);
     int vi2 = findIndexOfVertex(v2);
-    return addFace(vi0, vi1, vi2);
-}
-
-bool Mesh::addFace(int vi0, int vi1, int vi2)
-{
-    if (vi0 == vi1 || vi1 == vi2 || vi0 == vi2)
-    {
-        // the face has two vertices which get assigned the same location. Don't add the face.
-        return false;
-    }
+    if (vi0 == vi1 || vi1 == vi2 || vi0 == vi2) return; // the face has two vertices which get assigned the same location. Don't add the face.
 
     int idx = faces.size(); // index of face to be added
     faces.emplace_back();
@@ -44,8 +35,6 @@ bool Mesh::addFace(int vi0, int vi1, int vi2)
     vertices[face.vertex_index[0]].connected_faces.push_back(idx);
     vertices[face.vertex_index[1]].connected_faces.push_back(idx);
     vertices[face.vertex_index[2]].connected_faces.push_back(idx);
-
-    return true;
 }
 
 void Mesh::clear()
@@ -92,14 +81,6 @@ void Mesh::expandXY(int64_t offset)
 }
 
 
-void Mesh::addVertex(const Point3& v)
-{
-    uint32_t hash = pointHash(v);
-    vertex_hash_map[hash].push_back(vertices.size());
-    vertices.emplace_back(v);
-    aabb.include(v);
-}
-
 int Mesh::findIndexOfVertex(const Point3& v)
 {
     uint32_t hash = pointHash(v);
@@ -208,5 +189,4 @@ int Mesh::getFaceIdxWithPoints(int idx0, int idx1, int notFaceIdx, int notFaceVe
     return bestIdx;
 }
 
-
 }//namespace cura

src/mesh.h

@@ -3,7 +3,6 @@
 
 #include "settings/settings.h"
 #include "utils/AABB3D.h"
-#include "textureProcessing/MatSegment.h"
 
 namespace cura
 {
@@ -66,26 +65,7 @@ public:
 
     Mesh(SettingsBaseVirtual* parent); //!< initializes the settings
 
-    virtual ~Mesh() {} //!< Destructor
-    
-    /*! 
-     * add a face to the mesh without settings it's connected_faces.
-     * 
-     * Don't add a face when the surface is zero mm^2
-     * 
-     * \return whether a face has been added
-     */
-    bool addFace(Point3& v0, Point3& v1, Point3& v2);
-    /*!
-     * add a face to the mesh without settings it's connected_faces.
-     * 
-     * Don't add a face when the surface is zero mm^2
-     * 
-     * \return whether a face has been added
-     */
-    bool addFace(int vi0, int vi1, int vi2);
-    void addVertex(const Point3& v);
-
+    void addFace(Point3& v0, Point3& v1, Point3& v2); //!< add a face to the mesh without settings it's connected_faces.
     void clear(); //!< clears all data
     void finish(); //!< complete the model : set the connected_face_index fields of the faces.
 

src/multiVolumes.cpp

@@ -1,4 +1,4 @@
-#include "MultiVolumes.h"
+#include "multiVolumes.h"
 
 namespace cura 
 {

src/multiVolumes.h

@@ -1,8 +1,8 @@
-#ifndef SLICER_MULTIVOLUMES_H
-#define SLICER_MULTIVOLUMES_H
+#ifndef MULTIVOLUMES_H
+#define MULTIVOLUMES_H
 
-#include "../sliceDataStorage.h"
-#include "Slicer.h"
+#include "sliceDataStorage.h"
+#include "slicer.h"
 
 /* This file contains code to help fixing up and changing layers that are build from multiple volumes. */
 namespace cura {
@@ -21,4 +21,4 @@ void generateMultipleVolumesOverlap(std::vector<Slicer*> &meshes);
 
 }//namespace cura
 
-#endif//SLICER_MULTIVOLUMES_H
+#endif//MULTIVOLUMES_H

src/pathPlanning/Comb.cpp

@@ -8,7 +8,7 @@
 #include "../utils/polygonUtils.h"
 #include "../utils/PolygonsPointIndex.h"
 #include "../sliceDataStorage.h"
-#include "../utils/linearAlg2D.h"
+#include "../utils/SVG.h"
 
 namespace cura {
 

src/settings/SettingRegistry.cpp

@@ -125,7 +125,7 @@ bool SettingRegistry::getDefinitionFile(const std::string machine_id, std::strin
 
 int SettingRegistry::loadExtruderJSONsettings(unsigned int extruder_nr, SettingsBase* settings_base)
 {
-    if (extruder_train_ids.empty()) //... Tough luck, buddy.
+    if (extruder_train_ids.empty())
     {
         logError("Couldn't find any extruder trains!\n");
         return -1;

src/settings/settings.cpp

@@ -93,21 +93,23 @@ void SettingsBase::setSettingInheritBase(std::string key, const SettingsBaseVirt
 
 std::string SettingsBase::getSettingString(std::string key) const
 {
-    if (setting_values.find(key) != setting_values.end())
+    auto value_it = setting_values.find(key);
+    if (value_it != setting_values.end())
     {
-        return setting_values.at(key);
+        return value_it->second;
     }
-    if (setting_inherit_base.find(key) != setting_inherit_base.end())
+    auto inherit_override_it = setting_inherit_base.find(key);
+    if (inherit_override_it != setting_inherit_base.end())
     {
-        return setting_inherit_base.at(key)->getSettingString(key);
+        return inherit_override_it->second->getSettingString(key);
     }
     if (parent)
     {
         return parent->getSettingString(key);
     }
 
-    const_cast<SettingsBase&>(*this).setting_values[key] = "";
-    cura::logWarning("Unregistered setting %s\n", key.c_str());
+    cura::logError("Trying to retrieve unregistered setting with no value given: '%s'\n", key.c_str());
+    std::exit(-1);
     return "";
 }
 
@@ -458,32 +460,6 @@ SupportDistPriority SettingsBaseVirtual::getSettingAsSupportDistPriority(std::st
     return SupportDistPriority::XY_OVERRIDES_Z;
 }
 
-ColourUsage SettingsBaseVirtual::getSettingAsColourUsage(std::string key) const
-{
-    std::string value = getSettingString(key);
-    if (value == "red")
-    {
-        return ColourUsage::RED;
-    }
-    if (value == "green")
-    {
-        return ColourUsage::GREEN;
-    }
-    if (value == "blue")
-    {
-        return ColourUsage::BLUE;
-    }
-    if (value == "alpha")
-    {
-        return ColourUsage::ALPHA;
-    }
-    if (value == "grey")
-    {
-        return ColourUsage::GREY;
-    }
-    return ColourUsage::GREY;
-}
-
 
 }//namespace cura
 

src/settings/settings.h

@@ -177,18 +177,6 @@ enum class SupportDistPriority
     Z_OVERRIDES_XY
 };
 
-/*!
- * Which color(s) of a texture to use
- */
-enum class ColourUsage
-{
-    RED = 0,
-    GREEN = 1,
-    BLUE = 2,
-    ALPHA = 3,
-    GREY // use red, green and blue channels
-};
-
 #define MAX_EXTRUDERS 16
 
 //Maximum number of infill layers that can be combined into a single infill extrusion area.
@@ -265,7 +253,6 @@ public:
     FillPerimeterGapMode getSettingAsFillPerimeterGapMode(std::string key) const;
     CombingMode getSettingAsCombingMode(std::string key) const;
     SupportDistPriority getSettingAsSupportDistPriority(std::string key) const;
-    ColourUsage getSettingAsColourUsage(std::string key) const;
 };
 
 class SettingRegistry;

src/skin.cpp

@@ -10,7 +10,16 @@
 namespace cura 
 {
 
-        
+
+/*
+ * This function is executed in a parallel region based on layer_nr.
+ * When modifying make sure any changes does not introduce data races.
+ *
+ * generateSkinAreas reads data from mesh.layers.parts[*].insets and writes to mesh.layers[n].parts[*].skin_parts
+ * generateSkinInsets only read/writes the skin_parts from the current layer.
+ *
+ * generateSkins therefore reads (depends on) data from mesh.layers[*].parts[*].insets and writes mesh.layers[n].parts[*].skin_parts
+ */
 void generateSkins(int layerNr, SliceMeshStorage& mesh, int downSkinCount, int upSkinCount, int wall_line_count, int innermost_wall_line_width, int insetCount, bool no_small_gaps_heuristic)
 {
     generateSkinAreas(layerNr, mesh, innermost_wall_line_width, downSkinCount, upSkinCount, wall_line_count, no_small_gaps_heuristic);
@@ -23,6 +32,12 @@ void generateSkins(int layerNr, SliceMeshStorage& mesh, int downSkinCount, int u
     }
 }
 
+/*
+ * This function is executed in a parallel region based on layer_nr.
+ * When modifying make sure any changes does not introduce data races.
+ *
+ * generateSkinAreas reads data from mesh.layers[*].parts[*].insets and writes to mesh.layers[n].parts[*].skin_parts
+ */
 void generateSkinAreas(int layer_nr, SliceMeshStorage& mesh, const int innermost_wall_line_width, int downSkinCount, int upSkinCount, int wall_line_count, bool no_small_gaps_heuristic)
 {
     SliceLayer& layer = mesh.layers[layer_nr];
@@ -31,7 +46,7 @@ void generateSkinAreas(int layer_nr, SliceMeshStorage& mesh, const int innermost
     {
         return;
     }
-    
+    int min_infill_area = mesh.getSettingInMillimeters("min_infill_area");
     for(unsigned int partNr = 0; partNr < layer.parts.size(); partNr++)
     {
         SliceLayerPart& part = layer.parts[partNr];
@@ -63,12 +78,22 @@ void generateSkinAreas(int layer_nr, SliceMeshStorage& mesh, const int innermost
         {
             if (static_cast<int>(layer_nr - downSkinCount) >= 0)
             {
-                downskin = downskin.difference(getInsidePolygons(mesh.layers[layer_nr - downSkinCount])); // skin overlaps with the walls
+                Polygons not_air = getInsidePolygons(mesh.layers[layer_nr - downSkinCount]);
+                if (min_infill_area > 0)
+                {
+                    not_air.removeSmallAreas(min_infill_area);
+                }
+                downskin = downskin.difference(not_air); // skin overlaps with the walls
             }
             
             if (static_cast<int>(layer_nr + upSkinCount) < static_cast<int>(mesh.layers.size()))
             {
-                upskin = upskin.difference(getInsidePolygons(mesh.layers[layer_nr + upSkinCount])); // skin overlaps with the walls
+                Polygons not_air = getInsidePolygons(mesh.layers[layer_nr + upSkinCount]);
+                if (min_infill_area > 0)
+                {
+                    not_air.removeSmallAreas(min_infill_area);
+                }
+                upskin = upskin.difference(not_air); // skin overlaps with the walls
             }
         }
         else 
@@ -80,6 +105,10 @@ void generateSkinAreas(int layer_nr, SliceMeshStorage& mesh, const int innermost
                 {
                     not_air = not_air.intersection(getInsidePolygons(mesh.layers[downskin_layer_nr]));
                 }
+                if (min_infill_area > 0)
+                {
+                    not_air.removeSmallAreas(min_infill_area);
+                }
                 downskin = downskin.difference(not_air); // skin overlaps with the walls
             }
             
@@ -90,6 +119,10 @@ void generateSkinAreas(int layer_nr, SliceMeshStorage& mesh, const int innermost
                 {
                     not_air = not_air.intersection(getInsidePolygons(mesh.layers[upskin_layer_nr]));
                 }
+                if (min_infill_area > 0)
+                {
+                    not_air.removeSmallAreas(min_infill_area);
+                }
                 upskin = upskin.difference(not_air); // skin overlaps with the walls
             }
         }
@@ -106,7 +139,12 @@ void generateSkinAreas(int layer_nr, SliceMeshStorage& mesh, const int innermost
     }
 }
 
-
+/*
+ * This function is executed in a parallel region based on layer_nr.
+ * When modifying make sure any changes does not introduce data races.
+ *
+ * generateSkinInsets only read/writes the skin_parts from the current layer.
+ */
 void generateSkinInsets(SliceLayerPart* part, const int wall_line_width, int insetCount)
 {
     if (insetCount == 0)
@@ -139,6 +177,12 @@ void generateSkinInsets(SliceLayerPart* part, const int wall_line_width, int ins
     }
 }
 
+/*
+ * This function is executed in a parallel region based on layer_nr.
+ * When modifying make sure any changes does not introduce data races.
+ *
+ * generateInfill read mesh.layers[n].parts[*].{insets,skin_parts,boundingBox} and write mesh.layers[n].parts[*].infill_area
+ */
 void generateInfill(int layerNr, SliceMeshStorage& mesh, const int innermost_wall_line_width, int infill_skin_overlap, int wall_line_count)
 {
     SliceLayer& layer = mesh.layers[layerNr];

src/sliceDataStorage.cpp

@@ -72,46 +72,12 @@ void SliceLayer::getSecondOrInnermostWalls(Polygons& layer_walls) const
     }
 }
 
-SliceMeshStorage::SliceMeshStorage(SettingsBaseVirtual* settings, unsigned int slice_layer_count)
-: SettingsMessenger(settings)
-, layer_nr_max_filled_layer(0)
-, inset0_config(PrintFeatureType::OuterWall)
-, insetX_config(PrintFeatureType::InnerWall)
-, skin_config(PrintFeatureType::Skin)
-, base_subdiv_cube(nullptr)
-, texture_proximity_processor(nullptr)
-{
-    layers.resize(slice_layer_count);
-    infill_config.reserve(MAX_INFILL_COMBINE);
-    for(int n=0; n<MAX_INFILL_COMBINE; n++)
-        infill_config.emplace_back(PrintFeatureType::Infill);
-}
-
-
-SliceMeshStorage::SliceMeshStorage(SliceMeshStorage&& old)
-: SettingsMessenger(SettingsBaseVirtual::parent)
-, layers(old.layers)
-, layer_nr_max_filled_layer(old.layer_nr_max_filled_layer)
-, inset0_config(old.inset0_config)
-, insetX_config(old.insetX_config)
-, skin_config(old.skin_config)
-, base_subdiv_cube(old.base_subdiv_cube)
-, texture_proximity_processor(old.texture_proximity_processor)
-{
-    old.base_subdiv_cube = nullptr;
-    old.texture_proximity_processor = nullptr;
-}
-
 SliceMeshStorage::~SliceMeshStorage()
 {
     if (base_subdiv_cube)
     {
         delete base_subdiv_cube;
     }
-    if (texture_proximity_processor)
-    {
-        delete texture_proximity_processor;
-    }
 }
 
 std::vector<RetractionConfig> SliceDataStorage::initializeRetractionConfigs()
@@ -158,11 +124,6 @@ SliceDataStorage::SliceDataStorage(MeshGroup* meshgroup) : SettingsMessenger(mes
 {
 }
 
-SliceDataStorage::~SliceDataStorage()
-{
-}
-
-
 Polygons SliceDataStorage::getLayerOutlines(int layer_nr, bool include_helper_parts, bool external_polys_only) const
 {
     if (layer_nr < 0 && layer_nr < -Raft::getFillerLayerCount(*this))
@@ -246,7 +207,7 @@ Polygons SliceDataStorage::getLayerSecondOrInnermostWalls(int layer_nr, bool inc
             {
                 const SliceLayer& layer = mesh.layers[layer_nr];
                 layer.getSecondOrInnermostWalls(total);
-                if (const_cast<SliceMeshStorage&>(mesh).getSettingAsSurfaceMode("magic_mesh_surface_mode") != ESurfaceMode::NORMAL) // TODO: make getSetting const? make settings.setting_values mapping mutable??
+                if (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") != ESurfaceMode::NORMAL)
                 {
                     total = total.unionPolygons(layer.openPolyLines.offsetPolyLine(100));
                 }

src/sliceDataStorage.h

@@ -12,7 +12,6 @@
 #include "MeshGroup.h"
 #include "PrimeTower.h"
 #include "GCodePathConfig.h"
-#include "textureProcessing/TextureProximityProcessor.h"
 
 namespace cura 
 {
@@ -146,13 +145,7 @@ public:
 
 class SubDivCube; // forward declaration to prevent dependency loop
 
-/*!
- * 
- * passes on settings from a Mesh object
- * 
- * Cannot be copied due to \ref SliceMeshStorage::texture_proximity_processor being governed by this object alone
- */
-class SliceMeshStorage : public SettingsMessenger, public NoCopy
+class SliceMeshStorage : public SettingsMessenger // passes on settings from a Mesh object
 {
 public:
     std::vector<SliceLayer> layers;
@@ -162,18 +155,25 @@ public:
     GCodePathConfig inset0_config;
     GCodePathConfig insetX_config;
     GCodePathConfig skin_config;
+    GCodePathConfig perimeter_gap_config;
     std::vector<GCodePathConfig> infill_config;
 
     SubDivCube* base_subdiv_cube;
 
-    TextureProximityProcessor* texture_proximity_processor; //!< TextureProximityProcessor per layer per mesh (if that mesh needs a proximity processor)
-
-    SliceMeshStorage(SettingsBaseVirtual* settings, unsigned int slice_layer_count);
-
-    /*!
-     * Move constructor
-     */
-    SliceMeshStorage(SliceMeshStorage&& old);
+    SliceMeshStorage(SettingsBaseVirtual* settings, unsigned int slice_layer_count)
+    : SettingsMessenger(settings)
+    , layer_nr_max_filled_layer(0)
+    , inset0_config(PrintFeatureType::OuterWall)
+    , insetX_config(PrintFeatureType::InnerWall)
+    , skin_config(PrintFeatureType::Skin)
+    , perimeter_gap_config(PrintFeatureType::Skin)
+    , base_subdiv_cube(nullptr)
+    {
+        layers.resize(slice_layer_count);
+        infill_config.reserve(MAX_INFILL_COMBINE);
+        for(int n=0; n<MAX_INFILL_COMBINE; n++)
+            infill_config.emplace_back(PrintFeatureType::Infill);
+    }
 
     virtual ~SliceMeshStorage();
 };
@@ -244,7 +244,9 @@ public:
      */
     SliceDataStorage(MeshGroup* meshgroup);
 
-    ~SliceDataStorage();
+    ~SliceDataStorage()
+    {
+    }
 
     /*!
      * Get all outlines within a given layer.

src/slicer.cpp

@@ -1,29 +1,21 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
+/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
+#include <stdio.h>
 
-#include "SlicerLayer.h"
-#include "../textureProcessing/TextureBumpMapProcessor.h"
-#include "../utils/SparsePointGridInclusive.h"
+#include <algorithm> // remove_if
 
-namespace cura
-{
+#include "utils/gettime.h"
+#include "utils/logoutput.h"
+#include "utils/SparsePointGridInclusive.h"
+
+#include "slicer.h"
+
+
+namespace cura {
 
 int largest_neglected_gap_first_phase = MM2INT(0.01); //!< distance between two line segments regarded as connected
 int largest_neglected_gap_second_phase = MM2INT(0.02); //!< distance between two line segments regarded as connected
 int max_stitch1 = MM2INT(10.0); //!< maximal distance stitched between open polylines to form polygons
 
-
-SlicerLayer::SlicerLayer(unsigned int layer_nr, Mesh* mesh, std::optional<TextureBumpMapProcessor::Settings> bump_map_settings, FaceNormalStorage* face_normal_storage)
-: layer_nr(layer_nr)
-{
-    if (bump_map_settings)
-    {
-        TexturedMesh* textured_mesh = dynamic_cast<TexturedMesh*>(mesh);
-        assert(textured_mesh && "we should only have bump map settings when there is a texture");
-        texture_bump_map.emplace(textured_mesh, *bump_map_settings, face_normal_storage);
-    }
-}
-
-
 void SlicerLayer::makeBasicPolygonLoops(const Mesh* mesh, Polygons& open_polylines)
 {
     for(unsigned int start_segment_idx = 0; start_segment_idx < segments.size(); start_segment_idx++)
@@ -782,11 +774,6 @@ void SlicerLayer::makePolygons(const Mesh* mesh, bool keep_none_closed, bool ext
     auto it = std::remove_if(polygons.begin(), polygons.end(), [snapDistance](PolygonRef poly) { return poly.shorterThan(snapDistance); });
     polygons.erase(it, polygons.end());
 
-    if (texture_bump_map)
-    {
-        texture_bump_map->processBumpMap(polygons, layer_nr);
-    }
-
     //Finally optimize all the polygons. Every point removed saves time in the long run.
     polygons.simplify();
 
@@ -799,4 +786,117 @@ void SlicerLayer::makePolygons(const Mesh* mesh, bool keep_none_closed, bool ext
     }
 }
 
-} // namespace cura
+
+Slicer::Slicer(Mesh* mesh, int initial, int thickness, int slice_layer_count, bool keep_none_closed, bool extensive_stitching)
+: mesh(mesh)
+{
+    assert(slice_layer_count > 0);
+
+    TimeKeeper slice_timer;
+
+    layers.resize(slice_layer_count);
+
+
+    for(int32_t layer_nr = 0; layer_nr < slice_layer_count; layer_nr++)
+    {
+        layers[layer_nr].z = initial + thickness * layer_nr;
+    }
+
+    for(unsigned int mesh_idx = 0; mesh_idx < mesh->faces.size(); mesh_idx++)
+    {
+        const MeshFace& face = mesh->faces[mesh_idx];
+        const MeshVertex& v0 = mesh->vertices[face.vertex_index[0]];
+        const MeshVertex& v1 = mesh->vertices[face.vertex_index[1]];
+        const MeshVertex& v2 = mesh->vertices[face.vertex_index[2]];
+        Point3 p0 = v0.p;
+        Point3 p1 = v1.p;
+        Point3 p2 = v2.p;
+        int32_t minZ = p0.z;
+        int32_t maxZ = p0.z;
+        if (p1.z < minZ) minZ = p1.z;
+        if (p2.z < minZ) minZ = p2.z;
+        if (p1.z > maxZ) maxZ = p1.z;
+        if (p2.z > maxZ) maxZ = p2.z;
+        int32_t layer_max = (maxZ - initial) / thickness;
+        for(int32_t layer_nr = (minZ - initial) / thickness; layer_nr <= layer_max; layer_nr++)
+        {
+            int32_t z = layer_nr * thickness + initial;
+            if (z < minZ) continue;
+            if (layer_nr < 0) continue;
+
+            SlicerSegment s;
+            s.endVertex = nullptr;
+            int end_edge_idx = -1;
+            if (p0.z < z && p1.z >= z && p2.z >= z)
+            {
+                s = project2D(p0, p2, p1, z);
+                end_edge_idx = 0;
+                if (p1.z == z)
+                {
+                    s.endVertex = &v1;
+                }
+            }
+            else if (p0.z > z && p1.z < z && p2.z < z)
+            {
+                s = project2D(p0, p1, p2, z);
+                end_edge_idx = 2;
+
+            }
+
+            else if (p1.z < z && p0.z >= z && p2.z >= z)
+            {
+                s = project2D(p1, p0, p2, z);
+                end_edge_idx = 1;
+                if (p2.z == z)
+                {
+                    s.endVertex = &v2;
+                }
+            }
+            else if (p1.z > z && p0.z < z && p2.z < z)
+            {
+                s = project2D(p1, p2, p0, z);
+                end_edge_idx = 0;
+
+            }
+
+            else if (p2.z < z && p1.z >= z && p0.z >= z)
+            {
+                s = project2D(p2, p1, p0, z);
+                end_edge_idx = 2;
+                if (p0.z == z)
+                {
+                    s.endVertex = &v0;
+                }
+            }
+            else if (p2.z > z && p1.z < z && p0.z < z)
+            {
+                s = project2D(p2, p0, p1, z);
+                end_edge_idx = 1;
+            }
+            else
+            {
+                //Not all cases create a segment, because a point of a face could create just a dot, and two touching faces
+                //  on the slice would create two segments
+                continue;
+            }
+            layers[layer_nr].face_idx_to_segment_idx.insert(std::make_pair(mesh_idx, layers[layer_nr].segments.size()));
+            s.faceIndex = mesh_idx;
+            s.endOtherFaceIdx = face.connected_face_index[end_edge_idx];
+            s.addedToPolygon = false;
+            layers[layer_nr].segments.push_back(s);
+        }
+    }
+    log("slice of mesh took %.3f seconds\n",slice_timer.restart());
+
+    std::vector<SlicerLayer>& layers_ref = layers; // force layers not to be copied into the threads
+#pragma omp parallel for default(none) shared(mesh,layers_ref) firstprivate(keep_none_closed, extensive_stitching)
+    for(unsigned int layer_nr=0; layer_nr<layers_ref.size(); layer_nr++)
+    {
+        layers_ref[layer_nr].makePolygons(mesh, keep_none_closed, extensive_stitching);
+    }
+
+    mesh->expandXY(mesh->getSettingInMicrons("xy_offset"));
+    log("slice make polygons took %.3f seconds\n",slice_timer.restart());
+}
+
+}//namespace cura

src/slicer.h

@@ -1,46 +1,58 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-#ifndef SLICER_SLICER_LAYER_H
-#define SLICER_SLICER_LAYER_H
+/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
+#ifndef SLICER_H
+#define SLICER_H
 
-#include <unordered_map>
+#include <queue>
 
-#include "../utils/optional.h"
-#include "../mesh.h"
-#include "../utils/intpoint.h"
-#include "../utils/polygon.h"
+#include "mesh.h"
+#include "utils/polygon.h"
+/*
+    The Slicer creates layers of polygons from an optimized 3D model.
+    The result of the Slicer is a list of polygons without any order or structure.
+*/
+namespace cura {
 
-#include "SlicerSegment.h"
-#include "GapCloserResult.h"
-#include "ClosePolygonResult.h"
-
-#include "../textureProcessing/MatSegment.h"
-#include "../textureProcessing/TextureBumpMapProcessor.h"
-#include "../textureProcessing/FaceNormalStorage.h"
-
-namespace cura
+class SlicerSegment
 {
+public:
+    Point start, end;
+    int faceIndex = -1;
+    // The index of the other face connected via the edge that created end
+    int endOtherFaceIdx = -1;
+    // If end corresponds to a vertex of the mesh, then this is populated
+    // with the vertex that it ended on.
+    const MeshVertex *endVertex = nullptr;
+    bool addedToPolygon = false;
+};
+
+class ClosePolygonResult
+{   //The result of trying to find a point on a closed polygon line. This gives back the point index, the polygon index, and the point of the connection.
+    //The line on which the point lays is between pointIdx-1 and pointIdx
+public:
+    Point intersectionPoint;
+    int polygonIdx = -1;
+    unsigned int pointIdx = -1;
+};
+class GapCloserResult
+{
+public:
+    int64_t len = -1;
+    int polygonIdx = -1;
+    unsigned int pointIdxA = -1;
+    unsigned int pointIdxB = -1;
+    bool AtoB = false;
+};
 
 class SlicerLayer
 {
 public:
-    /*!
-     * \param mesh For which mesh this layer is sliced
-     * \param bump_map_settings The settings with which to create a TextureBumpMapProcessor - if provided
-     * \param face_normal_storage The face normal statistics to be used in the \p bump_map_settings - if provided
-     */
-    SlicerLayer(unsigned int layer_nr, Mesh* mesh, std::optional<TextureBumpMapProcessor::Settings> bump_map_settings, FaceNormalStorage* face_normal_storage);
-
     std::vector<SlicerSegment> segments;
     std::unordered_map<int, int> face_idx_to_segment_idx; // topology
 
     int z = -1;
-    unsigned int layer_nr;
-
     Polygons polygons;
     Polygons openPolylines;
 
-    std::optional<TextureBumpMapProcessor> texture_bump_map; //!< the bump map to apply to the outlines - if any
-
     /*!
      * Connect the segments into polygons for this layer of this \p mesh
      *
@@ -471,6 +483,44 @@ private:
                                   bool allow_reverse);
 };
 
-} // namespace cura
+class Slicer
+{
+public:
+    std::vector<SlicerLayer> layers;
 
-#endif // SLICER_SLICER_LAYER_H
+    const Mesh* mesh = nullptr; //!< The sliced mesh
+
+    Slicer(Mesh* mesh, int initial, int thickness, int slice_layer_count, bool keepNoneClosed, bool extensiveStitching);
+
+    /*!
+     * Linear interpolation
+     *
+     * Get the Y of a point with X \p x in the line through (\p x0, \p y0) and (\p x1, \p y1)
+     */
+    int64_t interpolate(int64_t x, int64_t x0, int64_t x1, int64_t y0, int64_t y1) const
+    {
+        int64_t dx_01 = x1 - x0;
+        int64_t num = (y1 - y0) * (x - x0);
+        num += num > 0 ? dx_01/2 : -dx_01/2; // add in offset to round result
+        int64_t y = y0 + num / dx_01;
+        return y;
+    }
+
+    SlicerSegment project2D(Point3& p0, Point3& p1, Point3& p2, int32_t z) const
+    {
+        SlicerSegment seg;
+
+        seg.start.X = interpolate(z, p0.z, p1.z, p0.x, p1.x);
+        seg.start.Y = interpolate(z, p0.z, p1.z, p0.y, p1.y);
+        seg.end  .X = interpolate(z, p0.z, p2.z, p0.x, p2.x);
+        seg.end  .Y = interpolate(z, p0.z, p2.z, p0.y, p2.y);
+
+        return seg;
+    }
+
+    void dumpSegmentsToHTML(const char* filename);
+};
+
+}//namespace cura
+
+#endif//SLICER_H

src/slicer/ClosePolygonResult.h

@@ -1,21 +0,0 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-#ifndef SLICER_CLOSE_POLYGON_RESULT_H
-#define SLICER_CLOSE_POLYGON_RESULT_H
-
-#include "../utils/intpoint.h"
-
-namespace cura
-{
-
-class ClosePolygonResult
-{   //The result of trying to find a point on a closed polygon line. This gives back the point index, the polygon index, and the point of the connection.
-    //The line on which the point lays is between pointIdx-1 and pointIdx
-public:
-    Point intersectionPoint;
-    int polygonIdx = -1;
-    unsigned int pointIdx = -1;
-};
-
-} // namespace cura
-
-#endif // SLICER_CLOSE_POLYGON_RESULT_H

src/slicer/GapCloserResult.h

@@ -1,22 +0,0 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-#ifndef SLICER_GAP_CLOSER_RESULT_H
-#define SLICER_GAP_CLOSER_RESULT_H
-
-#include "../utils/intpoint.h"
-
-namespace cura
-{
-
-class GapCloserResult
-{
-public:
-    int64_t len = -1;
-    int polygonIdx = -1;
-    unsigned int pointIdxA = -1;
-    unsigned int pointIdxB = -1;
-    bool AtoB = false;
-};
-
-} // namespace cura
-
-#endif // SLICER_GAP_CLOSER_RESULT_H

src/slicer/Slicer.cpp

@@ -1,180 +0,0 @@
-/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
-#include <stdio.h>
-
-#include "../utils/gettime.h"
-#include "../utils/logoutput.h"
-#include "../textureProcessing/MatCoord.h"
-#include "../textureProcessing/FaceNormalStorage.h"
-
-#include "Slicer.h"
-
-namespace cura {
-
-
-void Slicer::project2D(unsigned int face_idx, const Point3 p[3], unsigned int idx_shared, unsigned int idx_first, unsigned int idx_second, int32_t z, int32_t layer_nr, SlicerSegment& seg)
-{
-    const Point3& p0 = p[idx_shared];
-    const Point3& p1 = p[idx_first];
-    const Point3& p2 = p[idx_second];
-
-    seg.start.X = interpolate(z, p0.z, p1.z, p0.x, p1.x);
-    seg.start.Y = interpolate(z, p0.z, p1.z, p0.y, p1.y);
-    seg.end  .X = interpolate(z, p0.z, p2.z, p0.x, p2.x);
-    seg.end  .Y = interpolate(z, p0.z, p2.z, p0.y, p2.y);
-    if (textured_mesh)
-    {
-        MatSegment mat_segment;
-        bool got_texture_coords = textured_mesh->sliceFaceTexture(face_idx, idx_shared, idx_first, idx_second, z, seg.start, seg.end, mat_segment);
-        SlicerLayer& layer = layers[layer_nr];
-        if (got_texture_coords)
-        {
-            if (layer.texture_bump_map)
-            {
-                layer.texture_bump_map->registerTexturedFaceSlice(seg, mat_segment);
-            }
-            if (texture_proximity_processor)
-            {
-                texture_proximity_processor->registerTexturedFaceSlice(seg, mat_segment, layer_nr);
-            }
-        }
-    }
-}
-
-Slicer::Slicer(Mesh* mesh, int initial, int thickness, unsigned int slice_layer_count, bool keep_none_closed, bool extensive_stitching, TextureProximityProcessor* texture_proximity_processor)
-: mesh(mesh)
-, textured_mesh(dynamic_cast<TexturedMesh*>(mesh))
-, texture_proximity_processor(texture_proximity_processor)
-{
-    assert((int) slice_layer_count > 0);
-
-    TimeKeeper slice_timer;
-
-    std::optional<TextureBumpMapProcessor::Settings> bump_map_settings;
-    FaceNormalStorage* face_normal_storage = nullptr;
-    if (mesh->getSettingBoolean("bump_map_enabled"))
-    {
-        bump_map_settings.emplace(mesh);
-        if (mesh->getSettingAsRatio("bump_map_face_angle_correction") != 0.0)
-        {
-            face_normal_storage = new FaceNormalStorage(mesh);
-        }
-    }
-
-    layers.reserve(slice_layer_count);
-    for (uint32_t layer_nr = 0; layer_nr < slice_layer_count; layer_nr++)
-    { // initialize all layers
-        layers.emplace_back(layer_nr, mesh, bump_map_settings, face_normal_storage);
-        assert(&layers.back() == &layers[layer_nr] && "We should just have emplaced the last layer!");
-        layers[layer_nr].z = initial + thickness * layer_nr;
-    }
-
-    bool bump_map_alternate = mesh->getSettingBoolean("bump_map_alternate");
-    int extruder_nr = mesh->getSettingAsIndex("extruder_nr");
-
-    for(unsigned int face_idx = 0; face_idx < mesh->faces.size(); face_idx++)
-    {
-        const MeshFace& face = mesh->faces[face_idx];
-        const MeshVertex& v0 = mesh->vertices[face.vertex_index[0]];
-        const MeshVertex& v1 = mesh->vertices[face.vertex_index[1]];
-        const MeshVertex& v2 = mesh->vertices[face.vertex_index[2]];
-        Point3 p[3] =
-            { mesh->vertices[face.vertex_index[0]].p
-            , mesh->vertices[face.vertex_index[1]].p
-            , mesh->vertices[face.vertex_index[2]].p };
-        Point3& p0 = p[0];
-        Point3& p1 = p[1];
-        Point3& p2 = p[2];
-        int32_t minZ = p0.z;
-        int32_t maxZ = p0.z;
-        if (p1.z < minZ) minZ = p1.z;
-        if (p2.z < minZ) minZ = p2.z;
-        if (p1.z > maxZ) maxZ = p1.z;
-        if (p2.z > maxZ) maxZ = p2.z;
-        int32_t layer_max = (maxZ - initial) / thickness;
-        int32_t layer_min = (minZ - initial + thickness - 1) / thickness; //  + thickness - 1 to get the first layer above or at minZ
-        for (int32_t layer_nr = layer_min; layer_nr <= layer_max; layer_nr++)
-        {
-            if (bump_map_alternate && layer_nr % 2 == extruder_nr) // TODO only works for the first two extruders!
-            {
-                continue;
-            }
-            int32_t z = layer_nr * thickness + initial;
-            if (z < minZ) continue;
-            if (layer_nr < 0) continue;
-
-            SlicerSegment s;
-            s.endVertex = nullptr;
-            s.faceIndex = face_idx;
-            assert(face_idx >= 0);
-            s.addedToPolygon = false;
-            if (p0.z < z && p1.z >= z && p2.z >= z)
-            {
-                s.endOtherFaceIdx = face.connected_face_index[0];
-                if (p1.z == z)
-                {
-                    s.endVertex = &v1;
-                }
-                project2D(face_idx, p, 0, 2, 1, z, layer_nr, s);
-            }
-            else if (p0.z > z && p1.z < z && p2.z < z)
-            {
-                s.endOtherFaceIdx = face.connected_face_index[2];
-                project2D(face_idx, p, 0, 1, 2, z, layer_nr, s);
-
-            }
-
-            else if (p1.z < z && p0.z >= z && p2.z >= z)
-            {
-                s.endOtherFaceIdx = face.connected_face_index[1];
-                if (p2.z == z)
-                {
-                    s.endVertex = &v2;
-                }
-                project2D(face_idx, p, 1, 0, 2, z, layer_nr, s);
-            }
-            else if (p1.z > z && p0.z < z && p2.z < z)
-            {
-                s.endOtherFaceIdx = face.connected_face_index[0];
-                project2D(face_idx, p, 1, 2, 0, z, layer_nr, s);
-
-            }
-
-            else if (p2.z < z && p1.z >= z && p0.z >= z)
-            {
-                s.endOtherFaceIdx = face.connected_face_index[2];
-                if (p0.z == z)
-                {
-                    s.endVertex = &v0;
-                }
-                project2D(face_idx, p, 2, 1, 0, z, layer_nr, s);
-            }
-            else if (p2.z > z && p1.z < z && p0.z < z)
-            {
-                s.endOtherFaceIdx = face.connected_face_index[1];
-                project2D(face_idx, p, 2, 0, 1, z, layer_nr, s);
-            }
-            else
-            {
-                //Not all cases create a segment, because a point of a face could create just a dot, and two touching faces
-                //  on the slice would create two segments
-                continue;
-            }
-            layers[layer_nr].face_idx_to_segment_idx.insert(std::make_pair(face_idx, layers[layer_nr].segments.size()));
-            layers[layer_nr].segments.push_back(s);
-        }
-    }
-    log("slice of mesh took %.3f seconds\n",slice_timer.restart());
-    for(unsigned int layer_nr=0; layer_nr<layers.size(); layer_nr++)
-    {
-        layers[layer_nr].makePolygons(mesh, keep_none_closed, extensive_stitching);
-    }
-    mesh->expandXY(mesh->getSettingInMicrons("xy_offset"));
-    log("slice make polygons took %.3f seconds\n",slice_timer.restart());
-
-    if (face_normal_storage)
-    {
-        delete face_normal_storage;
-    }
-}
-
-}//namespace cura

src/slicer/Slicer.h

@@ -1,75 +0,0 @@
-/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
-#ifndef SLICER_SLICER_H
-#define SLICER_SLICER_H
-
-#include <queue>
-
-#include "../mesh.h"
-#include "../utils/polygon.h"
-
-#include "SlicerSegment.h"
-#include "ClosePolygonResult.h"
-#include "SlicerLayer.h"
-
-#include "../textureProcessing/MatSegment.h"
-#include "../textureProcessing/TextureProximityProcessor.h"
-
-/*
-    The Slicer creates layers of polygons from an optimized 3D model.
-    The result of the Slicer is a list of polygons without any order or structure.
-*/
-namespace cura {
-
-
-
-
-
-class Slicer
-{
-public:
-    std::vector<SlicerLayer> layers;
-
-    const Mesh* mesh = nullptr; //!< The sliced mesh
-
-    const TexturedMesh* textured_mesh; //!< Pointer to the textured mesh if \ref Slicer::mesh is a TexturedMesh
-
-    TextureProximityProcessor* texture_proximity_processor; //!< Containers for each layer for fast lookup of textures being defined in the proximity of the lookup point
-
-    /*!
-     * 
-     * \param texture_proximity_processors (optional) A TextureProximityProcessor for all layers in the mesh
-     */
-    Slicer(Mesh* mesh, int initial, int thickness, unsigned int slice_layer_count, bool keepNoneClosed, bool extensiveStitching, TextureProximityProcessor* texture_proximity_processors);
-
-    
-    
-    /*!
-     * Linear interpolation
-     *
-     * Get the Y of a point with X \p x in the line through (\p x0, \p y0) and (\p x1, \p y1)
-     * 
-     * \param p The face vertice locations in the order the vertices are given in the face
-     */
-    int64_t interpolate(int64_t x, int64_t x0, int64_t x1, int64_t y0, int64_t y1) const
-    {
-        int64_t dx_01 = x1 - x0;
-        int64_t num = (y1 - y0) * (x - x0);
-        num += num > 0 ? dx_01/2 : -dx_01/2; // add in offset to round result
-        int64_t y = y0 + num / dx_01;
-        return y;
-    }
-
-    /*!
-     * 
-     * \warning this function requires result.faceIndex to be correctly set already
-     * 
-     * \p result where to store the start and end of the sliced segment
-     */
-    void project2D(unsigned int face_idx, const Point3 p[3], unsigned int idx_shared, unsigned int idx_first, unsigned int idx_second, int32_t z, int32_t layer_nr, SlicerSegment& result);
-
-    void dumpSegmentsToHTML(const char* filename);
-};
-
-}//namespace cura
-
-#endif//SLICER_SLICER_H

src/slicer/SlicerSegment.h

@@ -1,59 +0,0 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-#ifndef SLICER_SLICER_SEGMENT_H
-#define SLICER_SLICER_SEGMENT_H
-
-#include <functional>
-
-#include "../utils/intpoint.h"
-
-#include "../mesh.h"
-
-namespace cura
-{
-
-class SlicerSegment
-{
-public:
-    Point start, end;
-    int faceIndex = -1;
-    // The index of the other face connected via the edge that created end
-    int endOtherFaceIdx = -1;
-    // If end corresponds to a vertex of the mesh, then this is populated
-    // with the vertex that it ended on.
-    const MeshVertex *endVertex = nullptr;
-    bool addedToPolygon = false;
-
-    SlicerSegment() //!< non-initializing constructor
-    {}
-    SlicerSegment(Point start, Point end) //!< partially initializing constructor
-    : start(start)
-    , end(end)
-    {}
-    /*!
-     * equivalence testing irrespective of start/end order
-     */
-    bool operator==(const SlicerSegment& b) const
-    {
-        return (start == b.start && end == b.end) || (start == b.end && end == b.start);
-    }
-};
-
-} // namespace cura
-
-namespace std
-{
-    /*!
-     * hash function irrespective of start/end order
-     */
-    template<> struct hash<cura::SlicerSegment>
-    {
-        typedef std::size_t result_type;
-        result_type operator()(cura::SlicerSegment const& s) const
-        {
-            return std::hash<cura::Point>()(cura::operator+(s.start, s.end));
-        }
-    };
-} // namespace std
-
-
-#endif // SLICER_SLICER_SEGMENT_H

src/support.cpp

@@ -90,6 +90,7 @@ void AreaSupport::generateSupportAreas(SliceDataStorage& storage, unsigned int l
         storage.support.supportLayers.resize(layer_count);
     }
 
+    // generate support areas
     for (unsigned int mesh_idx = 0; mesh_idx < storage.meshes.size(); mesh_idx++)
     {
         SliceMeshStorage& mesh = storage.meshes[mesh_idx];
@@ -100,25 +101,33 @@ void AreaSupport::generateSupportAreas(SliceDataStorage& storage, unsigned int l
         std::vector<Polygons> supportAreas;
         supportAreas.resize(layer_count, Polygons());
         generateSupportAreas(storage, mesh_idx, layer_count, supportAreas);
-        
-        if (mesh.getSettingBoolean("support_interface_enable"))
+
+        for (unsigned int layer_idx = 0; layer_idx < layer_count; layer_idx++)
         {
-            generateSupportInterface(storage, mesh, supportAreas, layer_count);
-        }
-        else 
-        {
-            for (unsigned int layer_idx = 0; layer_idx < layer_count ; layer_idx++)
-            {
-                storage.support.supportLayers[layer_idx].supportAreas.add(supportAreas[layer_idx]);
-            }
+            storage.support.supportLayers[layer_idx].supportAreas.add(supportAreas[layer_idx]);
         }
     }
-    
+
     for (unsigned int layer_idx = 0; layer_idx < layer_count ; layer_idx++)
     {
         Polygons& support_areas = storage.support.supportLayers[layer_idx].supportAreas;
         support_areas = support_areas.unionPolygons();
     }
+
+    // handle support interface
+    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"))
+        {
+            continue;
+        }
+
+        if (mesh.getSettingBoolean("support_interface_enable"))
+        {
+            generateSupportInterface(storage, mesh, layer_count);
+        }
+    }
 }
 
 /* 
@@ -156,6 +165,7 @@ void AreaSupport::generateSupportAreas(SliceDataStorage& storage, unsigned int m
     const int supportTowerDiameter = mesh.getSettingInMicrons("support_tower_diameter");
     const int supportMinAreaSqrt = mesh.getSettingInMicrons("support_minimal_diameter");
     const double supportTowerRoofAngle = mesh.getSettingInAngleRadians("support_tower_roof_angle");
+    const bool use_towers = mesh.getSettingBoolean("support_use_towers") && supportMinAreaSqrt > 0;
 
     const int layerThickness = storage.getSettingInMicrons("layer_height");
     const int supportXYDistance = mesh.getSettingInMicrons("support_xy_distance");
@@ -225,7 +235,10 @@ void AreaSupport::generateSupportAreas(SliceDataStorage& storage, unsigned int m
         
     
     std::vector<std::pair<int, std::vector<Polygons>>> overhang_points; // stores overhang_points along with the layer index at which the overhang point occurs
-    AreaSupport::detectOverhangPoints(storage, mesh, overhang_points, layer_count, supportMinAreaSqrt);
+    if (use_towers)
+    {
+        AreaSupport::detectOverhangPoints(storage, mesh, overhang_points, layer_count, supportMinAreaSqrt);
+    }
 
     std::deque<std::pair<Polygons, Polygons>> basic_and_full_overhang_above;
     for (unsigned int layer_idx = support_layer_count - 1; layer_idx != support_layer_count - 1 - layerZdistanceTop ; layer_idx--)
@@ -255,7 +268,7 @@ void AreaSupport::generateSupportAreas(SliceDataStorage& storage, unsigned int m
             supportLayer_this = supportLayer_this.offset(extension_offset);
         }
 
-        if (supportMinAreaSqrt > 0)
+        if (use_towers)
         {
             // handle straight walls
             AreaSupport::handleWallStruts(supportLayer_this, supportMinAreaSqrt, supportTowerDiameter);
@@ -342,14 +355,14 @@ void AreaSupport::generateSupportAreas(SliceDataStorage& storage, unsigned int m
     }
 
     //Enforce top Z distance.
-    if (layerZdistanceTop > 0)
+    if (layerZdistanceTop > 1)
     {
         // this is performed after the main support generation loop above, because it affects the joining of polygons
         // if this would be performed in the main loop then some support would not have been generated under the overhangs and consequently no support is generated for that,
         // meaning almost no support would be generated in some cases which definitely need support.
-        for (size_t layer_idx = 0; layer_idx < storage.support.supportLayers.size() && layer_idx < support_layer_count - layerZdistanceTop; layer_idx++)
+        for (size_t layer_idx = 0; layer_idx < storage.support.supportLayers.size() && layer_idx < support_layer_count - (layerZdistanceTop - 1); layer_idx++)
         {
-            supportAreas[layer_idx] = supportAreas[layer_idx].difference(storage.getLayerOutlines(layer_idx + layerZdistanceTop, false));
+            supportAreas[layer_idx] = supportAreas[layer_idx].difference(storage.getLayerOutlines(layer_idx + layerZdistanceTop - 1, false));
         }
     }
 
@@ -559,7 +572,7 @@ void AreaSupport::handleWallStruts(
 }
 
 
-void AreaSupport::generateSupportInterface(SliceDataStorage& storage, const SliceMeshStorage& mesh, std::vector<Polygons>& support_areas, const unsigned int layer_count)
+void AreaSupport::generateSupportInterface(SliceDataStorage& storage, const SliceMeshStorage& mesh, const unsigned int layer_count)
 {
     const unsigned int roof_layer_count = round_divide(mesh.getSettingInMicrons("support_roof_height"), storage.getSettingInMicrons("layer_height"));
     const unsigned int bottom_layer_count = round_divide(mesh.getSettingInMicrons("support_bottom_height"), storage.getSettingInMicrons("layer_height"));
@@ -576,44 +589,41 @@ void AreaSupport::generateSupportInterface(SliceDataStorage& storage, const Slic
 
         const unsigned int top_layer_idx_above = layer_idx + roof_layer_count + z_distance_top;
         const unsigned int bottom_layer_idx_below = std::max(0, int(layer_idx) - int(bottom_layer_count) - int(z_distance_bottom));
-        if (top_layer_idx_above < supportLayers.size())
+        if (top_layer_idx_above >= supportLayers.size())
         {
-            Polygons roofs;
-            if (roof_layer_count > 0)
-            {
-                Polygons model;
-                const unsigned int n_scans = std::max(1u, (roof_layer_count - 1) / skip_layer_count);
-                const float z_skip = std::max(1.0f, float(roof_layer_count - 1) / float(n_scans));
-                for (float layer_idx_above = top_layer_idx_above; layer_idx_above > layer_idx + z_distance_top; layer_idx_above -= z_skip)
-                {
-                    const Polygons outlines_above = mesh.layers[std::round(layer_idx_above)].getOutlines();
-                    model = model.unionPolygons(outlines_above);
-                }
-                roofs = support_areas[layer_idx].intersection(model);
-            }
-            Polygons bottoms;
-            if (bottom_layer_count > 0)
-            {
-                Polygons model;
-                const unsigned int n_scans = std::max(1u, (bottom_layer_count - 1) / skip_layer_count);
-                const float z_skip = std::max(1.0f, float(bottom_layer_count - 1) / float(n_scans));
-                for (float layer_idx_below = bottom_layer_idx_below; std::round(layer_idx_below) < (int)(layer_idx - z_distance_bottom); layer_idx_below += z_skip)
-                {
-                    const Polygons outlines_below = mesh.layers[std::round(layer_idx_below)].getOutlines();
-                    model = model.unionPolygons(outlines_below);
-                }
-                bottoms = support_areas[layer_idx].intersection(model);
-            }
-            // expand skin a bit so that we're sure it's not too thin to be printed.
-            Polygons skin = roofs.unionPolygons(bottoms).offset(interface_line_width).intersection(support_areas[layer_idx]);
-            skin.removeSmallAreas(1.0);
-            layer.skin.add(skin);
-            layer.supportAreas.add(support_areas[layer_idx].difference(layer.skin));
+            continue;
         }
-        else 
+        Polygons roofs;
+        if (roof_layer_count > 0)
         {
-            layer.skin.add(support_areas[layer_idx]);
+            Polygons model;
+            const unsigned int n_scans = std::max(1u, (roof_layer_count - 1) / skip_layer_count);
+            const float z_skip = std::max(1.0f, float(roof_layer_count - 1) / float(n_scans));
+            for (float layer_idx_above = top_layer_idx_above; layer_idx_above > layer_idx + z_distance_top; layer_idx_above -= z_skip)
+            {
+                const Polygons outlines_above = mesh.layers[std::round(layer_idx_above)].getOutlines();
+                model = model.unionPolygons(outlines_above);
+            }
+            roofs = layer.supportAreas.intersection(model);
         }
+        Polygons bottoms;
+        if (bottom_layer_count > 0)
+        {
+            Polygons model;
+            const unsigned int n_scans = std::max(1u, (bottom_layer_count - 1) / skip_layer_count);
+            const float z_skip = std::max(1.0f, float(bottom_layer_count - 1) / float(n_scans));
+            for (float layer_idx_below = bottom_layer_idx_below; std::round(layer_idx_below) < (int)(layer_idx - z_distance_bottom); layer_idx_below += z_skip)
+            {
+                const Polygons outlines_below = mesh.layers[std::round(layer_idx_below)].getOutlines();
+                model = model.unionPolygons(outlines_below);
+            }
+            bottoms = layer.supportAreas.intersection(model);
+        }
+        // expand skin a bit so that we're sure it's not too thin to be printed.
+        Polygons skin = roofs.unionPolygons(bottoms).offset(interface_line_width).intersection(layer.supportAreas);
+        skin.removeSmallAreas(1.0);
+        layer.skin.add(skin);
+        layer.supportAreas = layer.supportAreas.difference(layer.skin);
     }
 }
 

src/support.h

@@ -36,10 +36,9 @@ private:
      * 
      * \param storage Output storage: support area + support skin area output
      * \param mesh The mesh to generate support skins for.
-     * \param support_areas The basic support areas for the current mesh
      * \param layer_count The number of layers in this mesh group.
      */
-    static void generateSupportInterface(SliceDataStorage& storage, const SliceMeshStorage& mesh, std::vector<Polygons>& support_areas, const unsigned int layer_count);
+    static void generateSupportInterface(SliceDataStorage& storage, const SliceMeshStorage& mesh, const unsigned int layer_count);
 
     /*!
      * Join current support layer with the support of the layer above, (make support conical) and perform smoothing etc operations.

src/textureProcessing/FaceNormalStorage.cpp

@@ -1,59 +0,0 @@
-/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
-
-#include <limits> // numeric_limits
-#include <cmath> // isnan
-
-#include "FaceNormalStorage.h"
-
-#include <math.h> // debug
-
-#define NORMAL_LENGTH 10000
-
-namespace cura
-{
-
-FaceNormalStorage::FaceNormalStorage(Mesh* mesh)
-{
-    face_normal_vertical_component.reserve(mesh->faces.size());
-    for (MeshFace& face : mesh->faces)
-    {
-        Point3 p0 = mesh->vertices[face.vertex_index[0]].p;
-        Point3 p1 = mesh->vertices[face.vertex_index[1]].p;
-        Point3 p2 = mesh->vertices[face.vertex_index[2]].p;
-        face_normal_vertical_component.emplace_back(computeFaceTanAngle(p0, p1, p2));
-    }
-}
-
-float FaceNormalStorage::computeFaceTanAngle(const Point3 p0, const Point3 p1, const Point3 p2) const
-{
-    Point3 v01 = p1 - p0;
-    Point3 v01_n = v01.normal(NORMAL_LENGTH);
-    Point3 v02 = p2 - p0;
-    Point3 v02_n = v02.normal(NORMAL_LENGTH);
-    Point3 normal_dir = v01_n.cross(v02_n);
-    coord_t z_component = normal_dir.z;
-    coord_t xy_component = vSize(Point(normal_dir.x, normal_dir.y));
-    if (xy_component > -2 && xy_component < 2)
-    {
-        if (z_component > 0)
-        {
-            return std::numeric_limits<float>::infinity();
-        }
-        else
-        {
-            return -1 * std::numeric_limits<float>::infinity();
-        }
-    }
-    float ret = (float) z_component / (float) xy_component;
-    assert(!std::isnan(ret));
-    assert(!std::isnan(-ret));
-    return ret;
-}
-
-float FaceNormalStorage::getFaceTanAngle(unsigned int face_idx)
-{
-    return face_normal_vertical_component[face_idx];
-}
-
-
-} // namespace cura

src/textureProcessing/FaceNormalStorage.h

@@ -1,42 +0,0 @@
-/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
-#ifndef TEXTURE_PROCESSING_FACE_NORMAL_STORAGE_H
-#define TEXTURE_PROCESSING_FACE_NORMAL_STORAGE_H
-
-#include "../mesh.h"
-#include "../utils/NoCopy.h"
-
-namespace cura
-{
-
-/*!
- * helper class for storing mesh face data to be used by each TextureBumpMapProcessor of one mesh
- */
-class FaceNormalStorage : NoCopy
-{
-public:
-    /*!
-     * Constructor to compute the tan angle for all faces in the model.
-     */
-    FaceNormalStorage(Mesh* mesh);
-
-    /*!
-     * Get the horizontal component of the face normal
-     * 
-     * returns a negative amount for faces angling downward
-     * (TODO verify above sentence)
-     * \return the ratio between the vertical and the horizontal aspect of the normal of the face with index \p face_index (in the list of faes in the \ref Mesh)
-     */
-    float getFaceTanAngle(unsigned int face_idx);
-protected:
-
-    /*!
-     * compute the tan angle of one face
-     * \p p0, \p p1 and \p p2 should be in CCW order
-     */
-    float computeFaceTanAngle(const Point3 p0, const Point3 p1, const Point3 p2) const;
-    std::vector<float> face_normal_vertical_component; //!< for each face the horizontal component of the normal angle
-};
-
-} // namespace cura
-
-#endif // TEXTURE_PROCESSING_FACE_NORMAL_STORAGE_H

src/textureProcessing/MatCoord.h

@@ -1,44 +0,0 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-#ifndef TEXTURE_PROCESSING_MAT_COORD_H
-#define TEXTURE_PROCESSING_MAT_COORD_H
-
-#include "../utils/FPoint.h"
-
-#include "Material.h"
-
-namespace cura
-{
-
-/*!
- * Coordinates in a specific texture bitmap 
- */
-struct MatCoord
-{
-    FPoint coords;
-    const Material* mat; //!< Material id
-    MatCoord() //!< non-initializing constructor
-    {}
-    MatCoord(FPoint coords, const Material& mat) //!< constructor
-    : coords(coords)
-    , mat(&mat)
-    {}
-
-    /*!
-     * Get the color of the material to which this coordinate is pointing
-     */
-    float getColor(ColourUsage color) const
-    {
-        if (mat)
-        {
-            return mat->getColor(coords.x, coords.y, color);
-        }
-        else
-        {
-            return 0.0f;
-        }
-    }
-};
-
-} // namespace cura
-
-#endif // TEXTURE_PROCESSING_MAT_COORD_H

src/textureProcessing/MatSegment.h

@@ -1,27 +0,0 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-#ifndef TEXTURE_PROCESSING_MAT_SEGMENT_H
-#define TEXTURE_PROCESSING_MAT_SEGMENT_H
-
-#include "MatCoord.h"
-
-namespace cura
-{
-
-/*!
- * Coordinates in a specific texture bitmap 
- */
-struct MatSegment
-{
-    MatCoord start;
-    MatCoord end;
-    MatSegment() //!< non-initializing constructor
-    {}
-    MatSegment(MatCoord start, MatCoord end)
-    : start(start)
-    , end(end)
-    {}
-};
-
-} // namespace cura
-
-#endif // TEXTURE_PROCESSING_MAT_SEGMENT_H

src/textureProcessing/Material.cpp

@@ -1,178 +0,0 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-
-#include <limits> // numeric limits
-#include <algorithm> // min max
-
-#include <iostream>
-#include <cassert>
-
-
-#include "Material.h"
-
-#define STBI_FAILURE_USERMSG // enable user friendly bug messages for STB lib
-#define STB_IMAGE_IMPLEMENTATION // needed in order to enable the implementation of libs/std_image.h
-#include "stb/stb_image.h"
-
-namespace cura
-{
-/*!
- * custom destructor for the data to be used by the shared_pointer
- */
-struct ArrayDeleter
-{
-    void operator ()(unsigned char* p)
-    { 
-        stbi_image_free(p); 
-    }
-};
-
-Material::Material()
-: data(nullptr, ArrayDeleter())
-, width(0)
-, height(0)
-, depth(0)
-{
-
-}
-
-Material::~Material()
-{
-}
-
-
-void Material::loadImage(const char* filename)
-{
-    int w, h, d;
-    // in RGBA order
-    int desired_channel_count = 0; // keep original amount of channels
-    unsigned char* data = stbi_load(filename, &w, &h, &d, desired_channel_count);
-    if (data)
-    {
-        width = w;
-        height = h;
-        depth = d;
-        this->data = std::shared_ptr<unsigned char>(data);
-    }
-    else
-    {
-        const char* reason = "[unknown reason]";
-        if (stbi_failure_reason())
-        {
-            reason = stbi_failure_reason();
-        }
-        logError("Cannot load image %s: '%s'.\n", filename, reason);
-        std::exit(-1);
-    }
-}
-
-float Material::getColor(float x, float y, ColourUsage color) const
-{
-    if (!data)
-    {
-        return 0.0;
-    }
-    assert(x >= 0.0f && x <= 1.0f);
-    assert(y >= 0.0f && y <= 1.0f);
-    switch (color)
-    {
-        case ColourUsage::RED:
-        case ColourUsage::GREEN:
-        case ColourUsage::BLUE:
-        case ColourUsage::ALPHA:
-        {
-            assert((int)color >= 0 && (unsigned int)color < depth && "Z out of bounds!");
-            return getColorData(x, y, (unsigned int) color);
-        }
-        case ColourUsage::GREY:
-        default:
-        {
-            float r = getColorData(x, y, (unsigned int) ColourUsage::RED);
-            float g = getColorData(x, y, (unsigned int) ColourUsage::GREEN);
-            float b = getColorData(x, y, (unsigned int) ColourUsage::BLUE);
-            return (r + g + b) / 3.0;
-        }
-    }
-}
-
-
-float Material::getColorData(float x, float y, unsigned int z) const
-{
-    unsigned int x_idx = (unsigned int) (x * (width - 1) + 0.5);
-    assert(x_idx >= 0 && x_idx < width && "requested X is out of bounds!");
-    unsigned int y_idx = (unsigned int) (y * (height - 1) + 0.5);
-    assert(y_idx >= 0 && y_idx < height && "requested Y is out of bounds!");
-
-    unsigned char col = data.get()[((height - y_idx - 1) * width + x_idx) * depth + z];
-    return (float) col / std::numeric_limits<unsigned char>::max();
-}
-
-
-
-
-void Material::debugOutput(bool dw) const
-{
-    std::cerr << "\nImage size: " << width << " x " << height << " (" << depth << "channels)\n";
-    std::cerr << '+';
-    for (unsigned int i = 0; i < width; i++)
-    {
-        std::cerr << ((dw)? "--" : "-");
-    }
-    std::cerr << "+\n";
-    for (unsigned int y = 0; y < height; y++)
-    {
-        std::cerr << "|";
-        for (unsigned int x = 0; x < width; x++)
-        {
-            int val = (data.get()[((height - y) * width + x) * depth] * 10 / 256);
-
-            switch (val)
-            {
-                case 0:
-                    std::cerr << ((dw)? "  " : " ");
-                    break;
-                case 1:
-                    std::cerr << ((dw)? ".." : ".");
-                    break;
-                case 2:
-                    std::cerr << ((dw)? ",," : ",");
-                    break;
-                case 3:
-                    std::cerr << ((dw)? "::" : ":");
-                    break;
-                case 4:
-                    std::cerr << ((dw)? ";;" : ";");
-                    break;
-                case 5:
-                    std::cerr << ((dw)? "++" : "+");
-                    break;
-                case 6:
-                    std::cerr << ((dw)? "░░" : "░");
-                    break;
-                case 7:
-                    std::cerr << ((dw)? "▒▒" : "▒");
-                    break;
-                case 8:
-                    std::cerr << ((dw)? "▓▓" : "▓");
-                    break;
-                default:
-                    if (val > 8)
-                    {
-                        std::cerr << ((dw)? "██" : "█");
-                    }
-                    else
-                    {
-                        std::cerr << ((dw)? "  " : " ");
-                    }
-            }
-        }
-        std::cerr << "|\n";
-    }
-    std::cerr << '+';
-    for (unsigned int i = 0; i < width; i++)
-    {
-        std::cerr << ((dw)? "--" : "-");
-    }
-    std::cerr << "+\n";
-}
-
-} // namespace cura

src/textureProcessing/Material.h

@@ -1,71 +0,0 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-#ifndef TEXTURE_PROCESSING_MATERIAL_H
-#define TEXTURE_PROCESSING_MATERIAL_H
-
-#include <memory> // shared_ptr
-
-#include "../settings/settings.h" // ColourUsage
-
-
-namespace cura
-{
-
-/*!
- * The material used in a texture.
- * 
- * This class just holds the image data and has some nice utility functions.
- */
-class Material
-{
-public:
-    /*!
-     * non-initializing constructor
-     */
-    Material();
-
-    /*!
-     * Destructor
-     * 
-     * deletes the image data
-     */
-    ~Material();
-
-    /*!
-     * Load an image from file.
-     * 
-     * Crash if this doesn't work. (unsupported file type, IO exception, etc.)
-     */
-    void loadImage(const char* filename);
-
-    /*!
-     * get the color value at a particular place in the image
-     * 
-     * \param x place in the horizontal direction left to right (value between zero and one)
-     * \param y place in the vertical direction top to bottom (value between zero and one)
-     * \param color The color channel to check
-     * \return a value between zero and one
-     */
-    float getColor(float x, float y, ColourUsage color) const;
-
-    /*!
-     * print out something which looks like the picture through std::cerr
-     * \param double_width Whether to double each character being written, so that the width is visually similar to the height of each pixel.
-     */
-    void debugOutput(bool double_width = true) const;
-protected:
-
-    std::shared_ptr<unsigned char> data; //!< pixel data in rgb-row-first (or bgr-row first ?)
-    unsigned int width, height, depth; //!< image dimensions
-
-    /*!
-     * Get a color value from the data
-     * \param x place in the horizontal direction left to right (value between zero and one)
-     * \param y place in the vertical direction top to bottom (value between zero and one)
-     * \return the color data (0-256)
-     */
-    float getColorData(float x, float y, unsigned int z) const;
-};
-
-} // namespace cura
-
-#endif // TEXTURE_PROCESSING_MATERIAL_H

src/textureProcessing/MaterialBase.cpp

@@ -1,42 +0,0 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-
-#include "MaterialBase.h"
-
-
-namespace cura
-{
-
-Material* MaterialBase::add(std::string name)
-{
-    name_to_mat_idx[name] = materials.size();
-    materials.emplace_back();
-    return &materials.back();
-}
-
-const Material* MaterialBase::getMat(unsigned int id) const
-{
-    if (id < materials.size())
-    {
-        return &materials[id];
-    }
-    else
-    {
-        return nullptr;
-    }
-}
-
-
-int MaterialBase::getMatId(std::string name) const
-{
-    auto it = name_to_mat_idx.find(name);
-    if (it == name_to_mat_idx.end())
-    {
-        return -1;
-    }
-    else
-    {
-        return it->second;
-    }
-}
-
-} // namespace cura

src/textureProcessing/MaterialBase.h

@@ -1,27 +0,0 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-#ifndef TEXTURE_PROCESSING_MATERIAL_BASE_H
-#define TEXTURE_PROCESSING_MATERIAL_BASE_H
-
-#include <unordered_map>
-#include <string>
-#include <vector>
-
-#include "Material.h"
-
-namespace cura
-{
-
-class MaterialBase
-{
-public:
-    int getMatId(std::string name) const;
-    Material* add(std::string name);
-    const Material* getMat(unsigned int id) const;
-protected:
-    std::unordered_map<std::string, int> name_to_mat_idx;
-    std::vector<Material> materials;
-};
-
-} // namespace cura
-
-#endif // TEXTURE_PROCESSING_MATERIAL_BASE_H

src/textureProcessing/TextureBumpMapProcessor.cpp

@@ -1,289 +0,0 @@
-#include "TextureBumpMapProcessor.h"
-
-#include <algorithm> // swap
-#include <cmath> // fabs
-
-#include "../utils/optional.h"
-#include "../utils/linearAlg2D.h"
-#include "../slicer/SlicerSegment.h"
-
-namespace cura 
-{
-
-#define SLICE_SEGMENT_SNAP_GAP 20
-
-TextureBumpMapProcessor::TextureBumpMapProcessor(TexturedMesh* mesh, const TextureBumpMapProcessor::Settings settings, FaceNormalStorage* face_normal_storage)
-: mesh(mesh)
-, settings(settings)
-, face_normal_storage(face_normal_storage)
-, loc_to_slice(SLICE_SEGMENT_SNAP_GAP)
-{
-
-}
-
-
-void TextureBumpMapProcessor::registerTexturedFaceSlice(SlicerSegment face_segment, MatSegment texture_segment)
-{
-    assert(face_segment.faceIndex >= 0);
-    TexturedFaceSlice slice{face_segment, texture_segment};
-    loc_to_slice.insert(face_segment.start, slice);
-    loc_to_slice.insert(face_segment.end, slice);
-}
-
-std::optional<TextureBumpMapProcessor::TexturedFaceSlice> TextureBumpMapProcessor::getTexturedFaceSlice(Point p0, Point p1)
-{
-    std::vector<TexturedFaceSlice> nearby_slices = loc_to_slice.getNearby(p0, SLICE_SEGMENT_SNAP_GAP);
-    std::optional<TexturedFaceSlice> best;
-    coord_t best_dist_score = std::numeric_limits<coord_t>::max();
-
-    for (TexturedFaceSlice& slice : nearby_slices)
-    {
-        coord_t dist_score = std::min(
-                vSize2(slice.face_segment.start - p0) + vSize2(slice.face_segment.end - p1)
-                , vSize2(slice.face_segment.end - p0) + vSize2(slice.face_segment.start - p1)
-            );
-        if (dist_score < best_dist_score)
-        {
-            best = slice;
-            best_dist_score = dist_score;
-        }
-    }
-    if (best_dist_score > SLICE_SEGMENT_SNAP_GAP * SLICE_SEGMENT_SNAP_GAP * 4) // TODO: this condition doesn't follow exactly from using SLICE_SEGMENT_SNAP_GAP and the quadratic dist score
-    {
-        return std::optional<TextureBumpMapProcessor::TexturedFaceSlice>();
-    }
-    if (vSize2(best->face_segment.start - p0) > vSize2(best->face_segment.start - p1))
-    {
-        std::swap(best->face_segment.start, best->face_segment.end);
-    }
-    assert(best->face_segment.faceIndex >= 0);
-    return best;
-}
-
-coord_t TextureBumpMapProcessor::getOffset(const float color, const int face_idx)
-{
-    coord_t extra_offset = 0;
-    if (face_normal_storage)
-    {
-        assert(face_idx >= 0 && "we must know for which face we are getting the color");
-        float tan_angle = face_normal_storage->getFaceTanAngle(face_idx);
-        float abs_tan_angle = std::fabs(tan_angle);
-        abs_tan_angle = std::min(abs_tan_angle, settings.max_tan_correction_angle);
-        extra_offset = settings.face_angle_correction * (color - 0.5) * abs_tan_angle * settings.layer_height;
-        // (color - 0.5) so that the color causes either an outset or an inset which is
-        // within the range [-0.5, 0.5] so that when at max it will coincide with the min on the previous layer:
-        //
-        //          for a black mesh
-        //  bridged gap = 4              applied offset = 2 and -2
-        //       ^^^^                     ^^
-        //   ____                     ______^^
-        //   :_______                 :_____
-        //   :   :   :  will become   :   :   :
-    }
-    return color * (settings.amplitude * 2) - settings.amplitude + settings.offset + extra_offset;
-}
-
-coord_t TextureBumpMapProcessor::getCornerOffset(std::optional<TextureBumpMapProcessor::TexturedFaceSlice>& textured_face_slice, std::optional<TextureBumpMapProcessor::TexturedFaceSlice>& next_textured_face_slice)
-{
-    coord_t offset0 = 0; // where no texture is present, no offset is applied
-    coord_t offset1 = 0;
-    if (textured_face_slice)
-    {
-        const float color0 = textured_face_slice->mat_segment.end.getColor(settings.color_usage);
-        const int face_0_idx = textured_face_slice->face_segment.faceIndex;
-        offset0 = getOffset(color0, face_0_idx);
-    }
-    if (next_textured_face_slice)
-    {
-        const float color1 = next_textured_face_slice->mat_segment.start.getColor(settings.color_usage);
-        const int face_1_idx = next_textured_face_slice->face_segment.faceIndex;
-        offset1 = getOffset(color1, face_1_idx);
-    }
-    coord_t offset = (offset0 + offset1) / 2;
-    return offset;
-}
-
-coord_t TextureBumpMapProcessor::getCornerDisregard(Point p0, Point p1, Point p2, std::optional<TextureBumpMapProcessor::TexturedFaceSlice>& textured_face_slice, std::optional<TextureBumpMapProcessor::TexturedFaceSlice>& next_textured_face_slice)
-{
-    coord_t offset = getCornerOffset(textured_face_slice, next_textured_face_slice);
-    if ((LinearAlg2D::pointIsLeftOfLine(p1, p0, p2) < 0) == (offset > 0))
-    {
-        return 0;
-    }
-    Point v01 = p1 - p0;
-    Point v12 = p2 - p1;
-    assert(p0 != p1 && "Code below depends on v01 not being of zer o size");
-    assert(p1 != p2 && "This function assumes the three points are different");
-    Point n01 = normal(turn90CCW(v01), -1000);
-    Point n12 = normal(turn90CCW(v12), -1000);
-    Point corner_normal = n01 + n12;
-    coord_t corner_normal_size2 = vSize2(corner_normal);
-    coord_t normal_aspect = dot(corner_normal, v01) / vSize(v01); // The aspect of the corner normal along v01 (might be negative)
-    coord_t dist_aspect = sqrt(std::max((coord_t)1, corner_normal_size2 - normal_aspect * normal_aspect)); // The distance of the end of the normal vector to v01 or v12
-    // ^ due to rounding errors 'corner_normal_size2 - normal_aspect^2' may be smaller than zero; because of division on line below should be at least 1
-    coord_t disregard = std::abs(offset * normal_aspect) / dist_aspect;
-    assert(disregard >= 0);
-    return disregard;
-}
-
-
-void TextureBumpMapProcessor::processSegmentBumpMap(unsigned int layer_nr, const SlicerSegment& slicer_segment, const MatSegment& mat, const Point p0, const Point p1, coord_t& dist_left_over, coord_t corner_disregard_p1, PolygonRef result)
-{
-    assert(mat.start.mat == mat.end.mat && "texture across face must be from one material!");
-
-    Point p0p1 = p1 - p0;
-    int64_t p0p1_size = vSize(p0p1);
-    if (dist_left_over >= p0p1_size - corner_disregard_p1)
-    {
-        dist_left_over -= p0p1_size;
-        return;
-    }
-
-    Point perp_to_p0p1 = turn90CCW(p0p1);
-    int64_t dist_last_point = -1; // p0p1_size * 2 - dist_left_over; // so that p0p1_size - dist_last_point evaulates to dist_left_over - p0p1_size
-    for (int64_t p0pa_dist = dist_left_over; p0pa_dist < p0p1_size - corner_disregard_p1; p0pa_dist += settings.point_distance)
-    {
-        assert(p0pa_dist >= 0);
-        assert(p0pa_dist <= p0p1_size);
-        MatCoord mat_coord_now = mat.start;
-        mat_coord_now.coords = mat.start.coords + (mat.end.coords - mat.start.coords) * p0pa_dist / p0p1_size;
-        float val = mat_coord_now.getColor(settings.color_usage);
-        int offset = getOffset(val, slicer_segment.faceIndex);
-        Point fuzz = normal(perp_to_p0p1, offset);
-        Point pa = p0 + normal(p0p1, p0pa_dist) - fuzz;
-        result.add(pa);
-        dist_last_point = p0pa_dist;
-    }
-    assert(dist_last_point >= 0 && "above loop should have run at least once!");
-    assert(p0p1_size > dist_last_point);
-    dist_left_over = p0p1_size - dist_last_point;
-    assert(dist_left_over <= settings.point_distance + corner_disregard_p1);
-}
-
-
-void TextureBumpMapProcessor::processBumpMap(Polygons& layer_polygons, unsigned int layer_nr)
-{
-    if (layer_polygons.size() == 0)
-    {
-        return;
-    }
-
-    Polygons preprocessed;
-    for (PolygonRef poly : layer_polygons)
-    { // remove duplicate points
-        PolygonRef preprocessed_poly = preprocessed.newPoly();
-        Point p0 = poly.back();
-        for (const Point p1 : poly)
-        {
-            if (p1 == p0)
-                continue;
-            preprocessed_poly.add(p1);
-            p0 = p1;
-        }
-    }
-
-    Polygons results;
-    for (PolygonRef poly : preprocessed)
-    {
-        if (poly.size() < 3)
-        {
-            results.add(poly);
-            continue;
-        }
-        PolygonRef result = results.newPoly();
-
-        std::vector<std::optional<TexturedFaceSlice>> texture_poly;
-        {
-            Point p0 = poly.back();
-            for (Point& p1 : poly)
-            {
-                texture_poly.emplace_back(getTexturedFaceSlice(p0, p1));
-                p0 = p1;
-            }
-        }
-
-        coord_t corner_disregard_p0 = getCornerDisregard(poly[poly.size() - 2], poly.back(), poly[0], texture_poly.back(), texture_poly[0]);; // TODO
-        coord_t dist_left_over = (settings.point_distance / 2); // the distance to be traversed on the line before making the first new point
-        Point* p0 = &poly.back();
-        for (unsigned int point_idx = 0; point_idx < poly.size(); point_idx++)
-        { // 'a' is the (next) new point between p0 and p1
-            Point& p1 = poly[point_idx];
-            unsigned int next_point_idx = (point_idx + 1 == poly.size())? 0 : point_idx + 1;
-            Point& p2 = poly[next_point_idx];
-            if (*p0 == p1)
-            {
-                continue;
-            }
-            std::optional<TexturedFaceSlice>& textured_face_slice = texture_poly[point_idx];
-            std::optional<TexturedFaceSlice>& next_textured_face_slice = texture_poly[next_point_idx];
-
-            coord_t corner_disregard_p1 = getCornerDisregard(*p0, p1, p2, textured_face_slice, next_textured_face_slice); // TODO
-            if (dist_left_over < corner_disregard_p0)
-            {
-                dist_left_over = corner_disregard_p0;
-            }
-
-            if (textured_face_slice)
-            {
-                processSegmentBumpMap(layer_nr, textured_face_slice->face_segment, textured_face_slice->mat_segment, *p0, p1, dist_left_over, corner_disregard_p1, result);
-            }
-            else
-            {
-                coord_t p0p1_size2 = vSize2(p1 - *p0);
-                if (p0p1_size2 < dist_left_over * dist_left_over)
-                {
-                    dist_left_over -= sqrt(p0p1_size2);
-                }
-                else
-                {
-                    result.emplace_back(*p0);
-                    result.emplace_back(p1);
-                    dist_left_over = settings.point_distance;
-                }
-            }
-
-            if (corner_disregard_p1 == 0
-                && (textured_face_slice || next_textured_face_slice)
-                && (textured_face_slice || !shorterThen(p1 - *p0, SLICE_SEGMENT_SNAP_GAP)) // don't introduce corner points for gap closer poly segments
-                && (next_textured_face_slice || !shorterThen(p2 - p1, SLICE_SEGMENT_SNAP_GAP)) // don't introduce corner points for gap closer poly segments
-                )
-            { // add point for outward corner
-                // TODO: remove code duplication with getCornerDisregard
-                coord_t offset = getCornerOffset(textured_face_slice, next_textured_face_slice);
-                Point v01 = p1 - *p0;
-                Point v12 = p2 - p1;
-                Point n01 = normal(turn90CCW(v01), -1000);
-                Point n12 = normal(turn90CCW(v12), -1000);
-                Point corner_normal = normal(n01 + n12, offset);
-                result.add(p1 + corner_normal);
-            }
-            p0 = &p1;
-            corner_disregard_p0 = corner_disregard_p1;
-        }
-        while (result.size() < 3 )
-        {
-            unsigned int point_idx = poly.size() - 2;
-            result.add(poly[point_idx]);
-            if (point_idx == 0) { break; }
-            point_idx--;
-        }
-        if (result.size() < 3)
-        {
-            result.clear();
-            for (Point& p : poly)
-                result.add(p);
-        }
-    }
-    // a negative offset on two sides of a corner, may introduce complexities in the model which should be removed:
-    //         ^↘
-    //         ^  ↘
-    // <<<<<<<<^<<<<   should become  <<<<<<<<
-    //         ^                              ^
-    //         ^                              ^
-    //         ^                              ^
-    layer_polygons = results.removeComplexParts();
-}
-
-
-
-}//namespace cura

src/textureProcessing/TextureBumpMapProcessor.h

@@ -1,150 +0,0 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-#ifndef TEXTURE_PROCESSING_TEXTURE_BUMP_MAP_PROCESSOR_H
-#define TEXTURE_PROCESSING_TEXTURE_BUMP_MAP_PROCESSOR_H
-
-#include <vector>
-#include <math.h> // tan
-
-#include "../utils/polygon.h"
-#include "../utils/optional.h"
-#include "../utils/SparsePointGrid.h"
-
-#include "../settings/settings.h"
-
-#include "../slicer/SlicerSegment.h"
-#include "TexturedMesh.h"
-#include "FaceNormalStorage.h"
-
-namespace cura
-{
-
-class TextureBumpMapProcessor
-{
-public:
-    /*!
-     * Helper class to retrieve and store texture to bump map settings
-     */
-    struct Settings
-    {
-        coord_t layer_height;
-        coord_t point_distance;
-        coord_t amplitude;
-        coord_t offset;
-        bool alternate;
-        float face_angle_correction;
-        float max_tan_correction_angle;
-        ColourUsage color_usage;
-        Settings(SettingsBaseVirtual* settings_base)
-        : layer_height(settings_base->getSettingInMicrons("layer_height"))
-        , point_distance(settings_base->getSettingInMicrons("bump_map_point_dist"))
-        , amplitude(settings_base->getSettingInMicrons("bump_map_amplitude"))
-        , offset(settings_base->getSettingInMicrons("bump_map_offset"))
-        , alternate(settings_base->getSettingBoolean("bump_map_alternate"))
-        , face_angle_correction(settings_base->getSettingAsRatio("bump_map_face_angle_correction"))
-        , max_tan_correction_angle(std::tan(0.5 * M_PI - settings_base->getSettingInAngleRadians("bump_map_angle_correction_min")))
-        , color_usage(settings_base->getSettingAsColourUsage("bump_map_texture_color"))
-        {
-        }
-    };
-    /*!
-     * default constructor
-     * 
-     * initializes the \ref SparseGrid::cell_size of \ref TextureBumpMapProcessor::loc_to_slice
-     * 
-     * \param settings The settings with which to \ref TextureBumpMapProcessor::processBumpMap
-     */
-    TextureBumpMapProcessor(TexturedMesh* mesh, const Settings settings, FaceNormalStorage* face_normal_storage);
-
-    /*!
-     * Process the texture bump map.
-     * Change the polygons in a layer
-     * 
-     * \warning Where no texture is present, no offset is applied to the outer boundary!
-     * Such segments are copied to the result as is
-     * 
-     * \param[in,out] layer_polygons The polygons to be offsetted by texture color values
-     * \param layer_nr The layer nr for which we are processing the bump map
-     */
-    void processBumpMap(Polygons& layer_polygons, unsigned int layer_nr);
-
-    /*!
-     * Register that a particular face was sliced to a particular texture segment.
-     * \param face_segment The geometrical segment of the face
-     * \param texture_segment The corresponding texture coordinates
-     */
-    void registerTexturedFaceSlice(SlicerSegment face_segment, MatSegment texture_segment);
-protected:
-    /*!
-     * A sliced segment in combination with the corresponding texture slice.
-     */
-    struct TexturedFaceSlice
-    {
-        SlicerSegment face_segment;
-        MatSegment mat_segment;
-    };
-
-    TexturedMesh* mesh;
-
-    /*!
-     * The settings with which to \ref TextureBumpMapProcessor::processBumpMap
-     */
-    Settings settings;
-
-    /*!
-     * The face normal statistics to correct offsets for slanted faces - if provided
-     * 
-     * This is stored as a pointer so that the default assignment operator = can be defined automatically.
-     */
-    FaceNormalStorage* face_normal_storage;
-
-    /*!
-     * A grid to efficiently look op which texture segment best fits the slicer segment.
-     */
-    SparseGrid<TexturedFaceSlice> loc_to_slice;
-
-    /*!
-     * Get the offset to be applied at a given location
-     */
-    coord_t getOffset(const float color, const int face_idx);
-
-    /*!
-     * Get the offset to be applied at a given corner
-     * 
-     * Computes the average offset from the end of \p textured_face_slice and start of \p next_textured_face_slice
-     * If either of those is not present, the \ref TextureBumpMapProcessor::Settings::default_color is used for that segment
-     * 
-     * \warning Where no texture is present, no offset is applied to the outer boundary!
-     * 
-     * \param textured_face_slice From which to determine the offset at the end of the line segment - or default to zero
-     * \param next_textured_face_slice From which to determine the offset at the start of the line segment - or default to zero
-     */
-    coord_t getCornerOffset(std::optional<TextureBumpMapProcessor::TexturedFaceSlice>& textured_face_slice, std::optional<TextureBumpMapProcessor::TexturedFaceSlice>& next_textured_face_slice);
-
-    /*!
-     * Get how much of a corner to skip generating offsetted indices for inner corners,
-     * because those points would be removed by the offset itseld
-     */
-    coord_t getCornerDisregard(Point p0, Point p1, Point p2, std::optional<TexturedFaceSlice>& textured_face_slice, std::optional<TexturedFaceSlice>& next_textured_face_slice);
-
-    /*!
-     * Get the TexturedFaceSlice corresponding to an outline segment
-     * 
-     * Note that due to snapping in the \ref Slicer::makePolygons function, an outline segment may be a bit different from the originally sliced SlicerSegment
-     * 
-     * \param p0 The start of the segment
-     * \param p1 The end of the segment
-     */
-    std::optional<TexturedFaceSlice> getTexturedFaceSlice(Point p0, Point p1);
-
-    /*!
-     * 
-     * \param layer_nr The layer number for which we process the bump map
-     * \param slicer_segment The segment closest matching \p p0 - \p p1
-     * \param corner_disregard_p1 The distance at the end of p0p1 in which not to place offsetted points
-     */
-    void processSegmentBumpMap(unsigned int layer_nr, const SlicerSegment& slicer_segment, const MatSegment& mat, const Point p0, const Point p1, coord_t& dist_left_over, coord_t corner_disregard_p1, PolygonRef result);
-};
-
-} // namespace cura
-
-#endif // TEXTURE_PROCESSING_TEXTURE_BUMP_MAP_PROCESSOR_H

src/textureProcessing/TextureProximityProcessor.cpp

@@ -1,85 +0,0 @@
-#include "TextureProximityProcessor.h"
-
-#include <algorithm> // swap
-#include <functional> // function
-
-#include "../utils/optional.h"
-#include "../utils/linearAlg2D.h"
-#include "../slicer/SlicerSegment.h"
-
-namespace cura 
-{
-
-TextureProximityProcessor::TextureProximityProcessor(const TextureProximityProcessor::Settings settings, unsigned int slice_layer_count)
-: settings(settings)
-{
-    loc_to_slice.resize(slice_layer_count, SparseLineGrid<TexturedFaceSlice, TexturedFaceSliceLocator>(settings.proximity));
-}
-
-
-void TextureProximityProcessor::registerTexturedFaceSlice(SlicerSegment face_segment, MatSegment texture_segment, unsigned int layer_nr)
-{
-    TexturedFaceSlice slice{face_segment, texture_segment};
-    assert((int)layer_nr >= 0 && layer_nr < loc_to_slice.size());
-    loc_to_slice[layer_nr].insert(slice);
-}
-
-float TextureProximityProcessor::getColor(const Point location, const unsigned int layer_nr, ColourUsage color, float default_color)
-{
-    assert((int)layer_nr >= 0 && layer_nr < loc_to_slice.size());
-    SparseLineGrid<TexturedFaceSlice, TexturedFaceSliceLocator> grid = loc_to_slice[layer_nr];
-
-    coord_t best_dist2 = std::numeric_limits<coord_t>::max();
-    std::optional<TexturedFaceSlice> best;
-    std::function<bool (const TexturedFaceSlice& in)> process_func = [location, &best_dist2, &best](const TexturedFaceSlice& in)
-    {
-        coord_t dist2 = LinearAlg2D::getDist2FromLineSegment(in.face_segment.start, location, in.face_segment.end);
-        if (dist2 < best_dist2)
-        {
-            best_dist2 = dist2;
-            best = in;
-        }
-        return true; // keep going, we're not sure whether we have found the best yet
-    };
-    
-    grid.processNearby(location, settings.proximity, process_func);
-    
-    if (best_dist2 > settings.proximity * settings.proximity * 4)
-    {
-        return default_color;
-    }
-    assert(best && "given that dist2 != max int this variable should have been innitialized");
-    const Point p0 = best->face_segment.start;
-    const Point p1 = best->face_segment.end;
-    const Point x = location;
-    // Point r = resulting point on the nearest segment, nearest to [location]
-    const MatSegment mat_segment = best->mat_segment;
-
-    const Point v01 = p1 - p0;
-    const Point v0x = x - p0;
-    const coord_t v01_length2 = vSize2(v01);
-    if (v01_length2 <= 4)
-    {
-        return mat_segment.start.getColor(color);
-    }
-
-    const coord_t dot_prod = dot(v0x, v01);
-    const int64_t v0r_length2 = dot_prod * dot_prod / v01_length2;
-    if (v0r_length2 <= 0)
-    {
-        return mat_segment.start.getColor(color);
-    }
-    if (v0r_length2 >= v01_length2)
-    {
-        return mat_segment.end.getColor(color);
-    }
-    const coord_t v0r_length = sqrt(v0r_length2);
-    const coord_t v01_length = sqrt(v01_length2);
-    MatCoord mat_in_between = mat_segment.start;
-    mat_in_between.coords = mat_segment.start.coords + (mat_segment.end.coords - mat_segment.start.coords) * v0r_length / v01_length;
-    return mat_in_between.getColor(color);
-}
-
-
-
-}//namespace cura

src/textureProcessing/TextureProximityProcessor.h

@@ -1,93 +0,0 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-#ifndef TEXTURE_PROCESSING_TEXTURE_PROXIMITY_PROCESSOR_H
-#define TEXTURE_PROCESSING_TEXTURE_PROXIMITY_PROCESSOR_H
-
-#include <vector>
-
-#include "../utils/intpoint.h"
-#include "../utils/SparseLineGrid.h"
-
-#include "../settings/settings.h"
-
-#include "../slicer/SlicerSegment.h"
-#include "TexturedMesh.h"
-
-namespace cura
-{
-
-/*!
- * Class for recording texture coordinates at places where textures are defined, for later looking in the proximity of a texture.
- */
-class TextureProximityProcessor
-{
-public:
-    /*!
-     * Helper class to retrieve and store texture to bump map settings
-     */
-    struct Settings
-    {
-        coord_t proximity; //!< The distance within which to search for nearby texture
-        Settings(coord_t proximity)
-        : proximity(proximity)
-        {
-        }
-    };
-    /*!
-     * default constructor
-     * 
-     * initializes the \ref SparseGrid::cell_size of \ref TextureProximityProcessor::loc_to_slice
-     * 
-     * \param settings The settings with which to \ref TextureProximityProcessor::processBumpMap
-     */
-    TextureProximityProcessor(const Settings settings, unsigned int slice_layer_count);
-
-    /*!
-     * Register that a particular face was sliced to a particular texture segment.
-     * \param face_segment The geometrical segment of the face
-     * \param texture_segment The corresponding texture coordinates
-     * \param layer_nr The layer for which to register a face being sliced
-     */
-    void registerTexturedFaceSlice(SlicerSegment face_segment, MatSegment texture_segment, unsigned int layer_nr);
-
-    /*!
-     * 
-     * \param default_color Default color where no texture is present
-     */
-    float getColor(const Point location, const unsigned int layer_nr, ColourUsage color, float default_color);
-protected:
-    /*!
-     * A sliced segment in combination with the corresponding texture slice.
-     */
-    struct TexturedFaceSlice
-    {
-        SlicerSegment face_segment;
-        MatSegment mat_segment;
-    };
-
-    /*!
-     * Locator to find the line segment of a \ref TexturedFaceSlice
-     */
-    struct TexturedFaceSliceLocator
-    {
-        std::pair<Point, Point> operator()(const TexturedFaceSlice& elem) const
-        {
-            return std::make_pair(elem.face_segment.start, elem.face_segment.end);
-        }
-    };
-
-    /*!
-     * The settings with which to \ref TextureBumpMapProcessor::processBumpMap
-     */
-    Settings settings;
-
-    /*!
-     * A grid to efficiently look op which texture segment best fits the slicer segment.
-     * 
-     * A vector of elements for each layer
-     */
-    std::vector<SparseLineGrid<TexturedFaceSlice, TexturedFaceSliceLocator>> loc_to_slice;
-};
-
-} // namespace cura
-
-#endif // TEXTURE_PROCESSING_TEXTURE_PROXIMITY_PROCESSOR_H

src/textureProcessing/TexturedMesh.cpp

@@ -1,144 +0,0 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-
-#include "TexturedMesh.h"
-
-#include <cassert>
-#include <math.h>
-
-#include "../utils/logoutput.h"
-
-namespace cura
-{
-
-TexturedMesh::TexturedMesh(SettingsBaseVirtual* sb)
-: Mesh(sb)
-, current_mat(-1) // not set yet
-{
-}
-
-void TexturedMesh::addTextureCoord(float x, float y)
-{
-    // some textures use wrapping for some unholy reason
-    // unwrap for texture coordinates to fall within [0,1]
-    if (x > 1.0f || x < 0.0f)
-    { // only apply fmod when more than 1.0
-        x = fmod(x, 1.0f);
-        if (x < 0.0)
-        {
-            x += 1.0f;
-        }
-    }
-    if (y > 1.0f || y < 0.0f)
-    { // only apply fmod when more than 1.0
-        y = fmod(y, 1.0f);
-        if (y < 0.0)
-        {
-            y += 1.0f;
-        }
-    }
-    texture_coords.emplace_back(x, y);
-}
-
-void TexturedMesh::addFace(int vi0, int vi1, int vi2, int ti0, int ti1, int ti2)
-{
-    if (vi0 < -1)
-    {
-        vi0 = Mesh::faces.size() + vi0 + 1; // + 1 because of relative indexing doesn't start counting from 1
-    }
-    if (vi1 < -1)
-    {
-        vi1 = Mesh::faces.size() + vi0 + 1; // + 1 because of relative indexing doesn't start counting from 1
-    }
-    if (vi2 < -1)
-    {
-        vi2 = Mesh::faces.size() + vi0 + 1; // + 1 because of relative indexing doesn't start counting from 1
-    }
-    if (ti0 < -1)
-    {
-        ti0 = texture_coords.size() + vi0 + 1; // + 1 because of relative indexing doesn't start counting from 1
-    }
-    if (ti1 < -1)
-    {
-        ti1 = texture_coords.size() + vi0 + 1; // + 1 because of relative indexing doesn't start counting from 1
-    }
-    if (ti2 < -1)
-    {
-        ti2 = texture_coords.size() + vi0 + 1; // + 1 because of relative indexing doesn't start counting from 1
-    }
-    bool made_new_face = Mesh::addFace(vi0, vi1, vi2);
-    if (made_new_face)
-    {
-        face_texture_indices.emplace_back(ti0, ti1, ti2, current_mat);
-        assert(Mesh::faces.size() == face_texture_indices.size());
-    }
-}
-
-bool TexturedMesh::setMaterial(std::string name)
-{
-    current_mat = material_base.getMatId(name);
-    return current_mat >= 0;
-}
-
-Material* TexturedMesh::addMaterial(std::string name)
-{
-    return material_base.add(name);
-}
-
-
-bool TexturedMesh::getFaceEdgeMatCoord(unsigned int face_idx, int64_t z, unsigned int p0_idx, unsigned int p1_idx, MatCoord& result) const
-{
-    if (face_idx >= face_texture_indices.size() || face_idx >= faces.size())
-    {
-        return false;
-    }
-    FaceTextureCoordIndices texture_idxs = face_texture_indices[face_idx];
-    if (texture_idxs.index[0] < 0 || texture_idxs.index[1] < 0 || texture_idxs.index[2] < 0 || texture_idxs.mat_id < 0)
-    {
-        return false;
-    }
-    const MeshFace& face = faces[face_idx];
-    Point3 p0(vertices[face.vertex_index[p0_idx]].p);
-    Point3 p1(vertices[face.vertex_index[p1_idx]].p);
-
-    float dzp0 = z - p0.z;
-    float dp0p1 = p1.z - p0.z;
-
-    if (dzp0 * dp0p1 < 0)
-    { // z doesn't lie between p0 and p1
-        return false;
-    }
-    if (dzp0 == 0)
-    { // edge is not cut by horizontal plane!
-        return false;
-    }
-    float ratio = INT2MM(dzp0) / INT2MM(dp0p1);
-
-    FPoint t0 = texture_coords[texture_idxs.index[p0_idx]];
-    FPoint t1 = texture_coords[texture_idxs.index[p1_idx]];
-
-    result.mat = material_base.getMat(texture_idxs.mat_id);
-    result.coords.x = t0.x + (t1.x - t0.x) * ratio;
-    result.coords.y = t0.y + (t1.y - t0.y) * ratio;
-
-    if (result.coords.x > 1.001 || result.coords.x < -0.001 || result.coords.y > 1.001 || result.coords.y < -0.001)
-    {
-        logError("WARNING: wrapping material to outside image!\n");
-    }
-    return true;
-}
-
-bool TexturedMesh::sliceFaceTexture(unsigned int face_idx, unsigned int idx_shared, unsigned int idx_first, unsigned int idx_second, int32_t z, Point segment_start, Point segment_end, MatSegment& result) const
-{
-    if (!getFaceEdgeMatCoord(face_idx, z, idx_shared, idx_first, result.start))
-    {
-        return false;
-    }
-    if (!getFaceEdgeMatCoord(face_idx, z, idx_shared, idx_second, result.end))
-    {
-        return false;
-    }
-    return true;
-}
-
-
-} // namespace cura

src/textureProcessing/TexturedMesh.h

@@ -1,77 +0,0 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-#ifndef TEXTURE_PROCESSING_TEXTURED_MESH_H
-#define TEXTURE_PROCESSING_TEXTURED_MESH_H
-
-#include <vector>
-#include <string>
-
-#include "MaterialBase.h"
-
-#include "../mesh.h"
-#include "../utils/intpoint.h"
-#include "MatSegment.h"
-
-namespace cura
-{
-
-/*!
- * A mesh with bitmap textures to it.
- * 
- * material coordinates are defined separately, and can be reused for different bitmap textures
- */ 
-class TexturedMesh : public Mesh 
-{
-public:
-    TexturedMesh(SettingsBaseVirtual* sb);
-
-
-    /*!
-     * 
-     */
-    struct FaceTextureCoordIndices
-    {
-        int index[3]; //!< indices into texture_coords or -1 if no texture data available
-        int mat_id; //!< Material id
-        FaceTextureCoordIndices(int i1, int i2, int i3, int mat_id)
-        : mat_id(mat_id)
-        {
-            index[0] = i1;
-            index[1] = i2;
-            index[2] = i3;
-        }
-    };
-    void addTextureCoord(float x, float y);
-    void addFace(int vi0, int vi1, int vi2, int ti0, int ti1, int ti2);
-    using Mesh::addFace; // otherwise above addFace would shadow the parent addFace
-
-    bool setMaterial(std::string name); //!< set the material to be used in the comming data to be loaded
-    Material* addMaterial(std::string name);
-
-    /*!
-     * \return Whether a texture line segment has been created
-     */
-    bool sliceFaceTexture(unsigned int face_idx, unsigned int idx_shared, unsigned int idx_first, unsigned int idx_second, int32_t z, Point segment_start, Point segment_end, MatSegment& result) const;
-
-protected:
-    std::vector<FPoint> texture_coords; //!< all texture coordinates by all faces
-    std::vector<FaceTextureCoordIndices> face_texture_indices; //!< for each face the corresponding texture coordinates in TexturedMesh::texture_coords
-    // TODO clean up above lists when super class clear() is called
-    // TODO when to clean up below material base?
-    MaterialBase material_base;
-    /*!
-     * Get the material coordinate corresponding to the point on a plane cutting a given edge of the face.
-     * \param face_idx The face for which to get the material coord
-     * \param z The z of the horizontal plane cutting the face
-     * \param p0_idx The index into the first vert of the edge
-     * \param p1_idx The index into the second vert of the edge
-     * \param result The resulting material Coordinates
-     * \return Whether a Material coordinate is defined at the given location
-     */
-    bool getFaceEdgeMatCoord(unsigned int face_idx, int64_t z, unsigned int p0_idx, unsigned int p1_idx, MatCoord& result) const;
-private:
-    int current_mat; //!< material currently used in loading the face material info
-};
-
-} // namespace cura
-
-#endif // TEXTURE_PROCESSING_TEXTURED_MESH_H

src/utils/AABB3D.cpp

@@ -37,6 +37,12 @@ void AABB3D::include(Point3 p)
     max.z = std::max(max.z, p.z);   
 }
 
+void AABB3D::includeZ(int32_t z)
+{
+    min.z = std::min(min.z, z);
+    max.z = std::max(max.z, z);
+}
+
 void AABB3D::offset(Point3 offset)
 {
     min += offset;

src/utils/AABB3D.h

@@ -38,6 +38,14 @@ struct AABB3D
      */
     void include(Point3 p);
 
+    /*!
+     * Expand the AABB3D to include a z-coordinate.
+     *
+     * This is for including a point of which the X and Y coordinates are
+     * unknown but known to already be included in the bounding box.
+     */
+    void includeZ(int32_t z);
+
     /*!
      * Offset the coordinates of the bounding box.
      * \param offset The offset with which to offset the AABB3D.

src/utils/FPoint.h

@@ -1,74 +0,0 @@
-/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
-#ifndef UTILS_F_POINT_H
-#define UTILS_F_POINT_H
-
-#include <cmath> // sqrt
-#include <iostream> // auto-serialization / auto-toString() '<<'
-
-namespace cura
-{
-/*!
- * 2D coordinates represented by floats
- */
-class FPoint
-{
-public:
-    float x, y; //!< Coordinates 
-    FPoint() //!< non-initializing constructor
-    {}
-    FPoint(float x, float y) //!< constructor
-    : x(x)
-    , y(y)
-    {}
-
-    FPoint operator+(const FPoint& p) const { return FPoint(x+p.x, y+p.y); }
-    FPoint operator-(const FPoint& p) const { return FPoint(x-p.x, y-p.y); }
-    FPoint operator/(const float i) const { return FPoint(x/i, y/i); }
-    FPoint operator*(const float i) const { return FPoint(x*i, y*i); }
-
-    FPoint& operator += (const FPoint& p) { x += p.x; y += p.y; return *this; }
-    FPoint& operator -= (const FPoint& p) { x -= p.x; y -= p.y; return *this; }
-
-    bool operator==(const FPoint& p) const { return x == p.x && y == p.y; }
-    bool operator!=(const FPoint& p) const { return x != p.x || y != p.y; }
-
-    /*!
-     * output to string stream in standard format
-     */
-    template<class CharT, class TraitsT>
-    friend
-    std::basic_ostream<CharT, TraitsT>&
-    operator <<(std::basic_ostream<CharT, TraitsT>& os, const FPoint& p)
-    {
-        return os << "(" << p.x << ", " << p.y << ")";
-    }
-
-    /*!
-     * squared vector size
-     */
-    float vSize2() const
-    {
-        return x * x + y * y;
-    }
-
-    /*!
-     * vector size
-     */
-    float vSize() const
-    {
-        return sqrt(vSize2());
-    }
-
-    /*!
-     * dot product
-     */
-    float dot(const FPoint& p) const
-    {
-        return x * p.x + y * p.y;
-    }
-
-};
-
-} // namespace cura
-
-#endif // UTILS_F_POINT_H

src/utils/ListPolyIt.cpp

@@ -10,68 +10,49 @@ namespace cura
 {
 
 
-void ListPolyIt::convertPolygonsToLists(Polygons& polys, ListPolygons& result, bool remove_duplicates)
+void ListPolyIt::convertPolygonsToLists(Polygons& polys, ListPolygons& result)
 {
     for (PolygonRef poly : polys)
     {
         result.emplace_back();
-        convertPolygonToList(poly, result.back(), remove_duplicates);
+        convertPolygonToList(poly, result.back());
     }
 }
 
-void ListPolyIt::convertPolygonToList(PolygonRef poly, ListPolygon& result, bool remove_duplicates)
+void ListPolyIt::convertPolygonToList(PolygonRef poly, ListPolygon& result)
 {
-    if (remove_duplicates)
+#ifdef DEBUG
+    Point last = poly.back();
+#endif // DEBUG
+    for (Point& p : poly) 
     {
-        Point last = poly.back();
-        for (Point& p : poly)
-        {
-            if (p != last)
-            {
-                result.push_back(p);
-                last = p;
-            }
-        }
-    }
-    else
-    {
-        for (Point& p : poly)
-        {
-            result.push_back(p);
-        }
+        result.push_back(p);
+#ifdef DEBUG
+        // usually polygons shouldn't have such degenerate verts
+        // in PolygonProximityLinker (where this function is (also) used) it is
+        // required to not have degenerate verts, because verts are mapped
+        // to links, but if two different verts are at the same place the mapping fails.
+        assert(p != last);
+        last = p;
+#endif // DEBUG
     }
 }
 
 
-void ListPolyIt::convertListPolygonsToPolygons(ListPolygons& list_polygons, Polygons& polygons, bool remove_duplicates)
+void ListPolyIt::convertListPolygonsToPolygons(ListPolygons& list_polygons, Polygons& polygons)
 {
     for (unsigned int poly_idx = 0; poly_idx < polygons.size(); poly_idx++)
     {
         polygons[poly_idx].clear();
-        convertListPolygonToPolygon(list_polygons[poly_idx], polygons[poly_idx], remove_duplicates);
+        convertListPolygonToPolygon(list_polygons[poly_idx], polygons[poly_idx]);
     }
 }
 
-void ListPolyIt::convertListPolygonToPolygon(ListPolygon& list_polygon, PolygonRef polygon, bool remove_duplicates)
+void ListPolyIt::convertListPolygonToPolygon(ListPolygon& list_polygon, PolygonRef polygon)
 {
-    if (remove_duplicates)
+    for (Point& p : list_polygon)
     {
-        Point last = list_polygon.back();
-        for (Point& p : list_polygon)
-        {
-            if (p != last)
-            {
-                polygon.add(p);
-                last = p;
-            }
-        }
-    }
-    else
-    {
-        for (Point& p : list_polygon)
-        {
-            polygon.add(p);
-        }
+        polygon.add(p);
     }
 }
 

src/utils/ListPolyIt.h

@@ -93,33 +93,29 @@ public:
      * 
      * \param polys The polygons to convert
      * \param result The converted polygons
-     * \param remove_duplicates Whether to skip the conversion of duplicate consecutive points in the input
      */
-    static void convertPolygonsToLists(Polygons& polys, ListPolygons& result, bool remove_duplicates = false);
+    static void convertPolygonsToLists(Polygons& polys, ListPolygons& result);
     /*!
      * Convert Polygons to ListPolygons
      * 
      * \param polys The polygons to convert
      * \param result The converted polygons
-     * \param remove_duplicates Whether to skip the conversion of duplicate consecutive points in the input
      */
-    static void convertPolygonToList(PolygonRef poly, ListPolygon& result, bool remove_duplicates = false);
+    static void convertPolygonToList(PolygonRef poly, ListPolygon& result);
     /*!
      * Convert ListPolygons to Polygons
      * 
      * \param list_polygons The polygons to convert
      * \param polygons The converted polygons
-     * \param remove_duplicates Whether to skip the conversion of duplicate consecutive points in the input
      */
-    static void convertListPolygonsToPolygons(ListPolygons& list_polygons, Polygons& polygons, bool remove_duplicates = false);
+    static void convertListPolygonsToPolygons(ListPolygons& list_polygons, Polygons& polygons);
     /*!
      * Convert ListPolygons to Polygons
      * 
      * \param list_polygons The polygons to convert
      * \param polygons The converted polygons
-     * \param remove_duplicates Whether to skip the conversion of duplicate consecutive points in the input
      */
-    static void convertListPolygonToPolygon(ListPolygon& list_polygon, PolygonRef polygon, bool remove_duplicates = false);
+    static void convertListPolygonToPolygon(ListPolygon& list_polygon, PolygonRef polygon);
 
     /*!
      * Insert a point into a ListPolygon if it's not a duplicate of the point before or the point after.

src/utils/PolygonProximityLinker.cpp

@@ -21,8 +21,7 @@ PolygonProximityLinker::PolygonProximityLinker(Polygons& polygons, int proximity
     proximity_point_links.reserve(polygons.pointCount()); // When the whole model consists of thin walls, there will generally be a link for every point, plus some endings minus some points which map to eachother
 
     // convert to list polygons for insertion of points
-    constexpr bool remove_duplicates = true;
-    ListPolyIt::convertPolygonsToLists(polygons, list_polygons, remove_duplicates);
+    ListPolyIt::convertPolygonsToLists(polygons, list_polygons); 
 
     // link each corner to itself
     addSharpCorners();

src/utils/SparseGrid.h

@@ -14,6 +14,9 @@ namespace cura {
 
 /*! \brief Sparse grid which can locate spatially nearby elements efficiently.
  * 
+ * \note This is an abstract template class which doesn't have any functions to insert elements.
+ * \see SparsePointGrid
+ *
  * \tparam ElemT The element type to store.
  */
 template<class ElemT>
@@ -21,11 +24,6 @@ class SparseGrid
 {
 public:
     using Elem = ElemT;
-protected:
-    using GridPoint = Point;
-    using grid_coord_t = coord_t;
-    using GridMap = std::unordered_multimap<GridPoint, Elem>;
-public:
 
     /*! \brief Constructs a sparse grid with the specified cell size.
      *
@@ -97,50 +95,10 @@ public:
 
     coord_t getCellSize() const;
 
-    /*! \brief Inserts elem into the sparse grid.
-     *
-     * \param[in] location The location where to insert the element
-     * \param[in] elem The element to be inserted.
-     */
-    void insert(Point location, const Elem &elem);
-
-    class iterator
-    {
-        friend class SparseGrid<ElemT>;
-        typename GridMap::iterator it;
-        iterator(typename GridMap::iterator it)
-        :it(it)
-        {}
-    public:
-        iterator operator++() // pre-increment
-        {
-            ++it;
-            return *this;
-        }
-        iterator operator++(int) // post increment
-        {
-            iterator ret(it);
-            ++it;
-            return ret;
-        }
-        Elem operator*()
-        {
-            return it->second;
-        }
-        bool operator==(iterator other)
-        {
-            return it == other.it;
-        }
-        bool operator!=(iterator other)
-        {
-            return it != other.it;
-        }
-        // TODO: fully implement iterator interface
-    };
-    iterator begin();
-    iterator end();
-
 protected:
+    using GridPoint = Point;
+    using grid_coord_t = coord_t;
+    using GridMap = std::unordered_multimap<GridPoint, Elem>;
 
     /*! \brief Process elements from the cell indicated by \p grid_pt.
      *
@@ -263,26 +221,6 @@ typename cura::coord_t SGI_THIS::toLowerCoord(const grid_coord_t& grid_coord)  c
     return grid_coord * m_cell_size;
 }
 
-SGI_TEMPLATE
-void SGI_THIS::insert(Point loc, const Elem &elem)
-{
-    GridPoint grid_loc = toGridPoint(loc);
-
-    m_grid.emplace(grid_loc, elem);
-}
-
-SGI_TEMPLATE
-typename SGI_THIS::iterator SGI_THIS::begin()
-{
-    return iterator(m_grid.begin());
-}
-
-SGI_TEMPLATE
-typename SGI_THIS::iterator SGI_THIS::end()
-{
-    return iterator(m_grid.end());
-}
-
 SGI_TEMPLATE
 bool SGI_THIS::processFromCell(
     const GridPoint &grid_pt,

src/utils/SparsePointGrid.h

@@ -62,7 +62,9 @@ SGI_TEMPLATE
 void SGI_THIS::insert(const Elem &elem)
 {
     Point loc = m_locator(elem);
-    SparseGrid<ElemT>::insert(loc, elem);
+    GridPoint grid_loc = SparseGrid<ElemT>::toGridPoint(loc);
+
+    SparseGrid<ElemT>::m_grid.emplace(grid_loc,elem);
 }
 
 

src/utils/intpoint.h

@@ -46,19 +46,17 @@ Integer points are used to avoid floating point rounding errors, and because Cli
 namespace cura
 {
 
-using coord_t = ClipperLib::cInt;
-
 class Point3
 {
 public:
-    coord_t x,y,z;
+    int32_t x,y,z;
     Point3() {}
-    Point3(const coord_t _x, const coord_t _y, const coord_t _z): x(_x), y(_y), z(_z) {}
+    Point3(const int32_t _x, const int32_t _y, const int32_t _z): x(_x), y(_y), z(_z) {}
 
     Point3 operator+(const Point3& p) const { return Point3(x+p.x, y+p.y, z+p.z); }
     Point3 operator-(const Point3& p) const { return Point3(x-p.x, y-p.y, z-p.z); }
-    Point3 operator/(const coord_t i) const { return Point3(x/i, y/i, z/i); }
-    Point3 operator*(const coord_t i) const { return Point3(x*i, y*i, z*i); }
+    Point3 operator/(const int32_t i) const { return Point3(x/i, y/i, z/i); }
+    Point3 operator*(const int32_t i) const { return Point3(x*i, y*i, z*i); }
     Point3 operator*(const double d) const { return Point3(d*x, d*y, d*z); }
 
     Point3& operator += (const Point3& p) { x += p.x; y += p.y; z += p.z; return *this; }
@@ -77,14 +75,14 @@ public:
     }
 
 
-    coord_t max() const
+    int32_t max() const
     {
         if (x > y && x > z) return x;
         if (y > z) return y;
         return z;
     }
 
-    bool testLength(coord_t len) const
+    bool testLength(int32_t len) const
     {
         if (x > len || x < -len)
             return false;
@@ -95,12 +93,12 @@ public:
         return vSize2() <= len*len;
     }
 
-    coord_t vSize2() const
+    int64_t vSize2() const
     {
-        return x * x + y * y + z * z;
+        return int64_t(x)*int64_t(x)+int64_t(y)*int64_t(y)+int64_t(z)*int64_t(z);
     }
 
-    coord_t vSize() const
+    int32_t vSize() const
     {
         return sqrt(vSize2());
     }
@@ -112,33 +110,25 @@ public:
         double fz = INT2MM(z);
         return sqrt(fx*fx+fy*fy+fz*fz);
     }
-    Point3 cross(const Point3& p)
+    /*! this function is deprecated because it can cause overflows for vectors which easily fit inside a printer. Use FPoint3.cross(a,b) instead. */
+    DEPRECATED(Point3 cross(const Point3& p))
     {
         return Point3(
-            y*p.z-z*p.y,
-            z*p.x-x*p.z,
+            y*p.z-z*p.y, /// dangerous for vectors longer than 4.6 cm !!!!!
+            z*p.x-x*p.z, /// can cause overflows
             x*p.y-y*p.x);
     }
 
-    coord_t dot(const Point3& p) const
+    int64_t dot(const Point3& p) const
     {
         return x*p.x + y*p.y + z*p.z;
     }
 
-    Point3 normal(coord_t desired_length) const
-    {
-        coord_t current_length = vSize();
-        if (current_length < 1)
-        {
-            return Point3(0, 0, desired_length);
-        }
-        return *this * desired_length / current_length;
-    }
 };
 
-static Point3 no_point3(std::numeric_limits<coord_t>::max(), std::numeric_limits<coord_t>::max(), std::numeric_limits<coord_t>::max());
+static Point3 no_point3(std::numeric_limits<int32_t>::infinity(), std::numeric_limits<int32_t>::infinity(), std::numeric_limits<int32_t>::infinity());
     
-inline Point3 operator*(const coord_t i, const Point3& rhs) {
+inline Point3 operator*(const int32_t i, const Point3& rhs) {
     return rhs * i;
 }
 
@@ -146,6 +136,8 @@ inline Point3 operator*(const double d, const Point3& rhs) {
     return rhs * d;
 }
 
+using coord_t = ClipperLib::cInt;
+
 /* 64bit Points are used mostly troughout the code, these are the 2D points from ClipperLib */
 typedef ClipperLib::IntPoint Point;
 
@@ -154,10 +146,10 @@ public:
     int X, Y;
     Point p() { return Point(X, Y); }
 };
-#define POINT_MIN std::numeric_limits<coord_t>::min()
-#define POINT_MAX std::numeric_limits<coord_t>::max()
+#define POINT_MIN std::numeric_limits<ClipperLib::cInt>::min()
+#define POINT_MAX std::numeric_limits<ClipperLib::cInt>::max()
 
-static Point no_point(std::numeric_limits<coord_t>::max(), std::numeric_limits<coord_t>::max());
+static Point no_point(std::numeric_limits<int32_t>::infinity(), std::numeric_limits<int32_t>::infinity());
 
 /* Extra operators to make it easier to do math with the 64bit Point objects */
 INLINE Point operator-(const Point& p0) { return Point(-p0.X, -p0.Y); }

src/utils/linearAlg2D.h

@@ -160,7 +160,7 @@ public:
         if (ac_size == 0) 
         {
             int64_t ab_dist2 = vSize2(ab); 
-            if (ab_dist2 == 0 && b_is_beyond_ac)
+            if (ab_dist2 == 0)
             {
                 *b_is_beyond_ac = 0; // a is on b is on c
             }

src/utils/polygon.cpp

@@ -190,16 +190,6 @@ unsigned int Polygons::findInside(Point p, bool border_result)
     return ret;
 }
 
-Polygons Polygons::removeComplexParts() const
-{
-    Polygons ret;
-    ClipperLib::Clipper clipper(clipper_init);
-    clipper.AddPaths(paths, ClipperLib::ptSubject, true);
-    clipper.Execute(ClipperLib::ctUnion, ret.paths, ClipperLib::pftPositive);
-    return ret;
-}
-
-
 Polygons Polygons::offset(int distance, ClipperLib::JoinType join_type, double miter_limit) const
 {
     Polygons ret;
@@ -847,7 +837,6 @@ void PolygonRef::smooth_corner_simple(ListPolygon& poly, const Point p0, const P
             Point b;
             bool success = LinearAlg2D::getPointOnLineWithDist(a, p1, p2, shortcut_length, b);
             // v02 has to be longer than ab!
-            p1_it.remove();
             if (success)
             { // if not success then assume b is negligibly close to 2, but rounding errors caused a problem
 #ifdef ASSERT_INSANE_OUTPUT
@@ -855,6 +844,7 @@ void PolygonRef::smooth_corner_simple(ListPolygon& poly, const Point p0, const P
 #endif // #ifdef ASSERT_INSANE_OUTPUT
                 ListPolyIt::insertPointNonDuplicate(p1_it, p2_it, b);
             }
+            p1_it.remove();
         }
     }
 }

src/utils/polygon.h

@@ -859,18 +859,6 @@ public:
         return ret;
     }
 
-    /*!
-     * Remove holes which are lying outside of parts, and outlines inside of parts
-     * 
-     *         ^↘
-     *         ^  ↘
-     * <<<<<<<<^<<<<   should become  <<<<<<<<
-     *         ^                              ^
-     *         ^                              ^
-     *         ^                              ^
-     */
-    Polygons removeComplexParts() const;
-
     int64_t polygonLength() const
     {
         int64_t length = 0;

src/utils/string.h

@@ -1,3 +1,6 @@
+//Copyright (c) 2017 Ultimaker B.V.
+//CuraEngine is released under the terms of the AGPLv3 or higher.
+
 #ifndef UTILS_STRING_H
 #define UTILS_STRING_H
 
@@ -35,7 +38,7 @@ static inline void writeInt2mm(const int64_t coord, std::ostream& ss)
 {
     constexpr size_t buffer_size = 24;
     char buffer[buffer_size];
-    int char_count = sprintf(buffer, "%" PRId64, coord); // convert int to string
+    int char_count = sprintf(buffer, "%d", int(coord)); // convert int to string
 #ifdef DEBUG
     if (char_count + 1 >= int(buffer_size)) // + 1 for the null character
     {

src/wallOverlap.cpp

@@ -17,15 +17,6 @@ WallOverlapComputation::WallOverlapComputation(Polygons& polygons, int line_widt
 
 }
 
-float WallOverlapComputation::getFlow(const Polygons& from, unsigned int poly_idx, unsigned int from_point_idx, unsigned int to_point_idx)
-{
-    assert(poly_idx < from.size());
-    PolygonRef poly = from[poly_idx];
-    assert(from_point_idx < poly.size());
-    assert(to_point_idx < poly.size());
-    return getFlow(poly[from_point_idx], poly[to_point_idx]);
-}
-
 
 float WallOverlapComputation::getFlow(Point& from, Point& to)
 {

src/wallOverlap.h

@@ -17,8 +17,6 @@
 #include "utils/ProximityPointLink.h"
 #include "utils/PolygonProximityLinker.h"
 
-#include "PolygonFlowAdjuster.h"
-
 namespace cura 
 {
 
@@ -46,7 +44,7 @@ namespace cura
  * The main functionality of this class is performed by the constructor, by calling the constructor of PolygonProximityLinker.
  * The adjustment during gcode generation is made with the help of WallOverlapComputation::getFlow
  */
-class WallOverlapComputation : public PolygonFlowAdjuster
+class WallOverlapComputation
 {
     PolygonProximityLinker overlap_linker;
     int64_t line_width;
@@ -64,13 +62,6 @@ public:
      */
     float getFlow(Point& from, Point& to);
 
-    /*!
-     * \see \ref WallOverlapComputation::getFlow(Point&,Point&)
-     * 
-     * \see \ref PolygonFlowAdjuster::getFlow
-     */
-    float getFlow(const Polygons& from, unsigned int poly_idx, unsigned int from_point_idx, unsigned int to_point_idx);
-
     /*!
      * Computes the neccesary priliminaries in order to efficiently compute the flow when generatign gcode paths.
      * \param polygons The wall polygons for which to compute the overlaps

tests/runtest.py

@@ -235,11 +235,14 @@ class Setting:
             tree = ast.parse(code, "eval")
             compiled = compile(code, self._key, "eval")
         except (SyntaxError, TypeError) as e:
-            print("Parse error in function (" + code + ") for setting", self._key + ":", str(e))
+            print("Parse error in function (" + str(code) + ") for setting", self._key + ":", str(e))
+            return None
         except IllegalMethodError as e:
             print("Use of illegal method", str(e), "in function (" + code + ") for setting", self._key)
+            return None
         except Exception as e:
             print("Exception in function (" + code + ") for setting", self._key + ":", str(e))
+            return None
 
         return eval(compiled, globals(), locals)