Fix CppUnit assert call

Storing it in a variable first seems to work. Don't know why.

Contributes to issue CURA-891.

.gitignore

@@ -7,14 +7,8 @@
 NUL
 *.gcode
 
-## Directories used for other stuff
-Trash/*
-output/*
-callgrind/*
-
 ## Building result.
 build/*
-debug_build/*
 *.pyc
 *.exe
 *.a

CMakeLists.txt

@@ -28,11 +28,10 @@ set(CURA_ENGINE_VERSION "master" CACHE STRING "Version name of Cura")
 option(BUILD_TESTS OFF)
 
 # Add a compiler flag to check the output for insane values if we are in debug mode.
-if(CMAKE_BUILD_TYPE MATCHES DEBUG OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo)
+if(CMAKE_BUILD_TYPE MATCHES DEBUG)
     message(STATUS "Building debug release of CuraEngine.")
     add_definitions(-DASSERT_INSANE_OUTPUT)
     add_definitions(-DUSE_CPU_TIME)
-    add_definitions(-DDEBUG)
 endif()
 
 # Add warnings
@@ -42,16 +41,6 @@ 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)
@@ -66,20 +55,20 @@ set(engine_SRCS # Except main.cpp.
     src/FffProcessor.cpp
     src/gcodeExport.cpp
     src/GCodePathConfig.cpp
+    src/gcodePlanner.cpp
     src/infill.cpp
+    src/WallsComputation.cpp
     src/layerPart.cpp
-    src/LayerPlan.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
     src/raft.cpp
     src/skin.cpp
-    src/SkirtBrim.cpp
+    src/skirt.cpp
     src/sliceDataStorage.cpp
     src/slicer.cpp
     src/support.cpp
@@ -94,18 +83,13 @@ set(engine_SRCS # Except main.cpp.
     src/infill/ZigzagConnectorProcessorDisconnectedEndPieces.cpp
     src/infill/ZigzagConnectorProcessorEndPieces.cpp
     src/infill/ZigzagConnectorProcessorNoEndPieces.cpp
-    src/infill/SubDivCube.cpp
 
     src/pathPlanning/Comb.cpp
-    src/pathPlanning/GCodePath.cpp
     src/pathPlanning/LinePolygonsCrossings.cpp
-    src/pathPlanning/NozzleTempInsert.cpp
-    src/pathPlanning/TimeMaterialEstimates.cpp
 
     src/progress/Progress.cpp
     src/progress/ProgressStageEstimator.cpp
 
-    src/settings/PathConfigStorage.cpp
     src/settings/SettingConfig.cpp
     src/settings/SettingContainer.cpp
     src/settings/SettingRegistry.cpp
@@ -116,12 +100,9 @@ set(engine_SRCS # Except main.cpp.
     src/utils/Date.cpp
     src/utils/gettime.cpp
     src/utils/LinearAlg2D.cpp
-    src/utils/ListPolyIt.cpp
     src/utils/logoutput.cpp
-    src/utils/PolygonProximityLinker.cpp
     src/utils/polygonUtils.cpp
     src/utils/polygon.cpp
-    src/utils/ProximityPointLink.cpp
 )
 
 # List of tests. For each test there must be a file tests/${NAME}.cpp and a file tests/${NAME}.h.
@@ -131,11 +112,10 @@ set(engine_TEST
 set(engine_TEST_INFILL
 )
 set(engine_TEST_UTILS
-    SparseGridTest
+    BucketGrid2DTest
     LinearAlg2DTest
     PolygonUtilsTest
     PolygonTest
-    StringTest
 )
 
 # Generating ProtoBuf protocol
@@ -187,4 +167,4 @@ add_custom_command(TARGET CuraEngine POST_BUILD
 # Installing CuraEngine.
 include(GNUInstallDirs)
 install(TARGETS CuraEngine DESTINATION ${CMAKE_INSTALL_BINDIR})
-include(CPackConfig.cmake)
+include(CPackConfig.cmake)

Cura.proto

@@ -13,7 +13,6 @@ message Slice
     repeated ObjectList object_lists = 1; // The meshgroups to be printed one after another
     SettingList global_settings = 2; // The global settings used for the whole print job
     repeated Extruder extruders = 3; // The settings sent to each extruder object
-    repeated SettingExtruder limit_to_extruder = 4; // From which stack the setting would inherit if not defined per object
 }
 
 message Extruder
@@ -56,42 +55,19 @@ message Polygon {
         SupportInfillType = 7;
         MoveCombingType = 8;
         MoveRetractionType = 9;
-        SupportInterfaceType = 10;
     }
     Type type = 1; // Type of move
     bytes points = 2; // The points of the polygon, or two points if only a line segment (Currently only line segments are used)
     float line_width = 3; // The width of the line being laid down
 }
 
-message LayerOptimized {
-    int32 id = 1;
-    float height = 2; // Z position
-    float thickness = 3; // height of a single layer
-
-    repeated PathSegment path_segment = 4; // layer data
-}
-
-
-message PathSegment {
-    int32 extruder = 1; // The extruder used for this path segment
-    enum PointType {
-        Point2D = 0;
-        Point3D = 1;
-    }
-    PointType point_type = 2;
-    bytes points = 3; // The points defining the line segments, bytes of float[2/3] array of length N+1
-    bytes line_type = 4; // Type of line segment as an unsigned char array of length 1 or N, where N is the number of line segments in this path
-    bytes line_width = 5; // The widths of the line segments as bytes of a float array of length 1 or N
-}
-
-
 message GCodeLayer {
     bytes data = 2;
 }
 
-
-message PrintTimeMaterialEstimates { // The print time for the whole print and material estimates for the extruder
+message PrintTimeMaterialEstimates { // The print time for the whole print and material estimates for each extruder
     float time = 1; // Total time estimate
+
     repeated MaterialEstimates materialEstimates = 2; // materialEstimates data
 }
 
@@ -110,14 +86,8 @@ message Setting {
     bytes value = 2; // The value of the setting
 }
 
-message SettingExtruder {
-    string name = 1; //The setting key.
-
-    int32 extruder = 2; //From which extruder stack the setting should inherit.
-}
-
 message GCodePrefix {
-    bytes data = 2; //Header string to be prepended before the rest of the g-code sent from the engine.
+    bytes data = 2; // Header string to be prenpended before the rest of the gcode sent from the engine
 }
 
 message SlicingFinished {

Doxyfile

@@ -832,7 +832,7 @@ EXAMPLE_RECURSIVE      = NO
 # that contain images that are to be included in the documentation (see the
 # \image command).
 
-IMAGE_PATH             = docs/assets
+IMAGE_PATH             = documentation/assets
 
 # The INPUT_FILTER tag can be used to specify a program that doxygen should
 # invoke to filter for each input file. Doxygen will invoke the filter program

README.md

@@ -19,34 +19,33 @@ But in general it boils down to: You need to share the source of any CuraEngine
 How to Install
 ==============
 1. Clone the repository from https://github.com/Ultimaker/CuraEngine.git (the URL at the right hand side of this page).
-2. Install Protobuf >= 3.0.0 (see below)
+2. Install Protobuf (see below)
 3. Install libArcus (see https://github.com/Ultimaker/libArcus)
 
 In order to compile CuraEngine, either use CMake or start a project in your preferred IDE. 
 CMake compilation:
 
 1. Navigate to the CuraEngine directory and execute the following commands
-2. ```$ mkdir build && cd build```
-3. ```$ cmake ..```
-4. ```$ make```
+2. $ mkdir build && cd build
+3. $ cmake ..
+4. $ make
 
 Project files generation:
-
 1. Navigate to the CuraEngine directory and execute the following commands
-2. ```cmake . -G "CodeBlocks - Unix Makefiles"```
+2. cmake . -G "CodeBlocks - Unix Makefiles"
 3. (for a list of supported IDE's see http://www.cmake.org/Wiki/CMake_Generator_Specific_Information#Code::Blocks_Generator)
 
 Installing Protobuf
 -------------------
 1. Be sure to have libtool installed.
-2. Download protobuf from https://github.com/google/protobuf/releases (download ZIP and unZIP at desired location, or clone the repo). The protocol buffer is used for communication between the CuraEngine and the GUI.
-3. Run ```autogen.sh``` from the protobuf directory: 
-   ```$ ./autogen.sh```
-4. ```$ ./configure```
-5. ```$ make```
-6. ```# make install```  
-   (Please note the ```#```. It indicates the need of superuser, as known as root, priviliges.)
-7. (In case the shared library cannot be loaded, you can try ```sudo ldconfig``` on Linux systems)
+2. Download protobuf from https://github.com/google/protobuf/ (download ZIP and unZIP at desired location, or clone the repo) The protocol buffer is used for communication between the CuraEngine and the GUI.
+3. Before installing protobuf, change autogen.sh : comment line 18 to line 38 using '#'s. This removes the dependency on gtest-1.7.0.
+4. Run autogen.sh from the protobuf directory: 
+   $ ./autogen.sh
+5. $ ./configure
+6. $ make
+7. $ make install     # Requires superused priviliges.
+8. (In case the shared library cannot be loaded, you can try "sudo ldconfig" on Linux systems)
 
 Running
 =======

documentation/Link_to_index.html

@@ -0,0 +1 @@
+html/index.html

documentation/mainpage.md

@@ -7,4 +7,4 @@ This is the documentation for CuraEngine, the back-end slicer of Cura.
 
 [Glossary](documentation/glossary.md)
 
-[Code Conventions](https://github.com/Ultimaker/Meta/blob/master/code_conventions.md)
+[Code Conventions](documentation/code_conventions.md)

libs/clipper/License.txt

@@ -1,24 +1,26 @@
+The Clipper Library (including Delphi, C++ & C# source code, other accompanying
+code, examples and documentation), hereafter called "the Software", has been 
+released under the following license, terms and conditions:
+
 Boost Software License - Version 1.0 - August 17th, 2003
 http://www.boost.org/LICENSE_1_0.txt
 
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
+Permission is hereby granted, free of charge, to any person or organization 
+obtaining a copy of the Software covered by this license to use, reproduce, 
+display, distribute, execute, and transmit the Software, and to prepare 
+derivative works of the Software, and to permit third-parties to whom the 
+Software is furnished to do so, all subject to the following:
 
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
+The copyright notices in the Software and this entire statement, including the 
+above license grant, this restriction and the following disclaimer, must be 
+included in all copies of the Software, in whole or in part, and all derivative 
+works of the Software, unless such copies or derivative works are solely in the 
+form of machine-executable object code generated by a source language processor.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL 
+THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY 
+DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING 
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+THE SOFTWARE.

libs/clipper/README

@@ -1,39 +1,8 @@
 =====================================================================
 Clipper Change Log
 =====================================================================
-v6.2.1 (31 October 2014) Rev 482
-* Bugfix in ClipperOffset.Execute where the Polytree.IsHole property 
-  was returning incorrect values with negative offsets
-* Very minor improvement to join rounding in ClipperOffset
-* Fixed CPP OpenGL demo.
 
-v6.2.0 (17 October 2014) Rev 477
-* Numerous minor bugfixes, too many to list. 
-  (See revisions 454-475 in Sourceforge Repository)
-* The ZFillFunction (custom callback function) has had its parameters 
-  changed. 
-* Curves demo removed (temporarily).
-* Deprecated functions have been removed. 
-
-v6.1.5 (26 February 2014) Rev 460
-* Improved the joining of output polygons sharing a common edge 
-  when those common edges are horizontal.
-* Fixed a bug in ClipperOffset.AddPath() which would produce
-  incorrect solutions when open paths were added before closed paths.
-* Minor code tidy and performance improvement
-
-v6.1.4 (6 February 2014)
-* Fixed bugs in MinkowskiSum
-* Fixed minor bug when using Clipper.ForceSimplify.
-* Modified use_xyz callback so that all 4 vertices around an
-  intersection point are now passed to the callback function.
-
-v6.1.3a (22 January 2014) Rev 453
-* Fixed buggy PointInPolygon function (C++ and C# only). 
-  Note this bug only affected the newly exported function, the 
-  internal PointInPolygon function used by Clipper was OK.
- 
-v6.1.3 (19 January 2014) Rev 452
+v6.1.3 (19 January 2014)
 * Fixed potential endless loop condition when adding open 
   paths to Clipper.
 * Fixed missing implementation of SimplifyPolygon function 
@@ -44,11 +13,11 @@ v6.1.3 (19 January 2014) Rev 452
 * Overloaded MinkowskiSum function to accommodate multi-contour 
   paths.  
 
-v6.1.2 (15 December 2013) Rev 444
+v6.1.2 (15 December 2013)
 * Fixed broken C++ header file.
 * Minor improvement to joining polygons.
 
-v6.1.1 (13 December 2013) Rev 441
+v6.1.1 (13 December 2013)
 * Fixed a couple of bugs affecting open paths that could 
   raise unhandled exceptions.
   

libs/clipper/clipper.hpp

@@ -1,8 +1,8 @@
 /*******************************************************************************
 *                                                                              *
 * Author    :  Angus Johnson                                                   *
-* Version   :  6.2.1                                                           *
-* Date      :  31 October 2014                                                 *
+* Version   :  6.1.3a                                                          *
+* Date      :  22 January 2014                                                 *
 * Website   :  http://www.angusj.com                                           *
 * Copyright :  Angus Johnson 2010-2014                                         *
 *                                                                              *
@@ -34,7 +34,7 @@
 #ifndef clipper_hpp
 #define clipper_hpp
 
-#define CLIPPER_VERSION "6.2.0"
+#define CLIPPER_VERSION "6.1.3"
 
 //use_int32: When enabled 32bit ints are used instead of 64bit ints. This
 //improve performance but coordinate values are limited to the range +/- 46340
@@ -44,10 +44,11 @@
 //#define use_xyz
 
 //use_lines: Enables line clipping. Adds a very minor cost to performance.
-#define use_lines
+//#define use_lines
   
-//use_deprecated: Enables temporary support for the obsolete functions
-//#define use_deprecated  
+//use_deprecated: Enables support for the obsolete OffsetPaths() function
+//which has been replace with the ClipperOffset class.
+#define use_deprecated  
 
 #include <vector>
 #include <set>
@@ -56,7 +57,6 @@
 #include <cstdlib>
 #include <ostream>
 #include <functional>
-#include <queue>
 
 namespace ClipperLib {
 
@@ -69,16 +69,11 @@ enum PolyType { ptSubject, ptClip };
 enum PolyFillType { pftEvenOdd, pftNonZero, pftPositive, pftNegative };
 
 #ifdef use_int32
-  typedef int cInt;
-  static cInt const loRange = 0x7FFF;
-  static cInt const hiRange = 0x7FFF;
+typedef int cInt;
+typedef unsigned int cUInt;
 #else
-  typedef signed long long cInt;
-  static cInt const loRange = 0x3FFFFFFF;
-  static cInt const hiRange = 0x3FFFFFFFFFFFFFFFLL;
-  typedef signed long long long64;     //used by Int128 class
-  typedef unsigned long long ulong64;
-
+typedef signed long long cInt;
+typedef unsigned long long cUInt;
 #endif
 
 struct IntPoint {
@@ -122,12 +117,15 @@ struct DoublePoint
 //------------------------------------------------------------------------------
 
 #ifdef use_xyz
-typedef void (*ZFillCallback)(IntPoint& e1bot, IntPoint& e1top, IntPoint& e2bot, IntPoint& e2top, IntPoint& pt);
+typedef void (*TZFillCallback)(IntPoint& z1, IntPoint& z2, IntPoint& pt);
 #endif
 
 enum InitOptions {ioReverseSolution = 1, ioStrictlySimple = 2, ioPreserveCollinear = 4};
 enum JoinType {jtSquare, jtRound, jtMiter};
 enum EndType {etClosedPolygon, etClosedLine, etOpenButt, etOpenSquare, etOpenRound};
+#ifdef use_deprecated
+  enum EndType_ {etClosed, etButt = 2, etSquare, etRound};
+#endif
 
 class PolyNode;
 typedef std::vector< PolyNode* > PolyNodes;
@@ -136,7 +134,6 @@ class PolyNode
 { 
 public:
     PolyNode();
-    virtual ~PolyNode(){};
     Path Contour;
     PolyNodes Childs;
     PolyNode* Parent;
@@ -171,6 +168,11 @@ bool Orientation(const Path &poly);
 double Area(const Path &poly);
 int PointInPolygon(const IntPoint &pt, const Path &path);
 
+#ifdef use_deprecated
+  void OffsetPaths(const Paths &in_polys, Paths &out_polys,
+    double delta, JoinType jointype, EndType_ endtype, double limit = 0);
+#endif
+
 void SimplifyPolygon(const Path &in_poly, Paths &out_polys, PolyFillType fillType = pftEvenOdd);
 void SimplifyPolygons(const Paths &in_polys, Paths &out_polys, PolyFillType fillType = pftEvenOdd);
 void SimplifyPolygons(Paths &polys, PolyFillType fillType = pftEvenOdd);
@@ -181,7 +183,8 @@ void CleanPolygons(const Paths& in_polys, Paths& out_polys, double distance = 1.
 void CleanPolygons(Paths& polys, double distance = 1.415);
 
 void MinkowskiSum(const Path& pattern, const Path& path, Paths& solution, bool pathIsClosed);
-void MinkowskiSum(const Path& pattern, const Paths& paths, Paths& solution, bool pathIsClosed);
+void MinkowskiSum(const Path& pattern, const Paths& paths, 
+  Paths& solution, PolyFillType pathFillType, bool pathIsClosed);
 void MinkowskiDiff(const Path& poly1, const Path& poly2, Paths& solution);
 
 void PolyTreeToPaths(const PolyTree& polytree, Paths& paths);
@@ -199,7 +202,7 @@ enum EdgeSide { esLeft = 1, esRight = 2};
 //forward declarations (for stuff used internally) ...
 struct TEdge;
 struct IntersectNode;
-struct LocalMinimum;
+struct LocalMinima;
 struct Scanbeam;
 struct OutPt;
 struct OutRec;
@@ -210,6 +213,7 @@ typedef std::vector < TEdge* > EdgeList;
 typedef std::vector < Join* > JoinList;
 typedef std::vector < IntersectNode* > IntersectList;
 
+
 //------------------------------------------------------------------------------
 
 //ClipperBase is the ancestor to the Clipper class. It should not be
@@ -232,14 +236,12 @@ protected:
   void PopLocalMinima();
   virtual void Reset();
   TEdge* ProcessBound(TEdge* E, bool IsClockwise);
+  void InsertLocalMinima(LocalMinima *newLm);
   void DoMinimaLML(TEdge* E1, TEdge* E2, bool IsClosed);
   TEdge* DescendToMin(TEdge *&E);
   void AscendToMax(TEdge *&E, bool Appending, bool IsClosed);
-
-  typedef std::vector<LocalMinimum> MinimaList;
-  MinimaList::iterator m_CurrentLM;
-  MinimaList           m_MinimaList;
-
+  LocalMinima      *m_CurrentLM;
+  LocalMinima      *m_MinimaList;
   bool              m_UseFullRange;
   EdgeList          m_edges;
   bool             m_PreserveCollinear;
@@ -266,7 +268,7 @@ public:
   void StrictlySimple(bool value) {m_StrictSimple = value;};
   //set the callback function for z value filling on intersections (otherwise Z is 0)
 #ifdef use_xyz
-  void ZFillFunction(ZFillCallback zFillFunc);
+  void ZFillFunction(TZFillCallback zFillFunc);
 #endif
 protected:
   void Reset();
@@ -277,8 +279,7 @@ private:
   JoinList          m_GhostJoins;
   IntersectList     m_IntersectList;
   ClipType          m_ClipType;
-  typedef std::priority_queue<cInt> ScanbeamList;
-  ScanbeamList      m_Scanbeam;
+  std::set< cInt, std::greater<cInt> > m_Scanbeam;
   TEdge           *m_ActiveEdges;
   TEdge           *m_SortedEdges;
   bool             m_ExecuteLocked;
@@ -288,7 +289,7 @@ private:
   bool             m_UsingPolyTree; 
   bool             m_StrictSimple;
 #ifdef use_xyz
-  ZFillCallback   m_ZFill; //custom callback 
+  TZFillCallback   m_ZFill; //custom callback 
 #endif
   void SetWindingCount(TEdge& edge);
   bool IsEvenOddFillType(const TEdge& edge) const;
@@ -307,19 +308,21 @@ private:
   bool IsTopHorz(const cInt XPos);
   void SwapPositionsInAEL(TEdge *edge1, TEdge *edge2);
   void DoMaxima(TEdge *e);
+  void PrepareHorzJoins(TEdge* horzEdge, bool isTopOfScanbeam);
   void ProcessHorizontals(bool IsTopOfScanbeam);
   void ProcessHorizontal(TEdge *horzEdge, bool isTopOfScanbeam);
   void AddLocalMaxPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
   OutPt* AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
   OutRec* GetOutRec(int idx);
   void AppendPolygon(TEdge *e1, TEdge *e2);
-  void IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &pt);
+  void IntersectEdges(TEdge *e1, TEdge *e2,
+    const IntPoint &pt, bool protect = false);
   OutRec* CreateOutRec();
   OutPt* AddOutPt(TEdge *e, const IntPoint &pt);
   void DisposeAllOutRecs();
   void DisposeOutRec(PolyOutList::size_type index);
-  bool ProcessIntersections(const cInt topY);
-  void BuildIntersectList(const cInt topY);
+  bool ProcessIntersections(const cInt botY, const cInt topY);
+  void BuildIntersectList(const cInt botY, const cInt topY);
   void ProcessIntersectList();
   void ProcessEdgesAtTopOfScanbeam(const cInt topY);
   void BuildResult(Paths& polys);
@@ -341,7 +344,7 @@ private:
   void FixupFirstLefts1(OutRec* OldOutRec, OutRec* NewOutRec);
   void FixupFirstLefts2(OutRec* OldOutRec, OutRec* NewOutRec);
 #ifdef use_xyz
-  void SetZ(IntPoint& pt, TEdge& e1, TEdge& e2);
+  void SetZ(IntPoint& pt, TEdge& e);
 #endif
 };
 //------------------------------------------------------------------------------

meta/HOWTO.txt

@@ -9,7 +9,7 @@ cd ~/Development/CuraEngine/output/reflection/
 run setting inheritance reflection
 
 cd ~/Development/CuraEngine
-./build/CuraEngine analyse ../Cura/resources/definitions/fdmprinter.def.json meta/refl_ff.gv output/reflection/engineSettingLiterals.txt -piew
+./build/CuraEngine analyse ../Cura/resources/machines/fdmprinter.json meta/refl_ff.gv output/reflection/engineSettingLiterals.txt -piew
 
 dot meta/refl_ff.gv -Tpng > meta/rafl_ff_dotted.png
 

resources/command_line_settings.def.json

@@ -0,0 +1,52 @@
+{
+    "version": 2,
+    "name": "Command line setting defaults CuraEngine",
+    "metadata":
+    {
+        "author": "Ultimaker B.V."
+    },
+    "settings": {
+        "command_line_settings": {
+            "label": "Command Line Settings",
+            "type": "category",
+            "children": {
+                "center_object": {
+                    "description": "Whether to center the object on the middle of the build platform (0,0), instead of using the coordinate system in which the object was saved.",
+                    "type": "bool",
+                    "label": "Center object",
+                    "default_value": true
+                },
+                "machine_print_temp_wait": {
+                    "description": "Whether to wait for the nozzle temperature to be reached when preheating the nozzles at the start of the gcode.",
+                    "type": "bool",
+                    "label": "Machine print temp wait",
+                    "default_value": true
+                },
+                "mesh_position_x": {
+                    "description": "Offset applied to the object in the x direction.",
+                    "type": "float",
+                    "label": "Mesh position x",
+                    "default_value": 0
+                },
+                "mesh_position_y": {
+                    "description": "Offset applied to the object in the y direction.",
+                    "type": "float",
+                    "label": "Mesh position y",
+                    "default_value": 0
+                },
+                "mesh_position_z": {
+                    "description": "Offset applied to the object in the z direction. With this you can perform what was used to call 'Object Sink'.",
+                    "type": "float",
+                    "label": "Mesh position z",
+                    "default_value": 0
+                },
+                "prime_tower_dir_outward": {
+                    "description": "Whether to start printing in the middle of the prime tower and end up at the perimeter, or the other way around. This is only used for certain types of prime tower.",
+                    "type": "bool",
+                    "label": "Prime tower direction outward",
+                    "default_value": false
+                }
+            }
+        }
+    }
+}

src/ConicalOverhang.cpp

@@ -20,7 +20,7 @@ void ConicalOverhang::apply(Slicer* slicer, double angle, int layer_thickness)
             int safe_dist = 20;
             Polygons diff = layer_above.polygons.difference(layer.polygons.offset(-safe_dist));
             layer.polygons = layer.polygons.unionPolygons(diff);
-            layer.polygons = layer.polygons.smooth(safe_dist);
+            layer.polygons = layer.polygons.smooth(safe_dist, 100*100);
             layer.polygons.simplify(safe_dist, safe_dist * safe_dist / 4);
             // somehow layer.polygons get really jagged lines with a lot of vertices
             // without the above steps slicing goes really slow

src/ExtruderTrain.cpp

@@ -13,15 +13,4 @@ ExtruderTrain::ExtruderTrain(SettingsBaseVirtual* settings, int extruder_nr)
 {
 }
 
-bool ExtruderTrain::getIsUsed() const
-{
-    return is_used;
-}
-
-void ExtruderTrain::setIsUsed(bool used)
-{
-    is_used = used;
-}
-
-
 }//namespace cura

src/ExtruderTrain.h

@@ -10,13 +10,9 @@ namespace cura
 class ExtruderTrain : public SettingsBase
 {
     int extruder_nr;
-    bool is_used = false; //!< whether this extruder train is (probably) used during printing the current meshgroup
 public:
     int getExtruderNr();
 
-    bool getIsUsed() const; //!< return whether this extruder train is (probably) used during printing the current meshgroup
-    void setIsUsed(bool used); //!< set whether this extruder train is (probably) used during printing the current meshgroup
-
     ExtruderTrain(SettingsBaseVirtual* settings, int extruder_nr);
 
 };

src/FanSpeedLayerTime.h

@@ -11,7 +11,6 @@ struct FanSpeedLayerTimeSettings
 public:
     double cool_min_layer_time;
     double cool_min_layer_time_fan_speed_max;
-    double cool_fan_speed_0;
     double cool_fan_speed_min;
     double cool_fan_speed_max;
     double cool_min_speed;

src/FffGcodeWriter.h

@@ -12,7 +12,7 @@
 #include "infill.h"
 #include "bridge.h"
 #include "pathOrderOptimizer.h"
-#include "LayerPlan.h"
+#include "gcodePlanner.h"
 #include "gcodeExport.h"
 #include "commandSocket.h"
 #include "PrimeTower.h"
@@ -40,7 +40,7 @@ private:
     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 LayerPlan)
+     * Buffer for all layer plans (of type GCodePlanner)
      * 
      * The layer plans are buffered so that we can start heating up a nozzle several layers before it needs to be used.
      * Another reason is to perform Auto Temperature.
@@ -60,34 +60,32 @@ private:
     std::ofstream output_file;
 
     /*!
-     * Whether the skirt or brim polygons have been processed into planned paths
-     * for each extruder train.
+     * Layer number of the last layer in which a prime tower has been printed per extruder train.  
+     * 
+     * This is recorded per extruder to account for a prime tower per extruder, instead of the mixed prime tower.
      */
-    bool skirt_brim_is_processed[MAX_EXTRUDERS];
+    int last_prime_tower_poly_printed[MAX_EXTRUDERS]; 
 
-    std::vector<std::vector<unsigned int>> mesh_order_per_extruder; //!< For each extruder, the cyclic order of the meshes (the first element is not the starting element per se)
-
-    /*!
-     * For each extruder whether priming has already been planned
-     */
-    bool extruder_prime_is_planned[MAX_EXTRUDERS];
+    bool skirt_is_processed[MAX_EXTRUDERS]; //!< Whether the skirt polygons have been processed into planned paths for each extruder train
 
     std::vector<FanSpeedLayerTimeSettings> fan_speed_layer_time_settings_per_extruder; //!< The settings used relating to minimal layer time and fan speeds. Configured for each extruder.
 
-
-    LayerPlan::PlanningState planner_state;
-
+    Point last_position_planned; //!< The position of the head before planning the next layer
+    int current_extruder_planned; //!< The extruder train in use before planning the next layer
+    bool is_inside_mesh_layer_part; //!< Whether the last position was inside a layer part (used in combing)
 public:
     FffGcodeWriter(SettingsBase* settings_)
     : SettingsMessenger(settings_)
-    , max_object_height(0)
     , layer_plan_buffer(this, gcode)
-    , extruder_prime_is_planned {} // initialize all values in array with [false]
-    , planner_state{ no_point
-                    , 0 // changed somewhere early in FffGcodeWriter::writeGCode
-                    , false
-                    }
+    , last_position_planned(no_point)
+    , current_extruder_planned(0) // changed somewhere early in FffGcodeWriter::writeGCode
+    , is_inside_mesh_layer_part(false)
     {
+        max_object_height = 0;
+        for (unsigned int extruder_nr = 0; extruder_nr < MAX_EXTRUDERS; extruder_nr++)
+        {
+            skirt_is_processed[extruder_nr] = false;
+        }
     }
 
     /*!
@@ -173,79 +171,58 @@ private:
      * \param[out] storage The data storage to which to save the configurations
      */
     void setConfigRetraction(SliceDataStorage& storage);
-
+    
     /*!
-     * Get the extruder with which to start the print.
+     * Initialize the GcodePathConfig config parameters which don't change over all layers, for each feature.
      * 
-     * Generally this is the adhesion_extruder_nr, but in case the platform adhesion type is none,
-     * the extruder with lowest number which is used on the first layer is used as initial extruder.
+     * The features are: skirt, support and for each mesh: outer wall, inner walls, skin, infill (and combined infill)
      * 
-     * \param[in] storage where to get settings from.
+     * \param[out] storage The data storage to which to save the configurations
      */
-    unsigned int getStartExtruder(const SliceDataStorage& storage);
-
+    void initConfigs(SliceDataStorage& storage);
+    
     /*!
      * Set temperatures and perform initial priming.
      * 
      * Write a stub header if CuraEngine is in command line tool mode. (Cause writing the header afterwards would entail moving all gcode down.)
      * 
      * \param[in] storage where the slice data is stored.
-     * \param[in] start_extruder_nr The extruder with which to start the print.
      */
-    void processStartingCode(const SliceDataStorage& storage, const unsigned int start_extruder_nr);
+    void processStartingCode(SliceDataStorage& storage);
 
     /*!
      * Move up and over the already printed meshgroups to print the next meshgroup.
      * 
      * \param[in] storage where the slice data is stored.
      */
-    void processNextMeshGroupCode(const SliceDataStorage& storage);
+    void processNextMeshGroupCode(SliceDataStorage& storage);
     
     /*!
      * Add raft layer plans onto the FffGcodeWriter::layer_plan_buffer
      * 
-     * \param[in,out] storage where the slice data is stored.
+     * \param[in] storage where the slice data is stored.
      * \param total_layers The total number of layers.
      */
-    void processRaft(const SliceDataStorage& storage, unsigned int total_layers);
-
+    void processRaft(SliceDataStorage& storage, unsigned int total_layers);
+    
     /*!
      * Convert the polygon data of a layer into a layer plan on the FffGcodeWriter::layer_plan_buffer
      * 
-     * In case of negative layer numbers, create layers only containing the data from
-     * the helper parts (support etc) to fill up the gap between the raft and the model.
-     * 
      * \param[in] storage where the slice data is stored.
      * \param layer_nr The index of the layer to write the gcode of.
      * \param total_layers The total number of layers.
-     * \return The layer plans
+     * \param has_raft Whether a raft is used for this print.
      */
-    LayerPlan& processLayer(const SliceDataStorage& storage, int layer_nr, unsigned int total_layers) const;
-
+    void processLayer(SliceDataStorage& storage, unsigned int layer_nr, unsigned int total_layers, bool has_raft);
+    
     /*!
-     * Whether the extruders need to be primed separately just before they are used.
+     * Add the skirt to the layer plan \p gcodeLayer.
      * 
-     * \return whether the extruders need to be primed separately just before they are used
-     */
-    bool getExtrudersNeedPrimeDuringFirstLayer() const;
-
-    /*!
-     * Plan priming of all used extruders which haven't been primed yet
      * \param[in] storage where the slice data is stored.
-     * \param layer_plan The initial planning of the g-code of the layer.
-     * \param layer_nr The index of the layer to write the gcode of.
+     * \param gcodeLayer The initial planning of the gcode of the layer.
+     * \param extruder_nr The extrudewr train for which to process the skirt
      */
-    void ensureAllExtrudersArePrimed(const SliceDataStorage& storage, LayerPlan& layer_plan, const int layer_nr) const;
-
-    /*!
-     * Add the skirt or the brim to the layer plan \p gcodeLayer.
-     * 
-     * \param Storage where the slice data is stored.
-     * \param gcodeLayer The initial planning of the g-code of the layer.
-     * \param extruder_nr The extruder train for which to process the skirt or
-     * brim.
-     */
-    void processSkirtBrim(const SliceDataStorage& storage, LayerPlan& gcodeLayer, unsigned int extruder_nr) const;
+    void processSkirt(SliceDataStorage& storage, GCodePlanner& gcodeLayer, unsigned int extruder_nr);
     
     /*!
      * Adds the ooze shield to the layer plan \p gcodeLayer.
@@ -254,7 +231,7 @@ private:
      * \param gcodeLayer The initial planning of the gcode of the layer.
      * \param layer_nr The index of the layer to write the gcode of.
      */
-    void processOozeShield(const SliceDataStorage& storage, LayerPlan& gcodeLayer, unsigned int layer_nr) const;
+    void processOozeShield(SliceDataStorage& storage, GCodePlanner& gcodeLayer, unsigned int layer_nr);
     
     /*!
      * Adds the draft protection screen to the layer plan \p gcodeLayer.
@@ -263,155 +240,123 @@ private:
      * \param gcodeLayer The initial planning of the gcode of the layer.
      * \param layer_nr The index of the layer to write the gcode of.
      */
-    void processDraftShield(const SliceDataStorage& storage, LayerPlan& gcodeLayer, unsigned int layer_nr) const;
-
+    void processDraftShield(SliceDataStorage& storage, GCodePlanner& gcodeLayer, unsigned int layer_nr);
+    
     /*!
-     * Calculate in which order to plan the extruders
+     * Calculate in which order to print the meshes.
      * 
      * \param[in] storage where the slice data is stored.
      * \param current_extruder The current extruder with which we last printed
-     * \return A vector of pairs of extruder numbers coupled with the mesh indices ordered on print order for that extruder.
+     * \return A vector of mesh indices ordered on print order.
      */
-    std::vector<int> calculateExtruderOrder(const SliceDataStorage& storage, int current_extruder) const;
-
-    /*!
-     * Calculate in which order to plan the meshes of a specific extruder
-     * 
-     * \param[in] storage where the slice data is stored.
-     * \param extruder_nr The extruder for which to determine the order
-     * \return A vector of pairs of extruder numbers coupled with the mesh indices ordered on print order for that extruder.
-     */
-    std::vector<unsigned int> calculateMeshOrder(const SliceDataStorage& storage, int extruder_nr) const;
-
+    std::vector<unsigned int> calculateMeshOrder(SliceDataStorage& storage, int current_extruder);
+        
     /*!
      * Add a single layer from a single mesh-volume to the layer plan \p gcodeLayer in mesh surface mode.
      * 
      * \param[in] storage where the slice data is stored.
      * \param mesh The mesh to add to the layer plan \p gcodeLayer.
-     * \param mesh_config the line config with which to print a print feature
      * \param gcodeLayer The initial planning of the gcode of the layer.
      * \param layer_nr The index of the layer to write the gcode of.
      * 
      */
-    void addMeshLayerToGCode_meshSurfaceMode(const SliceDataStorage& storage, const SliceMeshStorage* mesh, const PathConfigStorage::MeshPathConfigs& mesh_config, LayerPlan& gcodeLayer, int layer_nr) const;
+    void addMeshLayerToGCode_meshSurfaceMode(SliceDataStorage& storage, SliceMeshStorage* mesh, GCodePlanner& gcodeLayer, int layer_nr);
     
     /*!
      * Add the open polylines from a single layer from a single mesh-volume to the layer plan \p gcodeLayer for mesh the surface modes.
      * 
      * \param[in] storage where the slice data is stored.
      * \param mesh The mesh for which to add to the layer plan \p gcodeLayer.
-     * \param mesh_config the line config with which to print a print feature
      * \param gcodeLayer The initial planning of the gcode of the layer.
      * \param layer_nr The index of the layer to write the gcode of.
      * 
      */
-    void addMeshOpenPolyLinesToGCode(const SliceDataStorage& storage, const SliceMeshStorage* mesh, const PathConfigStorage::MeshPathConfigs& mesh_config, LayerPlan& gcode_layer, int layer_nr) const;
+    void addMeshOpenPolyLinesToGCode(SliceDataStorage& storage, SliceMeshStorage* mesh, GCodePlanner& gcode_layer, int layer_nr);
     
     /*!
-     * Add a single layer from a single mesh-volume to the layer plan \p gcode_layer.
+     * Add a single layer from a single mesh-volume to the layer plan \p gcodeLayer.
      * 
      * \param[in] storage where the slice data is stored.
-     * \param mesh The mesh to add to the layer plan \p gcode_layer.
-     * \param mesh_config the line config with which to print a print feature
-     * \param gcode_layer The initial planning of the gcode of the layer.
+     * \param mesh The mesh to add to the layer plan \p gcodeLayer.
+     * \param gcodeLayer The initial planning of the gcode of the layer.
      * \param layer_nr The index of the layer to write the gcode of.
      * 
      */
-    void addMeshLayerToGCode(const SliceDataStorage& storage, const SliceMeshStorage* mesh, const PathConfigStorage::MeshPathConfigs& mesh_config, LayerPlan& gcode_layer, int layer_nr) const;
-
-    /*!
-     * Add a single part from a given layer of a mesh-volume to the layer plan \p gcode_layer.
-     * 
-     * \param[in] storage where the slice data is stored.
-     * \param mesh The mesh to add to the layer plan \p gcode_layer.
-     * \param mesh_config the line config with which to print a print feature
-     * \param part The part to add
-     * \param gcode_layer The initial planning of the gcode of the layer.
-     * \param layer_nr The index of the layer to write the gcode of.
-     * 
-     */
-    void addMeshPartToGCode(const SliceDataStorage& storage, const SliceMeshStorage* mesh, const PathConfigStorage::MeshPathConfigs& mesh_config, const SliceLayerPart& part, LayerPlan& gcode_layer, int layer_nr) const;
+    void addMeshLayerToGCode(SliceDataStorage& storage, SliceMeshStorage* mesh, GCodePlanner& gcodeLayer, int layer_nr);
     
     /*!
      * Add thicker (multiple layers) sparse infill for a given part in a layer plan.
      * 
      * \param gcodeLayer The initial planning of the gcode of the layer.
      * \param mesh The mesh for which to add to the layer plan \p gcodeLayer.
-     * \param mesh_config the line config with which to print a print feature
      * \param part The part for which to create gcode
      * \param layer_nr The current layer number.
      * \param infill_line_distance The distance between the infill lines
      * \param infill_overlap The distance by which the infill overlaps with the wall insets.
      * \param fillAngle The angle in the XY plane at which the infill is generated.
+     * \param extrusionWidth extrusionWidth
      */
-    void processMultiLayerInfill(LayerPlan& gcodeLayer, const SliceMeshStorage* mesh, const PathConfigStorage::MeshPathConfigs& mesh_config, const SliceLayerPart& part, unsigned int layer_nr, int infill_line_distance, int infill_overlap, int fillAngle) const;
+    void processMultiLayerInfill(GCodePlanner& gcodeLayer, SliceMeshStorage* mesh, SliceLayerPart& part, unsigned int layer_nr, int infill_line_distance, int infill_overlap, int fillAngle, int extrusionWidth); 
     
     /*!
      * Add normal sparse infill for a given part in a layer.
      * \param gcodeLayer The initial planning of the gcode of the layer.
      * \param mesh The mesh for which to add to the layer plan \p gcodeLayer.
-     * \param mesh_config the line config with which to print a print feature
      * \param part The part for which to create gcode
      * \param layer_nr The current layer number.
      * \param infill_line_distance The distance between the infill lines
      * \param infill_overlap The distance by which the infill overlaps with the wall insets.
      * \param fillAngle The angle in the XY plane at which the infill is generated.
+     * \param extrusionWidth extrusionWidth
      */
-    void processSingleLayerInfill(LayerPlan& gcodeLayer, const SliceMeshStorage* mesh, const PathConfigStorage::MeshPathConfigs& mesh_config, const SliceLayerPart& part, unsigned int layer_nr, int infill_line_distance, int infill_overlap, int fillAngle) const;
+    void processSingleLayerInfill(GCodePlanner& gcodeLayer, SliceMeshStorage* mesh, SliceLayerPart& part, unsigned int layer_nr, int infill_line_distance, int infill_overlap, int fillAngle, int extrusionWidth);
     
     /*!
      * Generate the insets for the walls of a given layer part.
      * \param gcodeLayer The initial planning of the gcode of the layer.
      * \param mesh The mesh for which to add to the layer plan \p gcodeLayer.
-     * \param mesh_config the line config with which to print a print feature
      * \param part The part for which to create gcode
      * \param layer_nr The current layer number.
      * \param z_seam_type dir3ective for where to start the outer paerimeter of a part
-     * \param z_seam_pos The location near where to start the outer inset in case \p z_seam_type is 'back'
      */
-    void processInsets(LayerPlan& gcodeLayer, const SliceMeshStorage* mesh, const PathConfigStorage::MeshPathConfigs& mesh_config, const SliceLayerPart& part, unsigned int layer_nr, EZSeamType z_seam_type, Point z_seam_pos) const;
+    void processInsets(GCodePlanner& gcodeLayer, SliceMeshStorage* mesh, SliceLayerPart& part, unsigned int layer_nr, EZSeamType z_seam_type);
     
     
     /*!
-     * Add the gcode of the top/bottom skin of the given part and of the perimeter gaps.
-     * 
-     * Perimter gaps are generated for skin outlines and printed while the skin fill of the skin part is printed.
-     * Perimeter gaps between the walls are added to the gcode afterwards.
-     * 
+     * Add the gcode of the top/bottom skin of the given part.
      * \param gcodeLayer The initial planning of the gcode of the layer.
      * \param mesh The mesh for which to add to the layer plan \p gcodeLayer.
-     * \param mesh_config the line config with which to print a print feature
      * \param part The part for which to create gcode
      * \param layer_nr The current layer number.
-     * \param skin_overlap The distance by which the skin overlaps with the wall insets and the distance by which the perimeter gaps overlap with adjacent print features.
+     * \param skin_overlap The distance by which the skin overlaps with the wall insets.
      * \param fillAngle The angle in the XY plane at which the infill is generated.
+     * \param extrusionWidth extrusionWidth
      */
-    void processSkinAndPerimeterGaps(LayerPlan& gcode_layer, const SliceMeshStorage* mesh, const PathConfigStorage::MeshPathConfigs& mesh_config, const SliceLayerPart& part, unsigned int layer_nr, int skin_overlap, int infill_angle) const;
-
+    void processSkin(cura::GCodePlanner& gcode_layer, cura::SliceMeshStorage* mesh, cura::SliceLayerPart& part, unsigned int layer_nr, int skin_overlap, int infill_angle, int extrusion_width);
+    
     /*!
-     * Add the support to the layer plan \p gcodeLayer of the current layer for all support parts with the given \p extruder_nr.
+     * Add the support to the layer plan \p gcodeLayer of the current layer.
      * \param[in] storage where the slice data is stored.
      * \param gcodeLayer The initial planning of the gcode of the layer.
      * \param layer_nr The index of the layer to write the gcode of.
-     * \return whether any support was added to the layer plan
+     * \param extruder_nr_before The extruder number at the start of the layer (before other print parts aka the rest)
+     * \param before_rest Whether the function has been called before adding the rest to the layer plan \p gcodeLayer, or after.
      */
-    bool addSupportToGCode(const SliceDataStorage& storage, LayerPlan& gcodeLayer, int layer_nr, int extruder_nr) const;
+    void addSupportToGCode(SliceDataStorage& storage, GCodePlanner& gcodeLayer, int layer_nr, int extruder_nr_before, bool before_rest);
     /*!
      * Add the support lines/walls to the layer plan \p gcodeLayer of the current layer.
      * \param[in] storage where the slice data is stored.
      * \param gcodeLayer The initial planning of the gcode of the layer.
      * \param layer_nr The index of the layer to write the gcode of.
-     * \return whether any support infill was added to the layer plan
      */
-    bool addSupportInfillToGCode(const SliceDataStorage& storage, LayerPlan& gcodeLayer, int layer_nr) const;
+    void addSupportInfillToGCode(SliceDataStorage& storage, GCodePlanner& gcodeLayer, int layer_nr);
     /*!
-     * Add the support skins to the layer plan \p gcodeLayer of the current layer.
+     * Add the support roofs to the layer plan \p gcodeLayer of the current layer.
      * \param[in] storage where the slice data is stored.
      * \param gcodeLayer The initial planning of the gcode of the layer.
      * \param layer_nr The index of the layer to write the gcode of.
-     * \return whether any support skin was added to the layer plan
      */
-    bool addSupportRoofsToGCode(const SliceDataStorage& storage, LayerPlan& gcodeLayer, int layer_nr) const;
+    void addSupportRoofsToGCode(SliceDataStorage& storage, GCodePlanner& gcodeLayer, int layer_nr);
     
     /*!
      * Change to a new extruder, and add the prime tower instructions if the new extruder is different from the last.
@@ -423,7 +368,7 @@ private:
      * \param layer_nr The index of the layer to write the gcode of.
      * \param extruder_nr The extruder to which to switch
      */
-    void setExtruder_addPrime(const SliceDataStorage& storage, LayerPlan& gcode_layer, int layer_nr, int extruder_nr) const;
+    void setExtruder_addPrime(SliceDataStorage& storage, GCodePlanner& gcode_layer, int layer_nr, int extruder_nr);
     
     /*!
      * Add the prime tower gcode for the current layer.
@@ -432,7 +377,7 @@ private:
      * \param layer_nr The index of the layer to write the gcode of.
      * \param prev_extruder The current extruder with which we last printed.
      */
-    void addPrimeTower(const SliceDataStorage& storage, LayerPlan& gcodeLayer, int layer_nr, int prev_extruder) const;
+    void addPrimeTower(SliceDataStorage& storage, GCodePlanner& gcodeLayer, int layer_nr, int prev_extruder);
     
     /*!
      * Add the end gcode and set all temperatures to zero.

src/FffPolygonGenerator.cpp

@@ -2,10 +2,7 @@
 
 #include <algorithm>
 #include <map> // multimap (ordered map allowing duplicate keys)
-#include <omp.h>
 
-#include "utils/math.h"
-#include "utils/algorithm.h"
 #include "slicer.h"
 #include "utils/gettime.h"
 #include "utils/logoutput.h"
@@ -14,10 +11,11 @@
 #include "multiVolumes.h"
 #include "layerPart.h"
 #include "WallsComputation.h"
-#include "SkirtBrim.h"
+#include "skirt.h"
 #include "skin.h"
 #include "infill.h"
 #include "raft.h"
+#include "debug.h"
 #include "progress/Progress.h"
 #include "PrintFeature.h"
 #include "ConicalOverhang.h"
@@ -29,7 +27,7 @@
 namespace cura
 {
 
-
+    
 bool FffPolygonGenerator::generateAreas(SliceDataStorage& storage, MeshGroup* meshgroup, TimeKeeper& timeKeeper)
 {
     if (!sliceModel(meshgroup, timeKeeper, storage)) 
@@ -42,22 +40,6 @@ bool FffPolygonGenerator::generateAreas(SliceDataStorage& storage, MeshGroup* me
     return true;
 }
 
-unsigned int FffPolygonGenerator::getDraftShieldLayerCount(const unsigned int total_layers) const
-{
-    if (!getSettingBoolean("draft_shield_enabled"))
-    {
-        return 0;
-    }
-    switch (getSettingAsDraftShieldHeightLimitation("draft_shield_height_limitation"))
-    {
-        default:
-        case DraftShieldHeightLimitation::FULL:
-            return total_layers;
-        case DraftShieldHeightLimitation::LIMITED:
-            return std::max((coord_t)0, (getSettingInMicrons("draft_shield_height") - getSettingInMicrons("layer_height_0")) / getSettingInMicrons("layer_height") + 1);
-    }
-}
-
 bool FffPolygonGenerator::sliceModel(MeshGroup* meshgroup, TimeKeeper& timeKeeper, SliceDataStorage& storage) /// slices the model
 {
     Progress::messageProgressStage(Progress::Stage::SLICING, &timeKeeper);
@@ -109,70 +91,23 @@ bool FffPolygonGenerator::sliceModel(MeshGroup* meshgroup, TimeKeeper& timeKeepe
     for(unsigned int meshIdx=0; meshIdx < slicerList.size(); meshIdx++)
     {
         Mesh& mesh = storage.meshgroup->meshes[meshIdx];
-        if (mesh.getSettingBoolean("conical_overhang_enabled") && !mesh.getSettingBoolean("anti_overhang_mesh"))
+        if (mesh.getSettingBoolean("conical_overhang_enabled"))
         {
             ConicalOverhang::apply(slicerList[meshIdx], mesh.getSettingInAngleRadians("conical_overhang_angle"), layer_thickness);
         }
     }
 
     Progress::messageProgressStage(Progress::Stage::PARTS, &timeKeeper);
-
-    if (storage.getSettingBoolean("carve_multiple_volumes"))
-    {
-        carveMultipleVolumes(slicerList, storage.getSettingBoolean("alternate_carve_order"));
-    }
+    //carveMultipleVolumes(storage.meshes);
     generateMultipleVolumesOverlap(slicerList);
 
-    storage.print_layer_count = 0;
-    for (unsigned int meshIdx = 0; meshIdx < slicerList.size(); meshIdx++)
-    {
-        Mesh& mesh = storage.meshgroup->meshes[meshIdx];
-        Slicer* slicer = slicerList[meshIdx];
-        if (!mesh.getSettingBoolean("anti_overhang_mesh") && !mesh.getSettingBoolean("infill_mesh"))
-        {
-            storage.print_layer_count = std::max(storage.print_layer_count, (unsigned int)slicer->layers.size());
-        }
-    }
-    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];
-
-        // always make a new SliceMeshStorage, so that they have the same ordering / indexing as meshgroup.meshes
         storage.meshes.emplace_back(&meshgroup->meshes[meshIdx], slicer->layers.size()); // new mesh in storage had settings from the Mesh
         SliceMeshStorage& meshStorage = storage.meshes.back();
-
-        if (mesh.getSettingBoolean("anti_overhang_mesh"))
-        {
-            for (unsigned int layer_nr = 0; layer_nr < slicer->layers.size(); layer_nr++)
-            {
-                SupportLayer& support_layer = storage.support.supportLayers[layer_nr];
-                SlicerLayer& slicer_layer = slicer->layers[layer_nr];
-                support_layer.anti_overhang = support_layer.anti_overhang.unionPolygons(slicer_layer.polygons);
-                meshStorage.layers[layer_nr].printZ =
-                    slicer_layer.z
-                    + getSettingInMicrons("layer_height_0")
-                    - initial_slice_z;
-            }
-            continue;
-        }
-        if (mesh.getSettingBoolean("support_mesh"))
-        {
-            for (unsigned int layer_nr = 0; layer_nr < slicer->layers.size(); layer_nr++)
-            {
-                SupportLayer& support_layer = storage.support.supportLayers[layer_nr];
-                SlicerLayer& slicer_layer = slicer->layers[layer_nr];
-                support_layer.support_mesh.add(slicer_layer.polygons);
-                meshStorage.layers[layer_nr].printZ =
-                    slicer_layer.z
-                    + getSettingInMicrons("layer_height_0")
-                    - initial_slice_z;
-            }
-            continue;
-        }
+        Mesh& mesh = storage.meshgroup->meshes[meshIdx];
 
         createLayerParts(meshStorage, slicer, mesh.getSettingBoolean("meshfix_union_all"), mesh.getSettingBoolean("meshfix_union_all_remove_holes"));
         delete slicerList[meshIdx];
@@ -189,7 +124,9 @@ bool FffPolygonGenerator::sliceModel(MeshGroup* meshgroup, TimeKeeper& timeKeepe
             {
                 ExtruderTrain* train = storage.meshgroup->getExtruderTrain(getSettingAsIndex("adhesion_extruder_nr"));
                 layer.printZ += 
-                    Raft::getTotalThickness(storage)
+                    train->getSettingInMicrons("raft_base_thickness") 
+                    + train->getSettingInMicrons("raft_interface_thickness") 
+                    + train->getSettingAsCount("raft_surface_layers") * train->getSettingInMicrons("raft_surface_thickness")
                     + train->getSettingInMicrons("raft_airgap")
                     - train->getSettingInMicrons("layer_0_z_overlap"); // shift all layers (except 0) down
                 if (layer_nr == 0)
@@ -216,7 +153,7 @@ void FffPolygonGenerator::slices2polygons(SliceDataStorage& storage, TimeKeeper&
     unsigned int slice_layer_count = 0;
     for (SliceMeshStorage& mesh : storage.meshes)
     {
-        if (!mesh.getSettingBoolean("infill_mesh") && !mesh.getSettingBoolean("anti_overhang_mesh"))
+        if (!mesh.getSettingBoolean("infill_mesh"))
         {
             slice_layer_count = std::max<unsigned int>(slice_layer_count, mesh.layers.size());
         }
@@ -245,93 +182,89 @@ void FffPolygonGenerator::slices2polygons(SliceDataStorage& storage, TimeKeeper&
     }
     for (unsigned int mesh_order_idx(0); mesh_order_idx < mesh_order.size(); ++mesh_order_idx)
     {
-        processBasicWallsSkinInfill(storage, mesh_order_idx, mesh_order, inset_skin_progress_estimate);
+        processBasicWallsSkinInfill(storage, mesh_order_idx, mesh_order, slice_layer_count, inset_skin_progress_estimate);
         Progress::messageProgress(Progress::Stage::INSET_SKIN, mesh_order_idx + 1, storage.meshes.size());
     }
 
-    for (unsigned int layer_nr = 0; layer_nr < slice_layer_count; layer_nr++)
-    {
-        SliceLayer* layer = nullptr;
-        for (unsigned int mesh_idx = 0; mesh_idx < storage.meshes.size(); mesh_idx++)
-        { // find first mesh which has this layer
-            SliceMeshStorage& mesh = storage.meshes[mesh_idx];
-            if (int(layer_nr) <= mesh.layer_nr_max_filled_layer)
-            {
-                layer = &mesh.layers[layer_nr];
-                break;
-            }
-        }
-        if (layer != nullptr)
+    unsigned int print_layer_count = 0;
+    if (CommandSocket::isInstantiated())
+    { // send layer info
+        for (unsigned int layer_nr = 0; layer_nr < slice_layer_count; layer_nr++)
         {
-            if (CommandSocket::isInstantiated())
-            { // send layer info
-                CommandSocket::getInstance()->sendOptimizedLayerInfo(layer_nr, layer->printZ, layer_nr == 0? getSettingInMicrons("layer_height_0") : getSettingInMicrons("layer_height"));
+            SliceLayer* layer = nullptr;
+            for (unsigned int mesh_idx = 0; mesh_idx < storage.meshes.size(); mesh_idx++)
+            { // find first mesh which has this layer
+                SliceMeshStorage& mesh = storage.meshes[mesh_idx];
+                if (int(layer_nr) <= mesh.layer_nr_max_filled_layer)
+                {
+                    layer = &mesh.layers[layer_nr];
+                    print_layer_count = layer_nr + 1;
+                    break;
+                }
+            }
+            if (layer != nullptr)
+            {
+                CommandSocket::getInstance()->sendLayerInfo(layer_nr, layer->printZ, layer_nr == 0? getSettingInMicrons("layer_height_0") : getSettingInMicrons("layer_height"));
             }
         }
     }
 
-    log("Layer count: %i\n", storage.print_layer_count);
+    log("Layer count: %i\n", print_layer_count);
 
     //layerparts2HTML(storage, "output/output.html");
 
-    Progress::messageProgressStage(Progress::Stage::SUPPORT, &time_keeper);
-
-    AreaSupport::generateSupportAreas(storage, storage.print_layer_count);
-
     // we need to remove empty layers after we have procesed the insets
     // processInsets might throw away parts if they have no wall at all (cause it doesn't fit)
     // brim depends on the first layer not being empty
-    // only remove empty layers if we haven't generate support, because then support was added underneath the model.
-    //   for some materials it's better to print on support than on the buildplate.
-    removeEmptyFirstLayers(storage, getSettingInMicrons("layer_height"), storage.print_layer_count); // changes storage.print_layer_count!
-    if (storage.print_layer_count == 0)
+    removeEmptyFirstLayers(storage, getSettingInMicrons("layer_height"), print_layer_count); // changes total_layers!
+    if (print_layer_count == 0)
     {
         log("Stopping process because there are no non-empty layers.\n");
         return;
     }
+
+    Progress::messageProgressStage(Progress::Stage::SUPPORT, &time_keeper);  
+
+    AreaSupport::generateSupportAreas(storage, print_layer_count);
     
     /*
     if (storage.support.generated)
     {
-        for (unsigned int layer_idx = 0; layer_idx < storage.print_layer_count; layer_idx++)
+        for (unsigned int layer_idx = 0; layer_idx < total_layers; layer_idx++)
         {
             Polygons& support = storage.support.supportLayers[layer_idx].supportAreas;
-            ExtruderTrain* infill_extr = storage.meshgroup->getExtruderTrain(storage.getSettingAsIndex("support_infill_extruder_nr"));
-            CommandSocket::sendPolygons(PrintFeatureType::Infill, support, 100); // infill_extr->getSettingInMicrons("support_line_width"));
+            if (CommandSocket::isInstantiated()) 
+            {
+                CommandSocket::getInstance()->sendPolygons(PrintFeatureType::Infill, layer_idx, support, 100); //getSettingInMicrons("support_line_width"));
+            }
         }
     }
     */
 
-    computePrintHeightStatistics(storage);
-
     // handle helpers
-    storage.primeTower.generatePaths(storage);
-    storage.primeTower.subtractFromSupport(storage);
-    
-    logDebug("Processing ooze shield\n");
-    processOozeShield(storage);
+    storage.primeTower.computePrimeTowerMax(storage);
+    storage.primeTower.generatePaths(storage, print_layer_count);
 
-    logDebug("Processing draft shield\n");
-    processDraftShield(storage);
+    processOozeShield(storage, print_layer_count);
+
+    processDraftShield(storage, print_layer_count);
 
-    logDebug("Processing platform adhesion\n");
     processPlatformAdhesion(storage);
     
     // meshes post processing
     for (SliceMeshStorage& mesh : storage.meshes)
     {
-        processDerivedWallsSkinInfill(mesh);
+        processDerivedWallsSkinInfill(mesh, print_layer_count);
     }
 }
 
-void FffPolygonGenerator::processBasicWallsSkinInfill(SliceDataStorage& storage, unsigned int mesh_order_idx, std::vector<unsigned int>& mesh_order, ProgressStageEstimator& inset_skin_progress_estimate)
+void FffPolygonGenerator::processBasicWallsSkinInfill(SliceDataStorage& storage, unsigned int mesh_order_idx, std::vector<unsigned int>& mesh_order, size_t total_layers, ProgressStageEstimator& inset_skin_progress_estimate)
 {
     unsigned int mesh_idx = mesh_order[mesh_order_idx];
     SliceMeshStorage& mesh = storage.meshes[mesh_idx];
-    size_t mesh_layer_count = mesh.layers.size();
     if (mesh.getSettingBoolean("infill_mesh"))
     {
-        processInfillMesh(storage, mesh_order_idx, mesh_order);
+        processInfillMesh(storage, mesh_order_idx, mesh_order, total_layers);
     }
     
     // TODO: make progress more accurate!!
@@ -341,32 +274,19 @@ void FffPolygonGenerator::processBasicWallsSkinInfill(SliceDataStorage& storage,
     
     inset_skin_progress_estimate.nextStage(mesh_inset_skin_progress_estimator); // the stage of this function call
     
-    ProgressEstimatorLinear* inset_estimator = new ProgressEstimatorLinear(mesh_layer_count);
+    ProgressEstimatorLinear* inset_estimator = new ProgressEstimatorLinear(total_layers);
     mesh_inset_skin_progress_estimator->nextStage(inset_estimator);
     
     
     // 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++)
+    for(unsigned int layer_number = 0; layer_number < total_layers; layer_number++)
     {
-        logDebug("Processing insets for layer %i of %i\n", layer_number, mesh_layer_count);
         processInsets(mesh, layer_number);
-#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);
     }
 
-    ProgressEstimatorLinear* skin_estimator = new ProgressEstimatorLinear(mesh_layer_count);
+    ProgressEstimatorLinear* skin_estimator = new ProgressEstimatorLinear(total_layers);
     mesh_inset_skin_progress_estimator->nextStage(skin_estimator);
 
     bool process_infill = mesh.getSettingInMicrons("infill_line_distance") > 0;
@@ -380,6 +300,8 @@ void FffPolygonGenerator::processBasicWallsSkinInfill(SliceDataStorage& storage,
             {
                 AABB3D aabb = storage.meshgroup->meshes[mesh_idx].getAABB();
                 AABB3D other_aabb = storage.meshgroup->meshes[other_mesh_idx].getAABB();
+                aabb.expandXY(mesh.getSettingInMicrons("xy_offset"));
+                other_aabb.expandXY(other_mesh.getSettingInMicrons("xy_offset"));
                 if (aabb.hit(other_aabb))
                 {
                     process_infill = true;
@@ -394,36 +316,18 @@ void FffPolygonGenerator::processBasicWallsSkinInfill(SliceDataStorage& storage,
     {
         mesh_max_bottom_layer_count = std::max(mesh_max_bottom_layer_count, mesh.getSettingAsCount("bottom_layers"));
     }
-
-    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)
+    for(unsigned int layer_number = 0; layer_number < total_layers; layer_number++)
     {
-
-#pragma omp for schedule(dynamic)
-        for (unsigned int layer_number = 0; layer_number < mesh.layers.size(); layer_number++)
+        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.
         {
-            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++;
-        }
+            processSkinsAndInfill(mesh, layer_number, process_infill);
         }
+        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)
+void FffPolygonGenerator::processInfillMesh(SliceDataStorage& storage, unsigned int mesh_order_idx, std::vector<unsigned int>& mesh_order, size_t total_layers)
 {
     unsigned int mesh_idx = mesh_order[mesh_order_idx];
     SliceMeshStorage& mesh = storage.meshes[mesh_idx];
@@ -494,19 +398,13 @@ void FffPolygonGenerator::processInfillMesh(SliceDataStorage& storage, unsigned
     
 }
 
-void FffPolygonGenerator::processDerivedWallsSkinInfill(SliceMeshStorage& mesh)
+void FffPolygonGenerator::processDerivedWallsSkinInfill(SliceMeshStorage& mesh, size_t total_layers)
 {
     // create gradual infill areas
     SkinInfillAreaComputation::generateGradualInfill(mesh, mesh.getSettingInMicrons("gradual_infill_step_height"), mesh.getSettingAsCount("gradual_infill_steps"));
 
-    //SubDivCube Pre-compute Octree
-    if (mesh.getSettingAsFillMethod("infill_pattern") == EFillMethod::CUBICSUBDIV)
-    {
-        SubDivCube::precomputeOctree(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.
+    unsigned int combined_infill_layers = mesh.getSettingInMicrons("infill_sparse_thickness") / std::max(getSettingInMicrons("layer_height"), 1); //How many infill layers to combine to obtain the requested sparse thickness.
     combineInfillLayers(mesh,combined_infill_layers);
 
     // fuzzy skin
@@ -516,63 +414,51 @@ void FffPolygonGenerator::processDerivedWallsSkinInfill(SliceMeshStorage& 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];
     if (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") != ESurfaceMode::SURFACE)
     {
         int inset_count = mesh.getSettingAsCount("wall_line_count");
-        if (mesh.getSettingBoolean("magic_spiralize") && static_cast<int>(layer_nr) < mesh.getSettingAsCount("bottom_layers") && ((layer_nr % 2) + 2) % 2 == 1)//Add extra insets every 2 layers when spiralizing, this makes bottoms of cups watertight.
+        if (mesh.getSettingBoolean("magic_spiralize") && static_cast<int>(layer_nr) < mesh.getSettingAsCount("bottom_layers") && layer_nr % 2 == 1)//Add extra insets every 2 layers when spiralizing, this makes bottoms of cups watertight.
             inset_count += 5;
         int line_width_x = mesh.getSettingInMicrons("wall_line_width_x");
         int line_width_0 = mesh.getSettingInMicrons("wall_line_width_0");
         if (mesh.getSettingBoolean("alternate_extra_perimeter"))
-        {
-            inset_count += ((layer_nr % 2) + 2) % 2;
-        }
+            inset_count += layer_nr % 2; 
         bool recompute_outline_based_on_outer_wall = mesh.getSettingBoolean("support_enable");
         WallsComputation walls_computation(mesh.getSettingInMicrons("wall_0_inset"), line_width_0, line_width_x, inset_count, recompute_outline_based_on_outer_wall);
         walls_computation.generateInsets(layer);
     }
+    if (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") != ESurfaceMode::NORMAL)
+    {
+        for (PolygonRef polyline : layer->openPolyLines)
+        {
+            Polygons segments;
+            for (unsigned int point_idx = 1; point_idx < polyline.size(); point_idx++)
+            {
+                PolygonRef segment = segments.newPoly();
+                segment.add(polyline[point_idx-1]);
+                segment.add(polyline[point_idx]);
+            }
+        }
+    }
 }
 
 void FffPolygonGenerator::removeEmptyFirstLayers(SliceDataStorage& storage, const int layer_height, unsigned int& total_layers)
-{
+{ 
     int n_empty_first_layers = 0;
     for (unsigned int layer_idx = 0; layer_idx < total_layers; layer_idx++)
     { 
         bool layer_is_empty = true;
-        if (storage.support.generated && layer_idx < storage.support.supportLayers.size())
-        {
-            SupportLayer& support_layer = storage.support.supportLayers[layer_idx];
-            if (support_layer.supportAreas.size() > 0 || support_layer.skin.size() > 0)
-            {
-                layer_is_empty = false;
-                break;
-            }
-        }
         for (SliceMeshStorage& mesh : storage.meshes)
         {
             SliceLayer& layer = mesh.layers[layer_idx];
-            if (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") != ESurfaceMode::NORMAL && layer.openPolyLines.size() > 0)
+            if (layer.parts.size() > 0 || (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) 
@@ -595,35 +481,22 @@ void FffPolygonGenerator::removeEmptyFirstLayers(SliceDataStorage& storage, cons
             {
                 layer.printZ -= n_empty_first_layers * layer_height;
             }
-            mesh.layer_nr_max_filled_layer -= n_empty_first_layers;
         }
         total_layers -= n_empty_first_layers;
-        storage.support.layer_nr_max_filled_layer -= n_empty_first_layers;
-        std::vector<SupportLayer>& support_layers = storage.support.supportLayers;
-        support_layers.erase(support_layers.begin(), support_layers.begin() + n_empty_first_layers);
     }
 }
-
-/*
- * 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)
+  
+void FffPolygonGenerator::processSkinsAndInfill(SliceMeshStorage& mesh, unsigned int layer_nr, bool process_infill) 
 {
     if (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") == ESurfaceMode::SURFACE) 
     { 
         return;
     }
-
-    const int wall_line_count = mesh.getSettingAsCount("wall_line_count");
-    const int innermost_wall_line_width = (wall_line_count == 1) ? mesh.getSettingInMicrons("wall_line_width_0") : mesh.getSettingInMicrons("wall_line_width_x");
-    generateSkins(layer_nr, mesh, mesh.getSettingAsCount("bottom_layers"), mesh.getSettingAsCount("top_layers"), wall_line_count, innermost_wall_line_width, mesh.getSettingAsCount("skin_outline_count"), mesh.getSettingBoolean("skin_no_small_gaps_heuristic"));
+    
+    int wall_line_count = mesh.getSettingAsCount("wall_line_count");
+    int skin_extrusion_width = mesh.getSettingInMicrons("skin_line_width");
+    int innermost_wall_extrusion_width = (wall_line_count == 1)? mesh.getSettingInMicrons("wall_line_width_0") : mesh.getSettingInMicrons("wall_line_width_x");
+    generateSkins(layer_nr, mesh, skin_extrusion_width, mesh.getSettingAsCount("bottom_layers"), mesh.getSettingAsCount("top_layers"), wall_line_count, innermost_wall_extrusion_width, mesh.getSettingAsCount("skin_outline_count"), mesh.getSettingBoolean("skin_no_small_gaps_heuristic"));
 
     if (process_infill)
     { // process infill when infill density > 0
@@ -632,116 +505,64 @@ void FffPolygonGenerator::processSkinsAndInfill(SliceMeshStorage& mesh, unsigned
         bool infill_is_dense = mesh.getSettingInMicrons("infill_line_distance") < mesh.getSettingInMicrons("infill_line_width") + 10;
         if (!infill_is_dense && mesh.getSettingAsFillMethod("infill_pattern") != EFillMethod::CONCENTRIC)
         {
-            infill_skin_overlap = innermost_wall_line_width / 2;
+            infill_skin_overlap = skin_extrusion_width / 2;
         }
-        generateInfill(layer_nr, mesh, innermost_wall_line_width, infill_skin_overlap, wall_line_count);
+        generateInfill(layer_nr, mesh, innermost_wall_extrusion_width, infill_skin_overlap, wall_line_count);
     }
 }
 
-void FffPolygonGenerator::computePrintHeightStatistics(SliceDataStorage& storage)
-{
-    int extruder_count = storage.meshgroup->getExtruderCount();
-
-    std::vector<int>& max_print_height_per_extruder = storage.max_print_height_per_extruder;
-    assert(max_print_height_per_extruder.size() == 0 && "storage.max_print_height_per_extruder shouldn't have been initialized yet!");
-    max_print_height_per_extruder.resize(extruder_count, -1); //Initialize all as -1.
-    { // compute max_object_height_per_extruder
-        //Height of the meshes themselves.
-        for (SliceMeshStorage& mesh : storage.meshes)
-        {
-            if (mesh.getSettingBoolean("anti_overhang_mesh") || mesh.getSettingBoolean("support_mesh"))
-            {
-                continue; //Special type of mesh that doesn't get printed.
-            }
-            const unsigned int extr_nr = mesh.getSettingAsIndex("extruder_nr");
-            max_print_height_per_extruder[extr_nr] = std::max(max_print_height_per_extruder[extr_nr], mesh.layer_nr_max_filled_layer);
-        }
-
-        //Height of where the support reaches.
-        const unsigned int support_infill_extruder_nr = storage.getSettingAsIndex("support_infill_extruder_nr"); // TODO: support extruder should be configurable per object
-        max_print_height_per_extruder[support_infill_extruder_nr] =
-            std::max(max_print_height_per_extruder[support_infill_extruder_nr],
-                     storage.support.layer_nr_max_filled_layer);
-        const unsigned int support_skin_extruder_nr = storage.getSettingAsIndex("support_interface_extruder_nr"); // TODO: support skin extruder should be configurable per object
-        max_print_height_per_extruder[support_skin_extruder_nr] =
-            std::max(max_print_height_per_extruder[support_skin_extruder_nr],
-                     storage.support.layer_nr_max_filled_layer);
-
-        //Height of where the platform adhesion reaches.
-        if (storage.getSettingAsPlatformAdhesion("adhesion_type") != EPlatformAdhesion::NONE)
-        {
-            const unsigned int adhesion_extruder_nr = storage.getSettingAsIndex("adhesion_extruder_nr");
-            max_print_height_per_extruder[adhesion_extruder_nr] =
-                std::max(0, max_print_height_per_extruder[adhesion_extruder_nr]);
-        }
-    }
-
-    storage.max_print_height_order = order(max_print_height_per_extruder);
-    if (extruder_count >= 2)
-    {
-        int second_highest_extruder = storage.max_print_height_order[extruder_count - 2];
-        storage.max_print_height_second_to_last_extruder = max_print_height_per_extruder[second_highest_extruder];
-    }
-    else
-    {
-        storage.max_print_height_second_to_last_extruder = -1;
-    }
-}
-
-
-void FffPolygonGenerator::processOozeShield(SliceDataStorage& storage)
+void FffPolygonGenerator::processOozeShield(SliceDataStorage& storage, unsigned int total_layers)
 {
     if (!getSettingBoolean("ooze_shield_enabled"))
     {
         return;
     }
-
-    const int ooze_shield_dist = getSettingInMicrons("ooze_shield_dist");
-
-    for (int layer_nr = 0; layer_nr <= storage.max_print_height_second_to_last_extruder; layer_nr++)
+    
+    int ooze_shield_dist = getSettingInMicrons("ooze_shield_dist");
+    
+    for(unsigned int layer_nr=0; layer_nr<total_layers; layer_nr++)
     {
-        storage.oozeShield.push_back(storage.getLayerOutlines(layer_nr, true).offset(ooze_shield_dist, ClipperLib::jtRound));
+        storage.oozeShield.push_back(storage.getLayerOutlines(layer_nr, true).offset(ooze_shield_dist));
     }
-
-    double angle = getSettingInAngleDegrees("ooze_shield_angle");
-    if (angle <= 89)
+    
+    int largest_printed_radius = MM2INT(1.0); // TODO: make var a parameter, and perhaps even a setting?
+    for(unsigned int layer_nr=0; layer_nr<total_layers; layer_nr++)
     {
-        int allowed_angle_offset = tan(getSettingInAngleRadians("ooze_shield_angle")) * getSettingInMicrons("layer_height"); // Allow for a 60deg angle in the oozeShield.
-        for (int layer_nr = 1; layer_nr <= storage.max_print_height_second_to_last_extruder; layer_nr++)
-        {
-            storage.oozeShield[layer_nr] = storage.oozeShield[layer_nr].unionPolygons(storage.oozeShield[layer_nr - 1].offset(-allowed_angle_offset));
-        }
-        for (int layer_nr = storage.max_print_height_second_to_last_extruder; layer_nr > 0; layer_nr--)
-        {
-            storage.oozeShield[layer_nr - 1] = storage.oozeShield[layer_nr - 1].unionPolygons(storage.oozeShield[layer_nr].offset(-allowed_angle_offset));
-        }
+        storage.oozeShield[layer_nr] = storage.oozeShield[layer_nr].offset(-largest_printed_radius).offset(largest_printed_radius); 
     }
-
-    const float largest_printed_area = 1.0; // TODO: make var a parameter, and perhaps even a setting?
-    for (int layer_nr = 0; layer_nr <= storage.max_print_height_second_to_last_extruder; layer_nr++)
+    int allowed_angle_offset = tan(getSettingInAngleRadians("ooze_shield_angle")) * getSettingInMicrons("layer_height");//Allow for a 60deg angle in the oozeShield.
+    for(unsigned int layer_nr=1; layer_nr<total_layers; layer_nr++)
     {
-        storage.oozeShield[layer_nr].removeSmallAreas(largest_printed_area);
+        storage.oozeShield[layer_nr] = storage.oozeShield[layer_nr].unionPolygons(storage.oozeShield[layer_nr-1].offset(-allowed_angle_offset));
+    }
+    for(unsigned int layer_nr=total_layers-1; layer_nr>0; layer_nr--)
+    {
+        storage.oozeShield[layer_nr-1] = storage.oozeShield[layer_nr-1].unionPolygons(storage.oozeShield[layer_nr].offset(-allowed_angle_offset));
     }
 }
 
-void FffPolygonGenerator::processDraftShield(SliceDataStorage& storage)
+void FffPolygonGenerator::processDraftShield(SliceDataStorage& storage, unsigned int total_layers)
 {
-    const unsigned int draft_shield_layers = getDraftShieldLayerCount(storage.print_layer_count);
-    if (draft_shield_layers <= 0)
+    int draft_shield_height = getSettingInMicrons("draft_shield_height");
+    int draft_shield_dist = getSettingInMicrons("draft_shield_dist");
+    int layer_height_0 = getSettingInMicrons("layer_height_0");
+    int layer_height = getSettingInMicrons("layer_height");
+    
+    if (draft_shield_height < layer_height_0)
     {
         return;
     }
-    const int layer_height = getSettingInMicrons("layer_height");
-
-    const unsigned int layer_skip = 500 / layer_height + 1;
-
+    
+    unsigned int max_screen_layer = (draft_shield_height - layer_height_0) / layer_height + 1;
+    
+    int layer_skip = 500 / layer_height + 1;
+    
     Polygons& draft_shield = storage.draft_protection_shield;
-    for (unsigned int layer_nr = 0; layer_nr < storage.print_layer_count && layer_nr < draft_shield_layers; layer_nr += layer_skip)
+    for (unsigned int layer_nr = 0; layer_nr < total_layers && layer_nr < max_screen_layer; layer_nr += layer_skip)
     {
         draft_shield = draft_shield.unionPolygons(storage.getLayerOutlines(layer_nr, true));
     }
-
-    const int draft_shield_dist = getSettingInMicrons("draft_shield_dist");
+    
     storage.draft_protection_shield = draft_shield.approxConvexHull(draft_shield_dist);
 }
 
@@ -751,20 +572,22 @@ void FffPolygonGenerator::processPlatformAdhesion(SliceDataStorage& storage)
     switch(getSettingAsPlatformAdhesion("adhesion_type"))
     {
     case EPlatformAdhesion::SKIRT:
-        {
-            constexpr bool outside_polygons_only = true;
-            SkirtBrim::generate(storage, train->getSettingInMicrons("skirt_gap"), train->getSettingAsCount("skirt_line_count"), outside_polygons_only);
+        if (train->getSettingInMicrons("draft_shield_height") == 0)
+        { // draft screen replaces skirt
+            generateSkirt(storage, train->getSettingInMicrons("skirt_gap"), train->getSettingAsCount("skirt_line_count"), train->getSettingInMicrons("skirt_minimal_length"));
         }
         break;
     case EPlatformAdhesion::BRIM:
-        SkirtBrim::generate(storage, 0, train->getSettingAsCount("brim_line_count"), train->getSettingBoolean("brim_outside_only"));
+        generateSkirt(storage, 0, train->getSettingAsCount("brim_line_count"), train->getSettingInMicrons("skirt_minimal_length"));
         break;
     case EPlatformAdhesion::RAFT:
-        Raft::generate(storage, train->getSettingInMicrons("raft_margin"));
-        break;
-    case EPlatformAdhesion::NONE:
+        generateRaft(storage, train->getSettingInMicrons("raft_margin"));
         break;
     }
+    
+    Polygons skirt_sent = storage.skirt[0];
+    for (int extruder = 1; extruder < storage.meshgroup->getExtruderCount(); extruder++)
+        skirt_sent.add(storage.skirt[extruder]);
 }
 
 

src/FffPolygonGenerator.h

@@ -46,19 +46,7 @@ public:
     bool generateAreas(SliceDataStorage& storage, MeshGroup* object, TimeKeeper& timeKeeper);
   
 private:
-    /*!
-     * \brief Helper function to get the actual height of the draft shield.
-     *
-     * The draft shield is the height of the print if we've set the draft shield
-     * limitation to FULL. Otherwise the height is set to the height limit
-     * setting. If the draft shield is disabled, the height is always 0.
-     *
-     * \param total_layers The total number of layers in the print (the height
-     * of the draft shield if the limit is FULL.
-     * \return The actual height of the draft shield.
-     */
-    unsigned int getDraftShieldLayerCount(unsigned int total_layers) const;
-
+    
     /*!
      * Slice the \p object and store the outlines in the \p storage.
      * 
@@ -84,9 +72,10 @@ private:
      * \param storage Input and Output parameter: fetches the outline information (see SliceLayerPart::outline) and generates the other reachable field of the \p storage
      * \param mesh_order_idx The index of the mesh_idx in \p mesh_order to process in the vector of meshes in \p storage
      * \param mesh_order The order in which the meshes are processed (used for infill meshes)
+     * \param total_layers The total number of layers over all objects
      * \param inset_skin_progress_estimate The progress stage estimate calculator
      */
-    void processBasicWallsSkinInfill(SliceDataStorage& storage, unsigned int mesh_order_idx, std::vector<unsigned int>& mesh_order, ProgressStageEstimator& inset_skin_progress_estimate);
+    void processBasicWallsSkinInfill(SliceDataStorage& storage, unsigned int mesh_order_idx, std::vector<unsigned int>& mesh_order, size_t total_layers, ProgressStageEstimator& inset_skin_progress_estimate);
     
     /*!
      * Process the mesh to be an infill mesh: limit all outlines to within the infill of normal meshes and subtract their volume from the infill of those meshes
@@ -94,16 +83,18 @@ private:
      * \param storage Input and Output parameter: fetches the outline information (see SliceLayerPart::outline) and generates the other reachable field of the \p storage
      * \param mesh_order_idx The index of the mesh_idx in \p mesh_order to process in the vector of meshes in \p storage
      * \param mesh_order The order in which the meshes are processed
+     * \param total_layers The total number of layers over all objects
      */
-    void processInfillMesh(SliceDataStorage& storage, unsigned int mesh_order_idx, std::vector<unsigned int>& mesh_order);
+    void processInfillMesh(SliceDataStorage& storage, unsigned int mesh_order_idx, std::vector<unsigned int>& mesh_order, size_t total_layers);
     
     /*!
      * Process features which are derived from the basic walls, skin, and infill:
      * fuzzy skin, infill combine
      * 
      * \param mesh Input and Output parameter: fetches the outline information (see SliceLayerPart::outline) and generates the other reachable field of the \p storage
+     * \param total_layers The total number of layers over all objects
      */
-    void processDerivedWallsSkinInfill(SliceMeshStorage& mesh);
+    void processDerivedWallsSkinInfill(SliceMeshStorage& mesh, size_t total_layers);
     
     /*!
      * Remove all bottom layers which are empty.
@@ -115,14 +106,7 @@ private:
      * \param total_layers The total number of layers
      */
     void removeEmptyFirstLayers(SliceDataStorage& storage, const int layer_height, unsigned int& total_layers);
-
-    /*!
-     * Set \ref SliceDataStorage::max_print_height_per_extruder and \ref SliceDataStorage::max_print_height_order and \ref SliceDataStorage::max_print_height_second_to_last_extruder
-     * 
-     * \param[in,out] storage Where to retrieve mesh and support etc settings from and where the print height statistics are saved.
-     */
-    void computePrintHeightStatistics(SliceDataStorage& storage);
-
+    
     /*!
      * Generate the inset polygons which form the walls.
      * \param mesh Input and Output parameter: fetches the outline information (see SliceLayerPart::outline) and generates the other reachable field of the \p storage
@@ -133,8 +117,9 @@ private:
     /*!
      * Generate the outline of the ooze shield.
      * \param storage Input and Output parameter: fetches the outline information (see SliceLayerPart::outline) and generates the other reachable field of the \p storage
+     * \param total_layers The total number of layers 
      */
-    void processOozeShield(SliceDataStorage& storage);
+    void processOozeShield(SliceDataStorage& storage, unsigned int total_layers);
     
     /*!
      * Generate the skin areas.
@@ -148,15 +133,17 @@ private:
      * Generate the polygons where the draft screen should be.
      * 
      * \param storage Input and Output parameter: fetches the outline information (see SliceLayerPart::outline) and generates the other reachable field of the \p storage
+     * \param total_layers The total number of layers 
      */
-    void processDraftShield(SliceDataStorage& storage);
-
+    void processDraftShield(SliceDataStorage& storage, unsigned int total_layers);
     /*!
      * Generate the skirt/brim/raft areas/insets.
      * \param storage Input and Output parameter: fetches the outline information (see SliceLayerPart::outline) and generates the other reachable field of the \p storage
      */
     void processPlatformAdhesion(SliceDataStorage& storage);
-
+    
+    
+    
     /*!
      * Make the outer wall 'fuzzy'
      * 
@@ -167,8 +154,10 @@ private:
      * \param[in,out] mesh where the outer wall is retrieved and stored in.
      */
     void processFuzzyWalls(SliceMeshStorage& mesh);
+    
+    
 
-
+    
 };
 }//namespace cura
 #endif // FFF_AREA_GENERATOR_H

src/FffProcessor.cpp

@@ -45,6 +45,29 @@ std::string FffProcessor::getAllSettingsString(MeshGroup& meshgroup, bool first_
     return sstream.str();
 }
 
+bool FffProcessor::processFiles(const std::vector< std::string >& files)
+{
+    time_keeper.restart();
+    MeshGroup* meshgroup = new MeshGroup(this);
+    
+    for(std::string filename : files)
+    {
+        log("Loading %s from disk...\n", filename.c_str());
+
+        FMatrix3x3 matrix;
+        if (!loadMeshIntoMeshGroup(meshgroup, filename.c_str(), matrix))
+        {
+            logError("Failed to load model: %s\n", filename.c_str());
+            return false;
+        }
+    }
+    
+    meshgroup->finalize();
+
+    log("Loaded from disk in %5.3fs\n", time_keeper.restart());
+    return processMeshGroup(meshgroup);
+}
+
 bool FffProcessor::processMeshGroup(MeshGroup* meshgroup)
 {
     if (SHOW_ALL_SETTINGS) { logWarning(getAllSettingsString(*meshgroup, meshgroup_number == 0).c_str()); }
@@ -60,7 +83,7 @@ bool FffProcessor::processMeshGroup(MeshGroup* meshgroup)
     bool empty = true;
     for (Mesh& mesh : meshgroup->meshes)
     {
-        if (!mesh.getSettingBoolean("infill_mesh") && !mesh.getSettingBoolean("anti_overhang_mesh"))
+        if (!mesh.getSettingBoolean("infill_mesh"))
         {
             empty = false;
         }
@@ -103,7 +126,7 @@ bool FffProcessor::processMeshGroup(MeshGroup* meshgroup)
     if (CommandSocket::isInstantiated())
     {
         CommandSocket::getInstance()->flushGcode();
-        CommandSocket::getInstance()->sendOptimizedLayerData();
+        CommandSocket::getInstance()->sendLayerData();
     }
     log("Total time elapsed %5.2fs.\n", time_keeper_total.restart());
 

src/FffProcessor.h

@@ -151,6 +151,13 @@ public:
         gcode_writer.finalize();
     }
 
+    /*!
+     * Process all files into one meshgroup
+     * 
+     * \warning Unused!
+     */
+    bool processFiles(const std::vector<std::string> &files);
+
     /*!
      * Generate gcode for a given \p meshgroup
      * The primary function of this class.

src/GCodePathConfig.cpp

@@ -6,74 +6,105 @@
 namespace cura 
 {
 
-GCodePathConfig::GCodePathConfig(const GCodePathConfig& other)
-: type(other.type)
-, speed_derivatives(other.speed_derivatives)
-, line_width(other.line_width)
-, layer_thickness(other.layer_thickness)
-, flow(other.flow)
-, extrusion_mm3_per_mm(other.extrusion_mm3_per_mm)
+GCodePathConfig::BasicConfig::BasicConfig()
+: speed(0)
+, acceleration(0)
+, jerk(0)
+, line_width(0)
+, flow(100)
 {
 }
 
 
-
-GCodePathConfig::GCodePathConfig(PrintFeatureType type, int line_width, int layer_height, double flow, GCodePathConfig::SpeedDerivatives speed_derivatives)
-: type(type)
-, speed_derivatives(speed_derivatives)
+GCodePathConfig::BasicConfig::BasicConfig(double speed, double acceleration, double jerk, int line_width, double flow)
+: speed(speed)
+, acceleration(acceleration)
+, jerk(jerk)
 , line_width(line_width)
-, layer_thickness(layer_height)
 , flow(flow)
-, extrusion_mm3_per_mm(calculateExtrusion())
 {
 }
 
-void GCodePathConfig::smoothSpeed(GCodePathConfig::SpeedDerivatives first_layer_config, int layer_nr, int max_speed_layer_nr) 
+void GCodePathConfig::BasicConfig::set(double speed, double acceleration, double jerk, int line_width, double flow)
 {
-    double max_speed_layer = max_speed_layer_nr;
-    speed_derivatives.speed = (speed_derivatives.speed * layer_nr) / max_speed_layer + (first_layer_config.speed * (max_speed_layer - layer_nr) / max_speed_layer);
-    speed_derivatives.acceleration = (speed_derivatives.acceleration * layer_nr) / max_speed_layer + (first_layer_config.acceleration * (max_speed_layer - layer_nr) / max_speed_layer);
-    speed_derivatives.jerk = (speed_derivatives.jerk * layer_nr) / max_speed_layer + (first_layer_config.jerk * (max_speed_layer - layer_nr) / max_speed_layer);
+    this->speed = speed;
+    this->acceleration = acceleration;
+    this->jerk = jerk;
+    this->line_width = line_width;
+    this->flow = flow;
 }
 
-double GCodePathConfig::getExtrusionMM3perMM() const
+
+GCodePathConfig::GCodePathConfig(PrintFeatureType type)
+: extrusion_mm3_per_mm(0.0)
+, type(type)
+{
+}
+
+void GCodePathConfig::init(double speed, double acceleration, double jerk, int line_width, double flow)
+{
+    iconic_config.set(speed, acceleration, jerk, line_width, flow);
+    current_config = iconic_config;
+}
+
+void GCodePathConfig::setLayerHeight(int layer_height)
+{
+    this->layer_thickness = layer_height;
+    calculateExtrusion();
+}
+
+void GCodePathConfig::smoothSpeed(GCodePathConfig::BasicConfig first_layer_config, int layer_nr, double max_speed_layer) 
+{
+    current_config.speed = (iconic_config.speed * layer_nr) / max_speed_layer + (first_layer_config.speed * (max_speed_layer - layer_nr) / max_speed_layer);
+    current_config.acceleration = (iconic_config.acceleration * layer_nr) / max_speed_layer + (first_layer_config.acceleration * (max_speed_layer - layer_nr) / max_speed_layer);
+    current_config.jerk = (iconic_config.jerk * layer_nr) / max_speed_layer + (first_layer_config.jerk * (max_speed_layer - layer_nr) / max_speed_layer);
+}
+
+void GCodePathConfig::setSpeedIconic()
+{
+    current_config.speed = iconic_config.speed;
+    current_config.acceleration = iconic_config.acceleration;
+    current_config.jerk = iconic_config.jerk;
+}
+
+double GCodePathConfig::getExtrusionMM3perMM()
 {
     return extrusion_mm3_per_mm;
 }
 
-double GCodePathConfig::getSpeed() const
+double GCodePathConfig::getSpeed()
 {
-    return speed_derivatives.speed;
+    return current_config.speed;
 }
 
-double GCodePathConfig::getAcceleration() const
+double GCodePathConfig::getAcceleration()
 {
-    return speed_derivatives.acceleration;
+    return current_config.acceleration;
 }
 
-double GCodePathConfig::getJerk() const
+double GCodePathConfig::getJerk()
 {
-    return speed_derivatives.jerk;
+    return current_config.jerk;
 }
 
-int GCodePathConfig::getLineWidth() const
+int GCodePathConfig::getLineWidth()
 {
-    return line_width;
+    return current_config.line_width;
 }
 
-bool GCodePathConfig::isTravelPath() const
+bool GCodePathConfig::isTravelPath()
 {
-    return line_width == 0;
+    return current_config.line_width == 0;
 }
 
-double GCodePathConfig::getFlowPercentage() const
+double GCodePathConfig::getFlowPercentage()
 {
-    return flow;
+    return current_config.flow;
 }
 
-double GCodePathConfig::calculateExtrusion() const
+void GCodePathConfig::calculateExtrusion()
 {
-    return INT2MM(line_width) * INT2MM(layer_thickness) * double(flow) / 100.0;
+    extrusion_mm3_per_mm = INT2MM(current_config.line_width) * INT2MM(layer_thickness) * double(current_config.flow) / 100.0;
 }
 
 

src/GCodePathConfig.h

@@ -13,73 +13,97 @@ namespace cura
  */
 class GCodePathConfig
 {
-    friend class LayerPlanTest;
+    friend class GCodePlannerTest;
 public:
     /*!
-     * A simple wrapper class for all derivatives of position which are used when printing a line
+     * The path config settings which may change from layer to layer
      */
-    struct SpeedDerivatives
+    struct BasicConfig
     {
         double speed; //!< movement speed (mm/s)
         double acceleration; //!< acceleration of head movement (mm/s^2)
-        double jerk; //!< jerk of the head movement (around stand still) as instantaneous speed change (mm/s)
+        double jerk; //!< jerk of the head movement (around stand still) (mm/s^3)
+        int line_width; //!< width of the line extruded
+        double flow; //!< extrusion flow modifier in %
+        BasicConfig(); //!< basic contructor initializing with inaccurate values
+        BasicConfig(double speed, double acceleration, double jerk, int line_width, double flow); //!< basic contructor initializing all values
+        void set(double speed, double acceleration, double jerk, int line_width, double flow); //!< Set all config values
     };
-    const PrintFeatureType type; //!< name of the feature type
 private:
-    SpeedDerivatives speed_derivatives; //!< The speed settings (and acceleration and jerk) of the extruded line. May be changed when smoothSpeed is called.
-    const int line_width; //!< width of the line extruded
-    const int layer_thickness; //!< current layer height in micron
-    const double flow; //!< extrusion flow modifier in %
-    const double extrusion_mm3_per_mm;//!< current mm^3 filament moved per mm line traversed
+    BasicConfig iconic_config; //!< The basic path configuration iconic to this print feature type
+    BasicConfig current_config; //!< The current path configuration for the current layer
+    int layer_thickness; //!< current layer height in micron
+    double extrusion_mm3_per_mm;//!< current mm^3 filament moved per mm line traversed
 public:
-    GCodePathConfig(PrintFeatureType type, int line_width, int layer_height, double flow, SpeedDerivatives speed_derivatives); // , SpeedDerivatives slowdown_speed_derivatives, int layer_nr, int max_speed_layer_nr);
+    const PrintFeatureType type; //!< name of the feature type
 
     /*!
-     * copy constructor
+     * Basic constructor.
      */
-    GCodePathConfig(const GCodePathConfig& other);
+    GCodePathConfig(PrintFeatureType type);
+    
+    /*!
+     * Initialize some of the member variables.
+     * 
+     * \warning GCodePathConfig::setLayerHeight still has to be called before this object can be used.
+     * 
+     * \param speed The regular speed with which to print this feature
+     * \param line_width The line width for this feature
+     * \param flow The flow modifier to apply to the extruded filament when printing this feature
+     */
+    void init(double speed, double acceleration, double jerk, int line_width, double flow);
+
+    /*!
+     * Set the layer height and (re)compute the extrusion_per_mm
+     */
+    void setLayerHeight(int layer_height);
 
     /*!
      * Set the speed to somewhere between the speed of @p first_layer_config and the iconic speed.
      * 
      * \warning This functions should not be called with @p layer_nr > @p max_speed_layer !
      * 
-     * \warning Calling this function twice will smooth the speed more toward \p first_layer_config
-     * 
      * \param first_layer_config The speed settings at layer zero
      * \param layer_nr The layer number 
      * \param max_speed_layer The layer number for which the speed_iconic should be used.
      */
-    void smoothSpeed(SpeedDerivatives first_layer_config, int layer_nr, int max_speed_layer);
+    void smoothSpeed(BasicConfig first_layer_config, int layer_nr, double max_speed_layer);
+
+    /*!
+     * Set the speed config to the iconic speed config, i.e. the normal speed of the feature type for which this is a config.
+     * 
+     * Does the same for acceleration and jerk.
+     */
+    void setSpeedIconic();
 
     /*!
      * Can only be called after the layer height has been set (which is done while writing the gcode!)
      */
-    double getExtrusionMM3perMM() const;
+    double getExtrusionMM3perMM();
 
     /*!
      * Get the movement speed in mm/s
      */
-    double getSpeed() const;
+    double getSpeed();
 
     /*!
      * Get the current acceleration of this config
      */
-    double getAcceleration() const;
+    double getAcceleration();
 
     /*!
      * Get the current jerk of this config
      */
-    double getJerk() const;
+    double getJerk();
 
-    int getLineWidth() const;
+    int getLineWidth();
 
-    bool isTravelPath() const;
+    bool isTravelPath();
 
-    double getFlowPercentage() const;
+    double getFlowPercentage();
 
 private:
-    double calculateExtrusion() const;
+    void calculateExtrusion();
 };
 
 

src/LayerPlanBuffer.cpp

@@ -13,11 +13,11 @@ void LayerPlanBuffer::flush()
 {
     if (buffer.size() > 0)
     {
-        insertTempCommands(); // insert preheat commands of the very last layer
+        insertPreheatCommands(); // insert preheat commands of the very last layer
     }
     while (!buffer.empty())
     {
-        buffer.front()->writeGCode(gcode);
+        buffer.front().writeGCode(gcode);
         if (CommandSocket::isInstantiated())
         {
             CommandSocket::getInstance()->flushGcode();
@@ -38,51 +38,41 @@ void LayerPlanBuffer::insertPreheatCommand(ExtruderPlan& extruder_plan_before, d
         if (acc_time > time_after_extruder_plan_start)
         {
             const double time_before_path_end = acc_time - time_after_extruder_plan_start;
-            bool wait = false;
-            extruder_plan_before.insertCommand(path_idx, extruder, temp, wait, time_this_path - time_before_path_end);
+            extruder_plan_before.insertCommand(path_idx, extruder, temp, false, time_this_path - time_before_path_end);
             return;
         }
     }
-    bool wait = false;
-    unsigned int path_idx = 0;
-    extruder_plan_before.insertCommand(path_idx, extruder, temp, wait); // insert at start of extruder plan if time_after_extruder_plan_start > extruder_plan.time
+    extruder_plan_before.insertCommand(0, extruder, temp, false); // insert at start of extruder plan if time_after_extruder_plan_start > extruder_plan.time
 }
 
 Preheat::WarmUpResult LayerPlanBuffer::timeBeforeExtruderPlanToInsert(std::vector<ExtruderPlan*>& extruder_plans, unsigned int extruder_plan_idx)
 {
     ExtruderPlan& extruder_plan = *extruder_plans[extruder_plan_idx];
     int extruder = extruder_plan.extruder;
-    double initial_print_temp = extruder_plan.initial_printing_temperature;
-
+    double required_temp = extruder_plan.required_temp;
+    
     double in_between_time = 0.0;
     for (unsigned int extruder_plan_before_idx = extruder_plan_idx - 1; int(extruder_plan_before_idx) >= 0; extruder_plan_before_idx--)
     { // find a previous extruder plan where the same extruder is used to see what time this extruder wasn't used
-        ExtruderPlan& extruder_plan_before = *extruder_plans[extruder_plan_before_idx];
-        if (extruder_plan_before.extruder == extruder)
+        ExtruderPlan& extruder_plan = *extruder_plans[extruder_plan_before_idx];
+        if (extruder_plan.extruder == extruder)
         {
-            double temp_before = preheat_config.getFinalPrintTemp(extruder);
-            if (temp_before == 0)
-            {
-                temp_before = extruder_plan_before.printing_temperature;
-            }
-            constexpr bool during_printing = false;
-            Preheat::WarmUpResult warm_up = preheat_config.getWarmUpPointAfterCoolDown(in_between_time, extruder, temp_before, preheat_config.getStandbyTemp(extruder), initial_print_temp, during_printing);
+            Preheat::WarmUpResult warm_up = preheat_config.timeBeforeEndToInsertPreheatCommand_coolDownWarmUp(in_between_time, extruder, required_temp);
             warm_up.heating_time = std::min(in_between_time, warm_up.heating_time + extra_preheat_time);
             return warm_up;
         }
-        in_between_time += extruder_plan_before.estimates.getTotalTime();
+        in_between_time += extruder_plan.estimates.getTotalTime();
     }
     // The last extruder plan with the same extruder falls outside of the buffer
     // assume the nozzle has cooled down to strandby temperature already.
     Preheat::WarmUpResult warm_up;
     warm_up.total_time_window = in_between_time;
     warm_up.lowest_temperature = preheat_config.getStandbyTemp(extruder);
-    constexpr bool during_printing = false;
-    warm_up.heating_time = preheat_config.getTimeToGoFromTempToTemp(extruder, warm_up.lowest_temperature, initial_print_temp, during_printing);
+    warm_up.heating_time = preheat_config.timeBeforeEndToInsertPreheatCommand_warmUp(warm_up.lowest_temperature, extruder, required_temp, false);
     if (warm_up.heating_time > in_between_time)
     {
         warm_up.heating_time = in_between_time;
-        warm_up.lowest_temperature = in_between_time / preheat_config.getTimeToHeatup1Degree(extruder, during_printing);
+        warm_up.lowest_temperature = in_between_time / preheat_config.getTimeToHeatup1Degree(extruder);
     }
     warm_up.heating_time = warm_up.heating_time + extra_preheat_time;
     return warm_up;
@@ -92,8 +82,7 @@ Preheat::WarmUpResult LayerPlanBuffer::timeBeforeExtruderPlanToInsert(std::vecto
 void LayerPlanBuffer::insertPreheatCommand_singleExtrusion(ExtruderPlan& prev_extruder_plan, int extruder, double required_temp)
 {
     // time_before_extruder_plan_end is halved, so that at the layer change the temperature will be half way betewen the two requested temperatures
-    constexpr bool during_printing = true;
-    double time_before_extruder_plan_end = 0.5 * preheat_config.getTimeToGoFromTempToTemp(extruder, prev_extruder_plan.printing_temperature, required_temp, during_printing);
+    double time_before_extruder_plan_end = 0.5 * preheat_config.timeBeforeEndToInsertPreheatCommand_warmUp(prev_extruder_plan.required_temp, extruder, required_temp, true);
     time_before_extruder_plan_end = std::min(prev_extruder_plan.estimates.getTotalTime(), time_before_extruder_plan_end);
 
     insertPreheatCommand(prev_extruder_plan, time_before_extruder_plan_end, extruder, required_temp);
@@ -122,13 +111,13 @@ void LayerPlanBuffer::insertPreheatCommand_multiExtrusion(std::vector<ExtruderPl
 {
     ExtruderPlan& extruder_plan = *extruder_plans[extruder_plan_idx];
     int extruder = extruder_plan.extruder;
-    double initial_print_temp = extruder_plan.initial_printing_temperature;
+    double required_temp = extruder_plan.required_temp;
     
     Preheat::WarmUpResult heating_time_and_from_temp = timeBeforeExtruderPlanToInsert(extruder_plans, extruder_plan_idx);
 
     if (heating_time_and_from_temp.total_time_window < preheat_config.getMinimalTimeWindow(extruder))
     {
-        handleStandbyTemp(extruder_plans, extruder_plan_idx, initial_print_temp);
+        handleStandbyTemp(extruder_plans, extruder_plan_idx, required_temp);
         return; // don't insert preheat command and just stay on printing temperature
     }
     else
@@ -136,32 +125,30 @@ void LayerPlanBuffer::insertPreheatCommand_multiExtrusion(std::vector<ExtruderPl
         handleStandbyTemp(extruder_plans, extruder_plan_idx, heating_time_and_from_temp.lowest_temperature);
     }
 
-    // handle preheat command
     double time_before_extruder_plan_to_insert = heating_time_and_from_temp.heating_time;
     for (unsigned int extruder_plan_before_idx = extruder_plan_idx - 1; int(extruder_plan_before_idx) >= 0; extruder_plan_before_idx--)
     {
         ExtruderPlan& extruder_plan_before = *extruder_plans[extruder_plan_before_idx];
         assert (extruder_plan_before.extruder != extruder);
-
+        
         double time_here = extruder_plan_before.estimates.getTotalTime();
         if (time_here >= time_before_extruder_plan_to_insert)
         {
-            insertPreheatCommand(extruder_plan_before, time_before_extruder_plan_to_insert, extruder, initial_print_temp);
+            insertPreheatCommand(extruder_plan_before, time_before_extruder_plan_to_insert, extruder, required_temp);
             return;
         }
         time_before_extruder_plan_to_insert -= time_here;
     }
-
+    
     // time_before_extruder_plan_to_insert falls before all plans in the buffer
-    bool wait = false;
-    unsigned int path_idx = 0;
-    extruder_plans[0]->insertCommand(path_idx, extruder, initial_print_temp, wait); // insert preheat command at verfy beginning of buffer
+    extruder_plans[0]->insertCommand(0, extruder, required_temp, false); // insert preheat command at verfy beginning of buffer
 }
 
-void LayerPlanBuffer::insertTempCommands(std::vector<ExtruderPlan*>& extruder_plans, unsigned int extruder_plan_idx)
+void LayerPlanBuffer::insertPreheatCommand(std::vector<ExtruderPlan*>& extruder_plans, unsigned int extruder_plan_idx)
 {   
     ExtruderPlan& extruder_plan = *extruder_plans[extruder_plan_idx];
     int extruder = extruder_plan.extruder;
+    double required_temp = extruder_plan.required_temp;
     
     
     ExtruderPlan* prev_extruder_plan = extruder_plans[extruder_plan_idx - 1];
@@ -175,156 +162,21 @@ void LayerPlanBuffer::insertTempCommands(std::vector<ExtruderPlan*>& extruder_pl
     
     if (prev_extruder == extruder)
     {
-        insertPreheatCommand_singleExtrusion(*prev_extruder_plan, extruder, extruder_plan.printing_temperature);
-        prev_extruder_plan->printing_temperature_command = --prev_extruder_plan->inserts.end();
+        if (preheat_config.usesFlowDependentTemp(extruder))
+        {
+            insertPreheatCommand_singleExtrusion(*prev_extruder_plan, extruder, required_temp);
+        }
     }
     else 
     {
         insertPreheatCommand_multiExtrusion(extruder_plans, extruder_plan_idx);
-        insertFinalPrintTempCommand(extruder_plans, extruder_plan_idx - 1);
-        insertPrintTempCommand(extruder_plan);
     }
+    
 }
 
-void LayerPlanBuffer::insertPrintTempCommand(ExtruderPlan& extruder_plan)
+void LayerPlanBuffer::insertPreheatCommands()
 {
-    unsigned int extruder = extruder_plan.extruder;
-    double print_temp = extruder_plan.printing_temperature;
-
-    double heated_pre_travel_time = 0;
-    if (preheat_config.getInitialPrintTemp(extruder) != 0)
-    { // handle heating from initial_print_temperature to printing_tempreature
-        unsigned int path_idx;
-        for (path_idx = 0; path_idx < extruder_plan.paths.size(); path_idx++)
-        {
-            GCodePath& path = extruder_plan.paths[path_idx];
-            heated_pre_travel_time += path.estimates.getTotalTime();
-            if (!path.isTravelPath())
-            {
-                break;
-            }
-        }
-        bool wait = false;
-        extruder_plan.insertCommand(path_idx, extruder, print_temp, wait);
-    }
-    extruder_plan.heated_pre_travel_time = heated_pre_travel_time;
-}
-
-void LayerPlanBuffer::insertFinalPrintTempCommand(std::vector<ExtruderPlan*>& extruder_plans, unsigned int last_extruder_plan_idx)
-{
-    ExtruderPlan& last_extruder_plan = *extruder_plans[last_extruder_plan_idx];
-    int extruder = last_extruder_plan.extruder;
-
-    double final_print_temp = preheat_config.getFinalPrintTemp(extruder);
-    if (final_print_temp == 0)
-    {
-        return;
-    }
-
-    double heated_post_travel_time = 0; // The time after the last extrude move toward the end of the extruder plan during which the nozzle is stable at the final print temperature
-    { // compute heated_post_travel_time
-        unsigned int path_idx;
-        for (path_idx = last_extruder_plan.paths.size() - 1; int(path_idx) >= 0; path_idx--)
-        {
-            GCodePath& path = last_extruder_plan.paths[path_idx];
-            if (!path.isTravelPath())
-            {
-                break;
-            }
-            heated_post_travel_time += path.estimates.getTotalTime();
-        }
-    }
-
-    double time_window = 0; // The time window within which the nozzle needs to heat from the initial print temp to the printing temperature and then back to the final print temp; i.e. from the first to the last extrusion move with this extruder
-    double weighted_average_print_temp = 0; // The average of the normal printing temperatures of the extruder plans (which might be different due to flow dependent temp or due to initial layer temp) Weighted by time
-    double initial_print_temp = -1; // The initial print temp of the first extruder plan with this extruder
-    { // compute time window and print temp statistics
-        double heated_pre_travel_time = -1; // The time before the first extrude move from the start of the extruder plan during which the nozzle is stable at the initial print temperature
-        for (unsigned int prev_extruder_plan_idx = last_extruder_plan_idx; (int)prev_extruder_plan_idx >= 0; prev_extruder_plan_idx--)
-        {
-            ExtruderPlan& prev_extruder_plan = *extruder_plans[prev_extruder_plan_idx];
-            if (prev_extruder_plan.extruder != extruder)
-            {
-                break;
-            }
-            double prev_extruder_plan_time = prev_extruder_plan.estimates.getTotalTime();
-            time_window += prev_extruder_plan_time;
-            heated_pre_travel_time = prev_extruder_plan.heated_pre_travel_time;
-
-            if (prev_extruder_plan.estimates.getTotalUnretractedTime() > 0)
-            { // handle temp statistics
-                assert(prev_extruder_plan.printing_temperature != -1 && "Previous extruder plan should already have a temperature planned");
-                weighted_average_print_temp += prev_extruder_plan.printing_temperature * prev_extruder_plan_time;
-                initial_print_temp = prev_extruder_plan.initial_printing_temperature;
-            }
-        }
-        weighted_average_print_temp /= time_window;
-        time_window -= heated_pre_travel_time + heated_post_travel_time;
-        assert(heated_pre_travel_time != -1 && "heated_pre_travel_time must have been computed; there must have been an extruder plan!");
-    }
-
-    assert((time_window >= 0 || last_extruder_plan.estimates.getMaterial() == 0) && "Time window should always be positive if we actually extrude");
-
-    //          ,layer change                                                                                   .
-    //          :     ,precool command                   ,layer change                                          .
-    //          : ____:                                  :     ,precool command                                 .
-    //          :/    \                             _____:_____:                                                .
-    //     _____/      \                           /           \                                                .
-    //    /             \                         /             \                                               .
-    //   /                                       /                                                              .
-    //  /                                       /                                                               .
-    //                                                                                                          .
-    // approximate ^               by                   ^                                                       .
-    // This approximation is quite ok since it only determines where to insert the precool temp command,
-    // which means the stable temperature of the previous extruder plan and the stable temperature of the next extruder plan couldn't be reached
-    constexpr bool during_printing = true;
-    Preheat::CoolDownResult warm_cool_result = preheat_config.getCoolDownPointAfterWarmUp(time_window, extruder, initial_print_temp, weighted_average_print_temp, final_print_temp, during_printing);
-    double cool_down_time = warm_cool_result.cooling_time;
-    assert(cool_down_time >= 0);
-
-    // find extruder plan in which to insert cooling command
-    ExtruderPlan* precool_extruder_plan = &last_extruder_plan;
-    {
-        for (unsigned int precool_extruder_plan_idx = last_extruder_plan_idx; (int)precool_extruder_plan_idx >= 0; precool_extruder_plan_idx--)
-        {
-            precool_extruder_plan = extruder_plans[precool_extruder_plan_idx];
-            if (precool_extruder_plan->printing_temperature_command)
-            { // the precool command ends up before the command to go to the print temperature of the next extruder plan, so remove that print temp command
-                precool_extruder_plan->inserts.erase(*precool_extruder_plan->printing_temperature_command);
-            }
-            double time_here = precool_extruder_plan->estimates.getTotalTime();
-            if (cool_down_time < time_here)
-            {
-                break;
-            }
-            cool_down_time -= time_here;
-        }
-    }
-
-    // at this point cool_down_time is what time is left if cool down time of extruder plans after precool_extruder_plan (up until last_extruder_plan) are already taken into account
-
-    { // insert temp command in precool_extruder_plan
-        double extrusion_time_seen = 0;
-        unsigned int path_idx;
-        for (path_idx = precool_extruder_plan->paths.size() - 1; int(path_idx) >= 0; path_idx--)
-        {
-            GCodePath& path = precool_extruder_plan->paths[path_idx];
-            extrusion_time_seen += path.estimates.getTotalTime();
-            if (extrusion_time_seen >= cool_down_time)
-            {
-                break;
-            }
-        }
-        bool wait = false;
-        double time_after_path_start = extrusion_time_seen - cool_down_time;
-        precool_extruder_plan->insertCommand(path_idx, extruder, final_print_temp, wait, time_after_path_start);
-    }
-}
-
-
-void LayerPlanBuffer::insertTempCommands()
-{
-    if (buffer.back()->extruder_plans.size() == 0 || (buffer.back()->extruder_plans.size() == 1 && buffer.back()->extruder_plans[0].paths.size() == 0))
+    if (buffer.back().extruder_plans.size() == 0 || (buffer.back().extruder_plans.size() == 1 && buffer.back().extruder_plans[0].paths.size() == 0))
     { // disregard empty layer
         buffer.pop_back();
         return;
@@ -332,9 +184,9 @@ void LayerPlanBuffer::insertTempCommands()
 
     std::vector<ExtruderPlan*> extruder_plans;
     extruder_plans.reserve(buffer.size() * 2);
-    for (LayerPlan* layer_plan : buffer)
+    for (GCodePlanner& layer_plan : buffer)
     {
-        for (ExtruderPlan& extr_plan : layer_plan->extruder_plans)
+        for (ExtruderPlan& extr_plan : layer_plan.extruder_plans)
         {
             extruder_plans.push_back(&extr_plan);
         }
@@ -342,30 +194,20 @@ void LayerPlanBuffer::insertTempCommands()
 
 
     // insert commands for all extruder plans on this layer
-    LayerPlan& layer_plan = *buffer.back();
+    GCodePlanner& layer_plan = buffer.back();
     for (unsigned int extruder_plan_idx = 0; extruder_plan_idx < layer_plan.extruder_plans.size(); extruder_plan_idx++)
     {
-        unsigned int overall_extruder_plan_idx = extruder_plans.size() - layer_plan.extruder_plans.size() + extruder_plan_idx;
         ExtruderPlan& extruder_plan = layer_plan.extruder_plans[extruder_plan_idx];
-        int extruder = extruder_plan.extruder;
         double time = extruder_plan.estimates.getTotalUnretractedTime();
-        if (time <= 0.0)
+        if (time <= 0.0 
+            || extruder_plan.estimates.getMaterial() == 0.0 // extruder plan only consists of moves (when an extruder switch occurs at the beginning of a layer)
+        )
         {
             continue;
         }
         
-        double avg_flow = extruder_plan.estimates.getMaterial() / time;
-        extruder_plan.printing_temperature = preheat_config.getTemp(extruder, avg_flow, extruder_plan.is_initial_layer);
-        extruder_plan.initial_printing_temperature = preheat_config.getInitialPrintTemp(extruder);
-        if (extruder_plan.initial_printing_temperature == 0
-            || !extruder_used_in_meshgroup[extruder]
-            || (overall_extruder_plan_idx > 0 && extruder_plans[overall_extruder_plan_idx - 1]->extruder == extruder)
-        )
-        {
-            extruder_plan.initial_printing_temperature = extruder_plan.printing_temperature;
-            extruder_used_in_meshgroup[extruder] = true;
-        }
-        assert(extruder_plan.printing_temperature != -1 && "extruder_plan.printing_temperature should now have been set");
+        double avg_flow = extruder_plan.estimates.getMaterial() / time; // TODO: subtract retracted travel time
+        extruder_plan.required_temp = preheat_config.getTemp(extruder_plan.extruder, avg_flow);
 
         if (buffer.size() == 1 && extruder_plan_idx == 0)
         { // the very first extruder plan of the current meshgroup
@@ -379,7 +221,7 @@ void LayerPlanBuffer::insertTempCommands()
                     // see  FffGcodeWriter::processStartingCode
                     if (extruder_idx == extruder)
                     {
-                        gcode.setInitialTemp(extruder_idx, extruder_plan.printing_temperature);
+                        gcode.setInitialTemp(extruder_idx, extruder_plan.required_temp);
                     }
                     else 
                     {
@@ -397,7 +239,8 @@ void LayerPlanBuffer::insertTempCommands()
             continue;
         }
 
-        insertTempCommands(extruder_plans, overall_extruder_plan_idx);
+        unsigned int overall_extruder_plan_idx = extruder_plans.size() - layer_plan.extruder_plans.size() + extruder_plan_idx;
+        insertPreheatCommand(extruder_plans, overall_extruder_plan_idx);
     }
 }
 

src/LayerPlanBuffer.h

@@ -1,4 +1,3 @@
-/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
 #ifndef LAYER_PLAN_BUFFER_H
 #define LAYER_PLAN_BUFFER_H
 
@@ -8,7 +7,7 @@
 #include "commandSocket.h"
 
 #include "gcodeExport.h"
-#include "LayerPlan.h"
+#include "gcodePlanner.h"
 #include "MeshGroup.h"
 
 #include "Preheat.h"
@@ -16,19 +15,6 @@
 namespace cura 
 {
 
-/*!
- * Class for buffering multiple layer plans (\ref LayerPlan) / extruder plans within those layer plans, so that temperature commands can be inserted in earlier layer plans.
- * 
- * This class handles where to insert temperature commands for:
- * - initial layer temperature
- * - flow dependent temperature
- * - starting to heat up from the standby temperature
- * - initial printing temperature | printing temperature | final printing temperature
- * 
- * \image html assets/precool.png "Temperature Regulation" width=10cm
- * \image latex assets/precool.png "Temperature Regulation" width=10cm
- * 
- */
 class LayerPlanBuffer : SettingsMessenger
 {
     GCodeExport& gcode;
@@ -40,61 +26,48 @@ class LayerPlanBuffer : SettingsMessenger
 
     static constexpr const double extra_preheat_time = 1.0; //!< Time to start heating earlier than computed to avoid accummulative discrepancy between actual heating times and computed ones.
 
-    std::vector<bool> extruder_used_in_meshgroup; //!< For each extruder whether it has already been planned once in this meshgroup. This is used to see whether we should heat to the initial_print_temp or to the printing_temperature
 public:
-    std::list<LayerPlan*> buffer; //!< The buffer containing several layer plans (LayerPlan) before writing them to gcode.
+    std::list<GCodePlanner> buffer; //!< The buffer containing several layer plans (GCodePlanner) before writing them to gcode.
     
     LayerPlanBuffer(SettingsBaseVirtual* settings, GCodeExport& gcode)
     : SettingsMessenger(settings)
     , gcode(gcode)
-    , extruder_used_in_meshgroup(MAX_EXTRUDERS, false)
     { }
     
     void setPreheatConfig(MeshGroup& settings)
     {
         preheat_config.setConfig(settings);
     }
-
+    
     /*!
-     * Push a new layer plan into the buffer
+     * Place a new layer plan (GcodePlanner) by constructing it with the given arguments.
+     * Pop back the oldest layer plan is it exceeds the buffer size and write it to gcode.
      */
-    void push(LayerPlan& layer_plan)
-    {
-        buffer.push_back(&layer_plan);
-    }
-
-    /*!
-     * Process all layers in the buffer
-     * This inserts the temperature commands to start warming for a given layer in earlier layers
-     * 
-     * Pop out the earliest layer in the buffer if the buffer size is exceeded
-     * \return A nullptr or the popped gcode_layer
-     */
-    LayerPlan* processBuffer()
+    template<typename... Args>
+    GCodePlanner& emplace_back(Args&&... constructor_args)
     {
         if (buffer.size() > 0)
         {
-            insertTempCommands(); // insert preheat commands of the just completed layer plan (not the newly emplaced one)
+            insertPreheatCommands(); // insert preheat commands of the just completed layer plan (not the newly emplaced one)
         }
+        buffer.emplace_back(constructor_args...);
         if (buffer.size() > buffer_size)
         {
-            LayerPlan* ret = buffer.front();
+            buffer.front().writeGCode(gcode);
             if (CommandSocket::isInstantiated())
             {
                 CommandSocket::getInstance()->flushGcode();
             }
             buffer.pop_front();
-            return ret;
         }
-        return nullptr;
+        return buffer.back();
     }
     
     /*!
-     * Write all remaining layer plans (LayerPlan) to gcode and empty the buffer.
+     * Write all remaining layer plans (GCodePlanner) to gcode and empty the buffer.
      */
     void flush();
-
-private:
+    
     /*!
      * Insert the preheat command for @p extruder into @p extruder_plan_before
      * 
@@ -144,34 +117,13 @@ private:
      * \param extruder_plans The extruder plans in the buffer, moved to a temporary vector (from lower to upper layers)
      * \param extruder_plan_idx The index of the extruder plan in \p extruder_plans for which to generate the preheat command
      */
-    void insertTempCommands(std::vector<ExtruderPlan*>& extruder_plans, unsigned int extruder_plan_idx);
-
-    /*!
-     * Insert the temperature command to heat from the initial print temperature to the printing temperature
-     * 
-     * The temperature command is insert at the start of the very first extrusion move
-     * 
-     * \param extruder_plan The extruder plan in which to insert the heat up command
-     */
-    void insertPrintTempCommand(ExtruderPlan& extruder_plan);
-
-    /*!
-     * Insert the temp command to start cooling from the printing temperature to the final print temp
-     * 
-     * The print temp is inserted before the last extrusion move of the extruder plan corresponding to \p last_extruder_plan_idx
-     * 
-     * The command is inserted at a timed offset before the end of the last extrusion move
-     * 
-     * \param extruder_plans The extruder plans in the buffer, moved to a temporary vector (from lower to upper layers)
-     * \param last_extruder_plan_idx The index of the last extruder plan in \p extruder_plans with the same extruder as previous extruder plans
-     */
-    void insertFinalPrintTempCommand(std::vector<ExtruderPlan*>& extruder_plans, unsigned int last_extruder_plan_idx);
+    void insertPreheatCommand(std::vector<ExtruderPlan*>& extruder_plans, unsigned int extruder_plan_idx);
 
     /*!
      * Insert the preheat commands for the last added layer (unless that layer was empty)
      */
-    void insertTempCommands();
-
+    void insertPreheatCommands();
+private:
     /*!
      * Reconfigure the standby temperature during which we didn't print with this extruder.
      * Find the previous extruder plan with the same extruder as layers[layer_plan_idx].extruder_plans[extruder_plan_idx]

src/MergeInfillLines.cpp

@@ -11,18 +11,14 @@ void MergeInfillLines::writeCompensatedMove(Point& to, double speed, GCodePath&
 {
     double old_line_width = INT2MM(last_path.config->getLineWidth());
     double new_line_width_mm = INT2MM(new_line_width);
+    double speed_mod = old_line_width / new_line_width_mm;
     double extrusion_mod = new_line_width_mm / old_line_width;
-    double new_speed = speed;
-    if (speed_equalize_flow_enabled)
-    {
-        double speed_mod = old_line_width / new_line_width_mm;
-        new_speed = std::min(speed * speed_mod, speed_equalize_flow_max);
-    }
-    sendLineTo(last_path.config->type, to, last_path.getLineWidth());
+    double new_speed = std::min(speed * speed_mod, 150.0); // TODO: hardcoded value: max extrusion speed is 150 mm/s = 9000 mm/min
+    sendPolygon(last_path.config->type, gcode.getPositionXY(), to, last_path.getLineWidth());
     gcode.writeMove(to, new_speed, last_path.getExtrusionMM3perMM() * extrusion_mod);
 }
     
-bool MergeInfillLines::mergeInfillLines(unsigned int& path_idx)
+bool MergeInfillLines::mergeInfillLines(double speed, unsigned int& path_idx)
 { //Check for lots of small moves and combine them into one large line
     Point prev_middle;
     Point last_middle;
@@ -35,12 +31,12 @@ bool MergeInfillLines::mergeInfillLines(unsigned int& path_idx)
             GCodePath& move_path = paths[path_idx];
             for(unsigned int point_idx = 0; point_idx < move_path.points.size() - 1; point_idx++)
             {
-                gcode.writeMove(move_path.points[point_idx], move_path.config->getSpeed() * extruder_plan.getTravelSpeedFactor(), move_path.getExtrusionMM3perMM());
+                gcode.writeMove(move_path.points[point_idx], speed, move_path.getExtrusionMM3perMM());
             }
             gcode.writeMove(prev_middle, travelConfig.getSpeed(), 0);
             GCodePath& last_path = paths[path_idx + 3];
             
-            writeCompensatedMove(last_middle, last_path.config->getSpeed() * extruder_plan.getExtrudeSpeedFactor(), last_path, line_width);
+            writeCompensatedMove(last_middle, speed, last_path, line_width);
         }
         
         path_idx += 2;
@@ -49,7 +45,7 @@ bool MergeInfillLines::mergeInfillLines(unsigned int& path_idx)
         {
             extruder_plan.handleInserts(path_idx, gcode);
             GCodePath& last_path = paths[path_idx + 3];
-            writeCompensatedMove(last_middle, last_path.config->getSpeed() * extruder_plan.getExtrudeSpeedFactor(), last_path, line_width);
+            writeCompensatedMove(last_middle, speed, last_path, line_width);
         }
         path_idx = path_idx + 1; // means that the next path considered is the travel path after the converted extrusion path corresponding to the updated path_idx
         extruder_plan.handleInserts(path_idx, gcode);
@@ -231,4 +227,4 @@ void MergeInfillLines::merge(Point& from, Point& p0, Point& p1)
      
      
      
-}//namespace cura
+}//namespace cura

src/MergeInfillLines.h

@@ -3,7 +3,7 @@
 
 #include "utils/intpoint.h"
 #include "gcodeExport.h"
-#include "LayerPlan.h"
+#include "gcodePlanner.h"
 #include "GCodePathConfig.h"
 
 namespace cura
@@ -17,10 +17,8 @@ class MergeInfillLines
     std::vector<GCodePath>& paths; //!< The paths currently under consideration
     ExtruderPlan& extruder_plan; //!< The extruder plan of the paths currently under consideration
     
-    const GCodePathConfig& travelConfig; //!< The travel settings used to see whether a path is a travel path or an extrusion path
+    GCodePathConfig& travelConfig; //!< The travel settings used to see whether a path is a travel path or an extrusion path
     int64_t nozzle_size; //!< The diameter of the hole in the nozzle
-    bool speed_equalize_flow_enabled; //!< Should the speed be varied with extrusion width
-    double speed_equalize_flow_max; //!< Maximum speed when adjusting speed for flow
 
     /*!
      * Whether the next two extrusion paths are convertible to a single line segment, starting from the end point the of the last travel move at \p path_idx_first_move
@@ -64,18 +62,9 @@ public:
     /*!
      * Simple constructor only used by MergeInfillLines::isConvertible to easily convey the environment
      */
-    MergeInfillLines(GCodeExport& gcode, int layer_nr, std::vector<GCodePath>& paths, ExtruderPlan& extruder_plan, const GCodePathConfig& travelConfig, int64_t nozzle_size, bool speed_equalize_flow_enabled, double speed_equalize_flow_max)
-    : gcode(gcode)
-    , layer_nr(layer_nr)
-    , paths(paths)
-    , extruder_plan(extruder_plan)
-    , travelConfig(travelConfig)
-    , nozzle_size(nozzle_size)
-    , speed_equalize_flow_enabled(speed_equalize_flow_enabled)
-    , speed_equalize_flow_max(speed_equalize_flow_max)
-    {
-    }
-
+    MergeInfillLines(GCodeExport& gcode, int layer_nr, std::vector<GCodePath>& paths, ExtruderPlan& extruder_plan, GCodePathConfig& travelConfig, int64_t nozzle_size) 
+    : gcode(gcode), layer_nr(layer_nr), paths(paths), extruder_plan(extruder_plan), travelConfig(travelConfig), nozzle_size(nozzle_size) { }
+    
     /*!
      * Check for lots of small moves and combine them into one large line.
      * Updates \p path_idx to the next path which is not combined.
@@ -84,19 +73,28 @@ public:
      * \param paths The paths currently under consideration
      * \param travelConfig The travel settings used to see whether a path is a travel path or an extrusion path
      * \param nozzle_size The diameter of the hole in the nozzle
+     * \param speed A factor used to scale the movement speed
      * \param path_idx Input/Output parameter: The current index in \p paths where to start combining and the current index after combining as output parameter.
      * \return Whether lines have been merged and normal path-to-gcode generation can be skipped for the current resulting \p path_idx .
      */
-    bool mergeInfillLines(unsigned int& path_idx);
+    bool mergeInfillLines(double speed, unsigned int& path_idx);
     
     /*!
-     * send a line segment through the command socket from the previous point to the given point \p to
+     * send a polygon through the command socket from the previous point to the given point
      */
-    void sendLineTo(PrintFeatureType print_feature_type, Point to, int line_width)
+    void sendPolygon(PrintFeatureType print_feature_type, Point from, Point to, int line_width)
     {
-        CommandSocket::sendLineTo(print_feature_type, to, line_width);
+        if (CommandSocket::isInstantiated()) 
+        {
+            // we should send this travel as a non-retraction move
+            cura::Polygons pathPoly;
+            PolygonRef path = pathPoly.newPoly();
+            path.add(from);
+            path.add(to);
+            CommandSocket::getInstance()->sendPolygons(print_feature_type, layer_nr, pathPoly, line_width);
+        }
     }
 };
 
 }//namespace cura
-#endif // MERGE_INFILL_LINES_H
+#endif // MERGE_INFILL_LINES_H

src/MeshGroup.cpp

@@ -4,12 +4,9 @@
 #include <stdio.h>
 
 #include "MeshGroup.h"
-#include "utils/gettime.h"
 #include "utils/logoutput.h"
 #include "utils/string.h"
 
-#include "settings/SettingRegistry.h" // loadExtruderJSONsettings
-
 namespace cura
 {
 
@@ -47,7 +44,7 @@ MeshGroup::~MeshGroup()
     }
 }
 
-int MeshGroup::getExtruderCount() const
+int MeshGroup::getExtruderCount()
 {
     if (extruder_count == -1)
     {
@@ -57,20 +54,13 @@ int MeshGroup::getExtruderCount() const
 }
 
 ExtruderTrain* MeshGroup::createExtruderTrain(unsigned int extruder_nr)
-{
-    assert((int)extruder_nr >= 0 && (int)extruder_nr < getSettingAsCount("machine_extruder_count") && "only valid extruder trains may be requested!");
-    if (!extruders[extruder_nr])
     {
-        extruders[extruder_nr] = new ExtruderTrain(this, extruder_nr);
-        int err = SettingRegistry::getInstance()->loadExtruderJSONsettings(extruder_nr, extruders[extruder_nr]);
-        if (err)
+        if (!extruders[extruder_nr])
         {
-            logError("Couldn't load extruder.def.json for extruder %i\n", extruder_nr);
-            std::exit(1);
+            extruders[extruder_nr] = new ExtruderTrain(this, extruder_nr);
         }
+        return extruders[extruder_nr];
     }
-    return extruders[extruder_nr];
-}
 
 ExtruderTrain* MeshGroup::getExtruderTrain(unsigned int extruder_nr)
 {
@@ -128,44 +118,6 @@ void MeshGroup::clear()
 
 void MeshGroup::finalize()
 {
-    extruder_count = getSettingAsCount("machine_extruder_count");
-
-    for (int extruder_nr = 0; extruder_nr < extruder_count; extruder_nr++)
-    {
-        createExtruderTrain(extruder_nr); // create it if it didn't exist yet
-
-        if (getSettingAsIndex("adhesion_extruder_nr") == extruder_nr && getSettingAsPlatformAdhesion("adhesion_type") != EPlatformAdhesion::NONE)
-        {
-            getExtruderTrain(extruder_nr)->setIsUsed(true);
-            continue;
-        }
-
-        for (const Mesh& mesh : meshes)
-        {
-            if (mesh.getSettingBoolean("support_enable")
-                && (
-                    getSettingAsIndex("support_infill_extruder_nr") == extruder_nr
-                    || getSettingAsIndex("support_extruder_nr_layer_0") == extruder_nr
-                    || (getSettingBoolean("support_interface_enable") && getSettingAsIndex("support_interface_extruder_nr") == extruder_nr)
-                    )
-                )
-            {
-                getExtruderTrain(extruder_nr)->setIsUsed(true);
-                break;
-            }
-        }
-    }
-
-    for (const Mesh& mesh : meshes)
-    {
-        if (!mesh.getSettingBoolean("anti_overhang_mesh")
-            && !mesh.getSettingBoolean("support_mesh")
-        )
-        {
-            getExtruderTrain(mesh.getSettingAsIndex("extruder_nr"))->setIsUsed(true);
-        }
-    }
-
     //If the machine settings have been supplied, offset the given position vertices to the center of vertices (0,0,0) is at the bed center.
     Point3 meshgroup_offset(0, 0, 0);
     if (!getSettingBoolean("machine_center_is_zero"))
@@ -331,8 +283,6 @@ bool loadMeshSTL(Mesh* mesh, const char* filename, const FMatrix3x3& matrix)
 
 bool loadMeshIntoMeshGroup(MeshGroup* meshgroup, const char* filename, const FMatrix3x3& transformation, SettingsBaseVirtual* object_parent_settings)
 {
-    TimeKeeper load_timer;
-
     const char* ext = strrchr(filename, '.');
     if (ext && (strcmp(ext, ".stl") == 0 || strcmp(ext, ".STL") == 0))
     {
@@ -340,7 +290,6 @@ bool loadMeshIntoMeshGroup(MeshGroup* meshgroup, const char* filename, const FMa
         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;
         }
     }

src/MeshGroup.h

@@ -18,9 +18,9 @@ namespace cura
 class MeshGroup : public SettingsBase, NoCopy
 {
     ExtruderTrain* extruders[MAX_EXTRUDERS] = {nullptr};
-    mutable int extruder_count; //!< The number of extruders. (mutable because of lazy evaluation)
+    int extruder_count;
 public:
-    int getExtruderCount() const;
+    int getExtruderCount();
 
     MeshGroup(SettingsBaseVirtual* settings_base);
     

src/Preheat.cpp

@@ -1,184 +0,0 @@
-#include "Preheat.h"
-
-namespace cura 
-{
-
-void Preheat::setConfig(const MeshGroup& meshgroup)
-{
-    for (int extruder_nr = 0; extruder_nr < meshgroup.getExtruderCount(); extruder_nr++)
-    {
-        assert(meshgroup.getExtruderTrain(extruder_nr) != nullptr);
-        const ExtruderTrain& extruder_train = *meshgroup.getExtruderTrain(extruder_nr);
-        config_per_extruder.emplace_back();
-        Config& config = config_per_extruder.back();
-        double machine_nozzle_cool_down_speed = extruder_train.getSettingInSeconds("machine_nozzle_cool_down_speed");
-        double machine_nozzle_heat_up_speed = extruder_train.getSettingInSeconds("machine_nozzle_heat_up_speed");
-        double material_extrusion_cool_down_speed = extruder_train.getSettingInSeconds("material_extrusion_cool_down_speed");
-        assert(material_extrusion_cool_down_speed < machine_nozzle_heat_up_speed && "The extrusion cooldown speed must be smaller than the heat up speed; otherwise the printing temperature cannot be reached!");
-        config.time_to_cooldown_1_degree[0] = 1.0 / machine_nozzle_cool_down_speed;
-        config.time_to_heatup_1_degree[0] = 1.0 / machine_nozzle_heat_up_speed;
-        config.time_to_cooldown_1_degree[1] = 1.0 / (machine_nozzle_cool_down_speed + material_extrusion_cool_down_speed);
-        config.time_to_heatup_1_degree[1] = 1.0 / (machine_nozzle_heat_up_speed - material_extrusion_cool_down_speed);
-        config.standby_temp = extruder_train.getSettingInSeconds("material_standby_temperature");
-
-        config.min_time_window = extruder_train.getSettingInSeconds("machine_min_cool_heat_time_window");
-
-        config.material_print_temperature = extruder_train.getSettingInDegreeCelsius("material_print_temperature");
-        config.material_print_temperature_layer_0 = extruder_train.getSettingInDegreeCelsius("material_print_temperature_layer_0");
-        config.material_initial_print_temperature = extruder_train.getSettingInDegreeCelsius("material_initial_print_temperature");
-        config.material_final_print_temperature = extruder_train.getSettingInDegreeCelsius("material_final_print_temperature");
-
-        config.flow_dependent_temperature = extruder_train.getSettingBoolean("material_flow_dependent_temperature"); 
-
-        config.flow_temp_graph = extruder_train.getSettingAsFlowTempGraph("material_flow_temp_graph"); // [[0.1,180],[20,230]]
-    }
-}
-
-double Preheat::getTimeToGoFromTempToTemp(int extruder, double temp_before, double temp_after, bool during_printing)
-{
-    Config& config = config_per_extruder[extruder];
-    double time;
-    if (temp_after > temp_before)
-    {
-        time = (temp_after - temp_before) * config.time_to_heatup_1_degree[during_printing];
-    }
-    else
-    {
-        time = (temp_before - temp_after) * config.time_to_cooldown_1_degree[during_printing];
-    }
-    return std::max(0.0, time);
-}
-
-double Preheat::getTemp(unsigned int extruder, double flow, bool is_initial_layer)
-{
-    if (is_initial_layer && config_per_extruder[extruder].material_print_temperature_layer_0 != 0)
-    {
-        return config_per_extruder[extruder].material_print_temperature_layer_0;
-    }
-    return config_per_extruder[extruder].flow_temp_graph.getTemp(flow, config_per_extruder[extruder].material_print_temperature, config_per_extruder[extruder].flow_dependent_temperature);
-}
-
-Preheat::WarmUpResult Preheat::getWarmUpPointAfterCoolDown(double time_window, unsigned int extruder, double temp_start, double temp_mid, double temp_end, bool during_printing)
-{
-    WarmUpResult result;
-    const Config& config = config_per_extruder[extruder];
-    double time_to_cooldown_1_degree = config.time_to_cooldown_1_degree[during_printing];
-    double time_to_heatup_1_degree = config.time_to_heatup_1_degree[during_printing];
-    result.total_time_window = time_window;
-
-    //                    ,temp_end
-    //                   /                                    .
-    //     ,temp_start  /                                     .
-    //      \ ' ' ' ' '/ ' ' '> outer_temp                    .
-    //       \________/                                       .
-    //               "-> temp_mid
-    //      ^^^^^^^^^^
-    //      limited_time_window
-    double outer_temp;
-    double limited_time_window;
-    if (temp_start < temp_end)
-    { // extra time needed during heating
-        double extra_heatup_time = (temp_end - temp_start) * time_to_heatup_1_degree;
-        result.heating_time = extra_heatup_time;
-        limited_time_window = time_window - extra_heatup_time;
-        outer_temp = temp_start;
-    }
-    else
-    {
-        double extra_cooldown_time = (temp_start - temp_end) * time_to_cooldown_1_degree;
-        result.heating_time = 0;
-        limited_time_window = time_window - extra_cooldown_time;
-        outer_temp = temp_end;
-    }
-    if (limited_time_window < 0.0)
-    {
-        result.heating_time = 0.0;
-        result.lowest_temperature = std::min(temp_start, temp_end);
-        return result;
-    }
-
-    double time_ratio_cooldown_heatup = time_to_cooldown_1_degree / time_to_heatup_1_degree;
-    double time_to_heat_from_standby_to_print_temp = getTimeToGoFromTempToTemp(extruder, temp_mid, outer_temp, during_printing);
-    double time_needed_to_reach_standby_temp = time_to_heat_from_standby_to_print_temp * (1.0 + time_ratio_cooldown_heatup);
-    if (time_needed_to_reach_standby_temp < limited_time_window)
-    {
-        result.heating_time += time_to_heat_from_standby_to_print_temp;
-        result.lowest_temperature = temp_mid;
-    }
-    else 
-    {
-        result.heating_time += limited_time_window * time_to_heatup_1_degree / (time_to_cooldown_1_degree + time_to_heatup_1_degree);
-        result.lowest_temperature = std::max(temp_mid, temp_end - result.heating_time / time_to_heatup_1_degree);
-    }
-
-    if (result.heating_time > time_window || result.heating_time < 0.0)
-    {
-        logWarning("getWarmUpPointAfterCoolDown returns result outside of the time window!");
-    }
-    return result;
-}
-
-Preheat::CoolDownResult Preheat::getCoolDownPointAfterWarmUp(double time_window, unsigned int extruder, double temp_start, double temp_mid, double temp_end, bool during_printing)
-{
-    CoolDownResult result;
-    const Config& config = config_per_extruder[extruder];
-    double time_to_cooldown_1_degree = config.time_to_cooldown_1_degree[during_printing];
-    double time_to_heatup_1_degree = config.time_to_heatup_1_degree[during_printing];
-
-    assert(temp_start != -1 && temp_mid != -1 && temp_end != -1 && "temperatures must be initialized!");
-
-    result.total_time_window = time_window;
-
-    //      limited_time_window
-    //     :^^^^^^^^^^^^:
-    //     :  ________. : . . .> temp_mid
-    //     : /        \ :                                     .
-    //     :/ . . . . .\:. . .> outer_temp                    .
-    //     ^temp_start  \                                     .
-    //                   \                                    .
-    //                    ^temp_end
-    double outer_temp;
-    double limited_time_window;
-    if (temp_start < temp_end)
-    { // extra time needed during heating
-        double extra_heatup_time = (temp_end - temp_start) * time_to_heatup_1_degree;
-        result.cooling_time = 0;
-        limited_time_window = time_window - extra_heatup_time;
-        outer_temp = temp_end;
-    }
-    else
-    {
-        double extra_cooldown_time = (temp_start - temp_end) * time_to_cooldown_1_degree;
-        result.cooling_time = extra_cooldown_time;
-        limited_time_window = time_window - extra_cooldown_time;
-        outer_temp = temp_start;
-    }
-    if (limited_time_window < 0.0)
-    {
-        result.cooling_time = 0.0;
-        result.highest_temperature = std::max(temp_start, temp_end);
-        return result;
-    }
-    double time_ratio_cooldown_heatup = time_to_cooldown_1_degree / time_to_heatup_1_degree;
-    double cool_down_time = getTimeToGoFromTempToTemp(extruder, temp_mid, outer_temp, during_printing);
-    double time_needed_to_reach_temp1 = cool_down_time * (1.0 + time_ratio_cooldown_heatup);
-    if (time_needed_to_reach_temp1 < limited_time_window)
-    {
-        result.cooling_time += cool_down_time;
-        result.highest_temperature = temp_mid;
-    }
-    else 
-    {
-        result.cooling_time += limited_time_window * time_to_heatup_1_degree / (time_to_cooldown_1_degree + time_to_heatup_1_degree);
-        result.highest_temperature = std::min(temp_mid, temp_end + result.cooling_time / time_to_cooldown_1_degree);
-    }
-
-    if (result.cooling_time > time_window || result.cooling_time < 0.0)
-    {
-        logWarning("getCoolDownPointAfterWarmUp returns result outside of the time window!");
-    }
-    return result;
-}
-
-
-}//namespace cura

src/Preheat.h

@@ -26,21 +26,17 @@ class Preheat
     class Config
     {
     public:
-        double time_to_heatup_1_degree[2]; //!< average time it takes to heat up one degree (in the range of normal print temperatures and standby temperature), while not-printing and while printing
-        double time_to_cooldown_1_degree[2]; //!< average time it takes to cool down one degree (in the range of normal print temperatures and standby temperature), while not-printing and while printing
+        double time_to_heatup_1_degree; //!< average time it takes to heat up one degree (in the range of normal print temperatures and standby temperature)
+        double time_to_cooldown_1_degree; //!< average time it takes to cool down one degree (in the range of normal print temperatures and standby temperature)
+        
+        double heatup_cooldown_time_mod_while_printing; //!< The time to be added to Preheat::time_to_heatup_1_degree and subtracted from Preheat::time_to_cooldown_1_degree to get the timings while printing
 
         double standby_temp; //!< The temperature at which the nozzle rests when it is not printing.
 
         double min_time_window; //!< Minimal time (in seconds) to allow an extruder to cool down and then warm up again.
 
         double material_print_temperature; //!< default print temp (backward compatilibily)
-
-        double material_print_temperature_layer_0; //!< initial layer print temp
-
-        double material_initial_print_temperature; //!< print temp when first starting to extrude after a layer switch
-
-        double material_final_print_temperature; //!< print temp at the end of all extrusion moves of an extruder to which it's cooled down just before - during the extrusion
-
+        
         bool flow_dependent_temperature; //!< Whether to make the temperature dependent on flow
     
         FlowTempGraph flow_temp_graph; //!< The graph linking flows to corresponding temperatures
@@ -58,16 +54,6 @@ public:
         double lowest_temperature; //!< The lower temperature from which heating starts.
     };
 
-    /*!
-     * The type of result when computing when to start cooling down a nozzle before it's not going to be used again.
-     */
-    struct CoolDownResult
-    {
-        double total_time_window; //!< The total time in which heating and cooling takes place.
-        double cooling_time; //!< The total time needed to cool down to the required temperature.
-        double highest_temperature; //!< The upper temperature from which cooling starts.
-    };
-
     /*!
      * Get the standby temperature of an extruder train
      * \param extruder the extruder train for which to get the standby tmep
@@ -82,51 +68,68 @@ public:
      * Get the time it takes to heat up one degree celsius
      * 
      * \param extruder the extruder train for which to get time it takes to heat up one degree celsius
-     * \param during_printing whether the heating takes time during printing or when idle
      * \return the time it takes to heat up one degree celsius
      */
-    double getTimeToHeatup1Degree(int extruder, bool during_printing)
+    double getTimeToHeatup1Degree(int extruder)
     {
-        return config_per_extruder[extruder].time_to_heatup_1_degree[during_printing];
-    }
-
-    /*!
-     * Get the initial print temperature when starting to extrude.
-     * \param during_printing whether the heating takes time during printing or when idle
-     */
-    double getInitialPrintTemp(int extruder)
-    {
-        return config_per_extruder[extruder].material_initial_print_temperature;
-    }
-
-    /*!
-     * Get the final print temperature at the end of all extrusion moves with the current extruder
-     */
-    double getFinalPrintTemp(int extruder)
-    {
-        return config_per_extruder[extruder].material_final_print_temperature;
+        return config_per_extruder[extruder].time_to_heatup_1_degree;
     }
 
     /*!
      * Set the nozzle and material temperature settings for each extruder train.
-     * \param meshgroup Where to get settings from
      */
-    void setConfig(const MeshGroup& meshgroup);
+    void setConfig(MeshGroup& settings)
+    {
+        for (int extruder_nr = 0; extruder_nr < settings.getExtruderCount(); extruder_nr++)
+        {
+            assert(settings.getExtruderTrain(extruder_nr) != nullptr);
+            ExtruderTrain& extruder_train = *settings.getExtruderTrain(extruder_nr);
+            config_per_extruder.emplace_back();
+            Config& config = config_per_extruder.back();
+            config.time_to_cooldown_1_degree = 1.0 / extruder_train.getSettingInSeconds("machine_nozzle_cool_down_speed"); // 0.5
+            config.time_to_heatup_1_degree = 1.0 / extruder_train.getSettingInSeconds("machine_nozzle_heat_up_speed"); // 0.5
+            config.heatup_cooldown_time_mod_while_printing = 1.0 / extruder_train.getSettingInSeconds("material_extrusion_cool_down_speed"); // 0.1
+            config.standby_temp = extruder_train.getSettingInSeconds("material_standby_temperature"); // 150
 
+            config.min_time_window = extruder_train.getSettingInSeconds("machine_min_cool_heat_time_window");
+
+            config.material_print_temperature = extruder_train.getSettingInDegreeCelsius("material_print_temperature"); // 220
+            
+            config.flow_dependent_temperature = extruder_train.getSettingBoolean("material_flow_dependent_temperature"); 
+            
+            config.flow_temp_graph = extruder_train.getSettingAsFlowTempGraph("material_flow_temp_graph"); // [[0.1,180],[20,230]]
+        }
+    }
+    
     bool usesFlowDependentTemp(int extruder_nr)
     {
         return config_per_extruder[extruder_nr].flow_dependent_temperature;
     }
+private:
     /*!
-     * Get the optimal temperature corresponding to a given average flow,
-     * or the initial layer temperature.
+     * Calculate time to heat up from standby temperature to a given temperature.
+     * Assumes @p temp is higher than the standby temperature.
      * 
+     * \param extruder The extruder for which to get the time
+     * \param temp The temperature to be reached
+     */
+    double timeToHeatFromStandbyToPrintTemp(unsigned int extruder, double temp)
+    {
+        return (temp - config_per_extruder[extruder].standby_temp) * config_per_extruder[extruder].time_to_heatup_1_degree; 
+    }
+
+public:
+    
+    /*!
+     * Get the optimal temperature corresponding to a given average flow.
      * \param extruder The extruder train
      * \param flow The flow for which to get the optimal temperature
-     * \param is_initial_layer Whether the initial layer temperature should be returned instead of flow-based temperature
      * \return The corresponding optimal temperature
      */
-    double getTemp(unsigned int extruder, double flow, bool is_initial_layer);
+    double getTemp(unsigned int extruder, double flow)
+    {
+        return config_per_extruder[extruder].flow_temp_graph.getTemp(flow, config_per_extruder[extruder].material_print_temperature, config_per_extruder[extruder].flow_dependent_temperature);
+    }
 
     /*!
      * Return the minimal time window of a specific extruder for letting an unused extruder cool down and warm up again
@@ -139,62 +142,76 @@ public:
     }
 
     /*!
-     * Decide when to start warming up again after starting to cool down towards \p temp_mid.
+     * Decide when to start warming up again after starting to cool down towards the standby temperature.
      * Two cases are considered: 
      * the case where the standby temperature is reached  \__/    .
      * and the case where it isn't  \/    .
      * 
-     * \warning it is assumed that \p temp_mid is lower than both \p temp_start and \p temp_end. If not somewhat weird results may follow.
+     * IT is assumed that the printer is not printing during this cool down and warm up time.
+     * 
+     * Assumes from_temp is approximately the same as @p temp
      * 
-    //                    ,temp_end
-    //                   /                                    .
-    //     ,temp_start  /                                     .
-    //      \          /                                      .
-    //       \________/                                       .
-    //               "-> temp_mid
      * \param window_time The time window within which the cooldown and heat up must take place.
      * \param extruder The extruder used
-     * \param temp_start The temperature from which to start cooling down
-     * \param temp_mid The temeprature to which we try to cool down
-     * \param temp_end The temperature to which we need to have heated up at the end of the \p time_window
-     * \param during_printing Whether the warming up and cooling down is performed during printing
+     * \param temp The temperature to which to heat
      * \return The time before the end of the @p time_window to insert the preheat command and the temperature from which the heating starts
      */
-    WarmUpResult getWarmUpPointAfterCoolDown(double time_window, unsigned int extruder, double temp_start, double temp_mid, double temp_end, bool during_printing);
-
+    WarmUpResult timeBeforeEndToInsertPreheatCommand_coolDownWarmUp(double time_window, unsigned int extruder, double temp)
+    {
+        WarmUpResult result;
+        const Config& config = config_per_extruder[extruder];
+        result.total_time_window = time_window;
+        double time_ratio_cooldown_heatup = config.time_to_cooldown_1_degree / config.time_to_heatup_1_degree;
+        double time_to_heat_from_standby_to_print_temp = timeToHeatFromStandbyToPrintTemp(extruder, temp);
+        double time_needed_to_reach_standby_temp = time_to_heat_from_standby_to_print_temp * (1.0 + time_ratio_cooldown_heatup);
+        if (time_needed_to_reach_standby_temp < time_window)
+        {
+            result.heating_time = time_to_heat_from_standby_to_print_temp;
+            result.lowest_temperature = config.standby_temp;
+        }
+        else 
+        {
+            result.heating_time = time_window * config.time_to_heatup_1_degree / (config.time_to_cooldown_1_degree + config.time_to_heatup_1_degree);
+            result.lowest_temperature = std::max(config.standby_temp, temp - result.heating_time / config.time_to_heatup_1_degree);
+        }
+        return result;
+    }
     /*!
-     * Decide when to start cooling down again after starting to warm up towards the \p temp_mid
-     * Two cases are considered: 
-     * the case where the temperature is reached  /"""\    .
-     * and the case where it isn't  /\    .
+     * Calculate time needed to warm up the nozzle from a given temp to a given temp.
+     * If the printer is printing in the mean time the warming up will take longer.
      * 
-     * \warning it is assumed that \p temp_mid is higher than both \p temp_start and \p temp_end. If not somewhat weird results may follow.
      * 
-    //               _> temp_mid
-    //       /""""""""\                                       .
-    //      /          \                                      .
-    //     ^temp_start  \                                     .
-    //                   \                                    .
-    //                    ^temp_end
-     * \param window_time The time window within which the cooldown and heat up must take place.
+     * \param from_temp The temperature at which the nozzle was before
      * \param extruder The extruder used
-     * \param temp_start The temperature from which to start heating up
-     * \param temp_mid The temeprature to which we try to heat up
-     * \param temp_end The temperature to which we need to have cooled down after \p time_window time
-     * \param during_printing Whether the warming up and cooling down is performed during printing
-     * \return The time before the end of the \p time_window to insert the preheat command and the temperature from which the cooling starts
+     * \param temp The temperature to which to heat
+     * \param printing Whether the printer is printing in the time to heat up the nozzle
+     * \return The time needed to reach the desired temperature (@p temp)
      */
-    CoolDownResult getCoolDownPointAfterWarmUp(double time_window, unsigned int extruder, double temp_start, double temp_mid, double temp_end, bool during_printing);
-
-    /*!
-     * Get the time to go from one temperature to another temperature
-     * \param extruder The extruder number for which to perform the heatup / cooldown
-     * \param temp_before The before temperature
-     * \param temp_after The after temperature
-     * \param during_printing Whether the planned cooldown / warmup occurs during printing or while in standby mode
-     * \return The time needed
-     */
-    double getTimeToGoFromTempToTemp(int extruder, double temp_before, double temp_after, bool during_printing);
+    double timeBeforeEndToInsertPreheatCommand_warmUp(double from_temp, unsigned int extruder, double temp, bool printing)
+    {
+        if (temp > from_temp)
+        {
+            if (printing)
+            {
+                return (temp - from_temp) * (config_per_extruder[extruder].time_to_heatup_1_degree + config_per_extruder[extruder].heatup_cooldown_time_mod_while_printing); 
+            }
+            else 
+            {
+                return (temp - from_temp) * config_per_extruder[extruder].time_to_heatup_1_degree; 
+            }
+        }
+        else 
+        {
+            if (printing)
+            {
+                return (from_temp - temp) * config_per_extruder[extruder].time_to_cooldown_1_degree; 
+            }
+            else 
+            {
+                return (from_temp - temp) * std::max(0.0, config_per_extruder[extruder].time_to_cooldown_1_degree - config_per_extruder[extruder].heatup_cooldown_time_mod_while_printing); 
+            }
+        }
+    }
 };
 
 } // namespace cura 

src/PrimeTower.cpp

@@ -1,43 +1,109 @@
 #include "PrimeTower.h"
 
-#include <limits>
-
 #include "ExtruderTrain.h"
 #include "sliceDataStorage.h"
 #include "gcodeExport.h"
-#include "LayerPlan.h"
+#include "gcodePlanner.h"
 #include "infill.h"
 #include "PrintFeature.h"
 
 namespace cura 
 {
-
-PrimeTower::PrimeTower(const SliceDataStorage& storage)
-: is_hollow(false)
-, wipe_from_middle(false)
+    
+    
+PrimeTower::PrimeTower()
 {
-    enabled = storage.getSettingBoolean("prime_tower_enable")
-           && storage.getSettingInMicrons("prime_tower_wall_thickness") > 10
-           && storage.getSettingInMicrons("prime_tower_size") > 10;
-    if (enabled)
+}
+
+
+
+void PrimeTower::initConfigs(MeshGroup* meshgroup, std::vector<RetractionConfig>& retraction_config_per_extruder)
+{
+    extruder_count = meshgroup->getSettingAsCount("machine_extruder_count");
+    
+    for (int extr = 0; extr < extruder_count; extr++)
     {
-        generateGroundpoly(storage);
+        config_per_extruder.emplace_back(PrintFeatureType::Support);// so that visualization in the old Cura still works (TODO)
+    }
+    for (int extr = 0; extr < extruder_count; extr++)
+    {
+        ExtruderTrain* train = meshgroup->getExtruderTrain(extr);
+        config_per_extruder[extr].init(train->getSettingInMillimetersPerSecond("speed_prime_tower"), train->getSettingInMillimetersPerSecond("acceleration_prime_tower"), train->getSettingInMillimetersPerSecond("jerk_prime_tower"), train->getSettingInMicrons("prime_tower_line_width"), train->getSettingInPercentage("prime_tower_flow"));
     }
 }
 
-void PrimeTower::generateGroundpoly(const SliceDataStorage& storage)
+void PrimeTower::setConfigs(MeshGroup* meshgroup, int layer_thickness)
 {
-    extruder_count = storage.meshgroup->getExtruderCount();
-
-    int64_t prime_tower_wall_thickness = storage.getSettingInMicrons("prime_tower_wall_thickness");
-    int64_t tower_size = storage.getSettingInMicrons("prime_tower_size");
-
-    if (prime_tower_wall_thickness * 2 < tower_size)
+    
+    extruder_count = meshgroup->getSettingAsCount("machine_extruder_count");
+    
+    for (int extr = 0; extr < extruder_count; extr++)
     {
-        is_hollow = true;
+        GCodePathConfig& conf = config_per_extruder[extr];
+        conf.setLayerHeight(layer_thickness);
     }
+}
 
-    PolygonRef p = ground_poly.newPoly();
+    
+
+void PrimeTower::computePrimeTowerMax(SliceDataStorage& storage)
+{ // compute storage.max_object_height_second_to_last_extruder, which is used to determine the highest point in the prime tower
+        
+    extruder_count = storage.getSettingAsCount("machine_extruder_count");
+    
+    int max_object_height_per_extruder[extruder_count]; 
+    std::fill_n(max_object_height_per_extruder, extruder_count, -1); // unitialize all as -1
+    { // compute max_object_height_per_extruder
+        for (SliceMeshStorage& mesh : storage.meshes)
+        {
+            unsigned int extr_nr = mesh.getSettingAsIndex("extruder_nr");
+            max_object_height_per_extruder[extr_nr] = 
+                std::max(   max_object_height_per_extruder[extr_nr]
+                        ,   mesh.layer_nr_max_filled_layer  ); 
+        }
+        int support_infill_extruder_nr = storage.getSettingAsIndex("support_infill_extruder_nr"); // TODO: support extruder should be configurable per object
+        max_object_height_per_extruder[support_infill_extruder_nr] = 
+        std::max(   max_object_height_per_extruder[support_infill_extruder_nr]
+                ,   storage.support.layer_nr_max_filled_layer  ); 
+        int support_roof_extruder_nr = storage.getSettingAsIndex("support_roof_extruder_nr"); // TODO: support roof extruder should be configurable per object
+        max_object_height_per_extruder[support_roof_extruder_nr] = 
+        std::max(   max_object_height_per_extruder[support_roof_extruder_nr]
+                ,   storage.support.layer_nr_max_filled_layer  ); 
+    }
+    { // // compute max_object_height_second_to_last_extruder
+        int extruder_max_object_height = 0;
+        for (int extruder_nr = 1; extruder_nr < extruder_count; extruder_nr++)
+        {
+            if (max_object_height_per_extruder[extruder_nr] > max_object_height_per_extruder[extruder_max_object_height])
+            {
+                extruder_max_object_height = extruder_nr;
+            }
+        }
+        int extruder_second_max_object_height = -1;
+        for (int extruder_nr = 0; extruder_nr < extruder_count; extruder_nr++)
+        {
+            if (extruder_nr == extruder_max_object_height) { continue; }
+            if (extruder_second_max_object_height == -1 || max_object_height_per_extruder[extruder_nr] > max_object_height_per_extruder[extruder_second_max_object_height])
+            {
+                extruder_second_max_object_height = extruder_nr;
+            }
+        }
+        if (extruder_second_max_object_height < 0)
+        {
+            storage.max_object_height_second_to_last_extruder = -1;
+        }
+        else 
+        {
+            storage.max_object_height_second_to_last_extruder = max_object_height_per_extruder[extruder_second_max_object_height];
+        }
+    }
+       
+}
+
+void PrimeTower::generateGroundpoly(SliceDataStorage& storage) 
+{
+    PolygonRef p = storage.primeTower.ground_poly.newPoly();
+    int tower_size = storage.getSettingInMicrons("prime_tower_size");
     int tower_distance = 0; 
     int x = storage.getSettingInMicrons("prime_tower_position_x"); // storage.model_max.x
     int y = storage.getSettingInMicrons("prime_tower_position_y"); // storage.model_max.y
@@ -45,228 +111,198 @@ void PrimeTower::generateGroundpoly(const SliceDataStorage& storage)
     p.add(Point(x + tower_distance, y + tower_distance + tower_size));
     p.add(Point(x + tower_distance - tower_size, y + tower_distance + tower_size));
     p.add(Point(x + tower_distance - tower_size, y + tower_distance));
-    middle = Point(x - tower_size / 2, y + tower_size / 2);
 
-    if (is_hollow)
-    {
-        ground_poly = ground_poly.difference(ground_poly.offset(-prime_tower_wall_thickness));
-    }
-
-    post_wipe_point = Point(x + tower_distance - tower_size / 2, y + tower_distance + tower_size / 2);
+    storage.wipePoint = Point(x + tower_distance - tower_size / 2, y + tower_distance + tower_size / 2);   
 }
 
-void PrimeTower::generatePaths(const SliceDataStorage& storage)
+void PrimeTower::generatePaths(SliceDataStorage& storage, unsigned int total_layers)
 {
-    enabled &= storage.max_print_height_second_to_last_extruder >= 0; //Maybe it turns out that we don't need a prime tower after all because there are no layer switches.
-    if (enabled)
+    if (storage.max_object_height_second_to_last_extruder >= 0 && storage.getSettingBoolean("prime_tower_enable"))
     {
-        generatePaths_denseInfill(storage);
-        generateWipeLocations(storage);
+        generatePaths3(storage);
     }
 }
-
-void PrimeTower::generatePaths_denseInfill(const SliceDataStorage& storage)
+void PrimeTower::generatePaths_OLD(SliceDataStorage& storage, unsigned int total_layers)
 {
+    
+    if (storage.max_object_height_second_to_last_extruder >= 0 && storage.getSettingBoolean("prime_tower_enable"))
+    {
+        PolygonRef p = storage.primeTower.ground_poly.newPoly();
+        int tower_size = storage.getSettingInMicrons("prime_tower_size");
+        int tower_distance = 0; 
+        int x = storage.getSettingInMicrons("prime_tower_position_x"); // storage.model_max.x
+        int y = storage.getSettingInMicrons("prime_tower_position_y"); // storage.model_max.y
+        p.add(Point(x + tower_distance, y + tower_distance));
+        p.add(Point(x + tower_distance, y + tower_distance + tower_size));
+        p.add(Point(x + tower_distance - tower_size, y + tower_distance + tower_size));
+        p.add(Point(x + tower_distance - tower_size, y + tower_distance));
+
+        storage.wipePoint = Point(x + tower_distance - tower_size / 2, y + tower_distance + tower_size / 2);
+    }
+}
+    
+    
+void PrimeTower::generatePaths2(SliceDataStorage& storage) // half baked attempt at spiral shaped prime tower pattern
+{
+//     extruder_count = storage.getSettingAsCount("machine_extruder_count");
+//     
+//     int64_t line_dists[extruder_count + 1]; // distance between the lines of different extruders, and half the line dist for beginning and ending
+//     int64_t total_width = 0;
+//     {
+//         int64_t last_line_width = 0;
+//         for (int extr = 0; extr < extruder_count; extr++)
+//         {
+//             int64_t line_width = config_per_extruder[extr].getLineWidth();
+//             line_dists[extr] = (line_width + last_line_width) / 2;
+//             total_width += line_width;
+//             last_line_width = line_width;
+//         }
+//         line_dists[extruder_count] = last_line_width / 2;
+//     }
+//     
+    
+    
+}
+
+void PrimeTower::generatePaths3(SliceDataStorage& storage)
+{
+        
     int n_patterns = 2; // alternating patterns between layers
     int infill_overlap = 60; // so that it can't be zero; EDIT: wtf?
     int extra_infill_shift = 0;
-
+    
+    generateGroundpoly(storage);
+    
     int64_t z = 0; // (TODO) because the prime tower stores the paths for each extruder for once instead of generating each layer, we don't know the z position
-
+    
     for (int extruder = 0; extruder < extruder_count; extruder++)
     {
         int line_width = storage.meshgroup->getExtruderTrain(extruder)->getSettingInMicrons("prime_tower_line_width");
         patterns_per_extruder.emplace_back(n_patterns);
-        std::vector<ExtrusionMoves>& patterns = patterns_per_extruder.back();
-        patterns.resize(n_patterns);
+        std::vector<Polygons>& patterns = patterns_per_extruder.back();
         for (int pattern_idx = 0; pattern_idx < n_patterns; pattern_idx++)
         {
-            patterns[pattern_idx].polygons = ground_poly.offset(-line_width / 2);
-            Polygons& result_lines = patterns[pattern_idx].lines;
-            int outline_offset = -line_width;
+            Polygons result_polygons; // should remain empty, since we generate lines pattern!
+            int outline_offset = -line_width/2;
             int line_distance = line_width;
             double fill_angle = 45 + pattern_idx * 90;
-            Polygons result_polygons; // should remain empty, since we generate lines pattern!
+            Polygons& result_lines = patterns[pattern_idx];
             Infill infill_comp(EFillMethod::LINES, ground_poly, outline_offset, line_width, line_distance, infill_overlap, fill_angle, z, extra_infill_shift);
             infill_comp.generate(result_polygons, result_lines);
         }
     }
 }
 
+    
 
-void PrimeTower::addToGcode(const SliceDataStorage& storage, LayerPlan& gcodeLayer, const GCodeExport& gcode, const int layer_nr, const int prev_extruder, const int new_extruder) const
+void PrimeTower::addToGcode(SliceDataStorage& storage, GCodePlanner& gcodeLayer, GCodeExport& gcode, int layer_nr, int prev_extruder, bool prime_tower_dir_outward, bool wipe, int* last_prime_tower_poly_printed)
 {
-    if (!enabled)
+    if (!( storage.max_object_height_second_to_last_extruder >= 0 && storage.getSettingInMicrons("prime_tower_size") > 0) )
     {
         return;
     }
-    if (gcodeLayer.getPrimeTowerIsPlanned())
+    bool prime_tower_added = false;
+    for (int extruder = 0; extruder <  storage.meshgroup->getExtruderCount() && !prime_tower_added; extruder++)
+    {
+        prime_tower_added = last_prime_tower_poly_printed[extruder] == int(layer_nr);
+    }
+    if (prime_tower_added)
     { // don't print the prime tower if it has been printed already
         return;
     }
+    
+    if (prev_extruder == gcodeLayer.getExtruder())
+    {
+        wipe = false;
+    }
+    addToGcode3(storage, gcodeLayer, gcode, layer_nr, prev_extruder, prime_tower_dir_outward, wipe, last_prime_tower_poly_printed);
+}
 
-    if (layer_nr > storage.max_print_height_second_to_last_extruder + 1)
+void PrimeTower::addToGcode3(SliceDataStorage& storage, GCodePlanner& gcodeLayer, GCodeExport& gcode, int layer_nr, int prev_extruder, bool prime_tower_dir_outward, bool wipe, int* last_prime_tower_poly_printed)
+{
+    if (layer_nr > storage.max_object_height_second_to_last_extruder + 1)
     {
         return;
     }
+    
+    int new_extruder = gcodeLayer.getExtruder();
 
-    bool pre_wipe = storage.meshgroup->getExtruderTrain(new_extruder)->getSettingBoolean("dual_pre_wipe");
-    bool post_wipe = storage.meshgroup->getExtruderTrain(prev_extruder)->getSettingBoolean("prime_tower_wipe_enabled");
+    
+    Polygons& pattern = patterns_per_extruder[new_extruder][layer_nr % 2];
 
-    if (prev_extruder == new_extruder)
+    
+    GCodePathConfig& config = config_per_extruder[new_extruder];
+    int start_idx = 0; // TODO: figure out which idx is closest to the far right corner
+    gcodeLayer.addPolygon(ground_poly.back(), start_idx, &config);
+    gcodeLayer.addLinesByOptimizer(pattern, &config, SpaceFillType::Lines);
+    
+    last_prime_tower_poly_printed[new_extruder] = layer_nr;
+
+    if (CommandSocket::isInstantiated())
     {
-        pre_wipe = false;
-        post_wipe = false;
-    }
-    // pre-wipe:
-    if (pre_wipe)
-    {
-        preWipe(storage, gcodeLayer, layer_nr, new_extruder);
+        CommandSocket::getInstance()->sendPolygons(PrintFeatureType::Support, layer_nr, pattern, config.getLineWidth());
     }
 
-    addToGcode_denseInfill(gcodeLayer, layer_nr, new_extruder);
-
-    // post-wipe:
-    if (post_wipe)
+    if (wipe)
     { //Make sure we wipe the old extruder on the prime tower.
-        gcodeLayer.addTravel(post_wipe_point - gcode.getExtruderOffset(prev_extruder) + gcode.getExtruderOffset(new_extruder));
+        gcodeLayer.addTravel(storage.wipePoint - gcode.getExtruderOffset(prev_extruder) + gcode.getExtruderOffset(new_extruder));
     }
-
-    gcodeLayer.setPrimeTowerIsPlanned();
 }
 
-void PrimeTower::addToGcode_denseInfill(LayerPlan& gcode_layer, const int layer_nr, const int extruder_nr) const
+void PrimeTower::addToGcode_OLD(SliceDataStorage& storage, GCodePlanner& gcodeLayer, GCodeExport& gcode, int layer_nr, int prev_extruder, bool prime_tower_dir_outward, bool wipe, int* last_prime_tower_poly_printed)
 {
-    const ExtrusionMoves& pattern = patterns_per_extruder[extruder_nr][((layer_nr % 2) + 2) % 2]; // +2) %2 to handle negative layer numbers
-
-    const GCodePathConfig& config = gcode_layer.configs_storage.prime_tower_config_per_extruder[extruder_nr];
-
-    gcode_layer.addPolygonsByOptimizer(pattern.polygons, &config);
-    gcode_layer.addLinesByOptimizer(pattern.lines, &config, SpaceFillType::Lines);
-}
-
-Point PrimeTower::getLocationBeforePrimeTower(const SliceDataStorage& storage) const
-{
-    Point ret(0, 0);
-    int absolute_starting_points = 0;
-    for (int extruder_nr = 0; extruder_nr < storage.meshgroup->getExtruderCount(); extruder_nr++)
+    if (layer_nr > storage.max_object_height_second_to_last_extruder + 1)
     {
-        ExtruderTrain& train = *storage.meshgroup->getExtruderTrain(0);
-        if (train.getSettingBoolean("machine_extruder_start_pos_abs"))
-        {
-            ret += Point(train.getSettingInMicrons("machine_extruder_start_pos_x"), train.getSettingInMicrons("machine_extruder_start_pos_y"));
-            absolute_starting_points++;
-        }
+        return;
     }
-    if (absolute_starting_points > 0)
-    { // take the average over all absolute starting positions
-        ret /= absolute_starting_points;
-    }
-    else
-    { // use the middle of the bed
-        if (!storage.getSettingBoolean("machine_center_is_zero"))
-        {
-            ret = Point(storage.getSettingInMicrons("machine_width"), storage.getSettingInMicrons("machine_depth")) / 2;
-        }
-        // otherwise keep (0, 0)
-    }
-    return ret;
-}
+    
+    int new_extruder = gcodeLayer.getExtruder();
 
-void PrimeTower::generateWipeLocations(const SliceDataStorage& storage)
-{
-    wipe_from_middle = is_hollow;
-    // only wipe from the middle of the prime tower if we have a z hop already on the first move after the layer switch
-    for (int extruder_nr = 0; extruder_nr < storage.meshgroup->getExtruderCount(); extruder_nr++)
-    {
-        const ExtruderTrain& train = *storage.meshgroup->getExtruderTrain(extruder_nr);
-        wipe_from_middle &= train.getSettingBoolean("retraction_hop_enabled") 
-                        && (!train.getSettingBoolean("retraction_hop_only_when_collides") || train.getSettingBoolean("retraction_hop_after_extruder_switch"));
-    }
-
-    PolygonsPointIndex segment_start; // from where to start the sequence of wipe points
-    PolygonsPointIndex segment_end; // where to end the sequence of wipe points
-
-    if (wipe_from_middle)
-    {
-        // take the same start as end point so that the whole poly os covered.
-        // find the inner polygon.
-        segment_start = segment_end = PolygonUtils::findNearestVert(middle, ground_poly);
-    }
-    else
-    {
-        // take the closer corner of the wipe tower and generate wipe locations on that side only:
-        //
-        //     |
-        //     |
-        //     +-----
-        //  .
-        //  ^ nozzle switch location
-        Point from = getLocationBeforePrimeTower(storage);
-
-        // find the single line segment closest to [from] pointing most toward [from]
-        PolygonsPointIndex closest_vert = PolygonUtils::findNearestVert(from, ground_poly);
-        PolygonsPointIndex prev = closest_vert.prev();
-        PolygonsPointIndex next = closest_vert.next();
-        int64_t prev_dot_score = dot(from - closest_vert.p(), turn90CCW(prev.p() - closest_vert.p()));
-        int64_t next_dot_score = dot(from - closest_vert.p(), turn90CCW(closest_vert.p() - next.p()));
-        if (prev_dot_score > next_dot_score)
-        {
-            segment_start = prev;
-            segment_end = closest_vert;
-        }
+    int64_t offset = -config_per_extruder[new_extruder].getLineWidth(); 
+    if (layer_nr > 0)
+        offset *= 2;
+    
+    //If we changed extruder, print the wipe/prime tower for this nozzle;
+    std::vector<Polygons> insets;
+    { // generate polygons
+        if ((layer_nr % 2) == 1)
+            insets.push_back(storage.primeTower.ground_poly.offset(offset / 2));
         else
+            insets.push_back(storage.primeTower.ground_poly);
+        while(true)
         {
-            segment_start = closest_vert;
-            segment_end = next;
+            Polygons new_inset = insets[insets.size() - 1].offset(offset);
+            if (new_inset.size() < 1)
+                break;
+            insets.push_back(new_inset);
         }
     }
-
-    PolygonUtils::spreadDots(segment_start, segment_end, number_of_pre_wipe_locations, pre_wipe_locations);
-}
-
-void PrimeTower::preWipe(const SliceDataStorage& storage, LayerPlan& gcode_layer, const int layer_nr, const int extruder_nr) const
-{
-    int current_pre_wipe_location_idx = (pre_wipe_location_skip * layer_nr) % number_of_pre_wipe_locations;
-    const ClosestPolygonPoint wipe_location = pre_wipe_locations[current_pre_wipe_location_idx];
-
-    ExtruderTrain& train = *storage.meshgroup->getExtruderTrain(extruder_nr);
-    const int inward_dist = train.getSettingInMicrons("machine_nozzle_size") * 3 / 2 ;
-    const int start_dist = train.getSettingInMicrons("machine_nozzle_size") * 2;
-    const Point end = PolygonUtils::moveInsideDiagonally(wipe_location, inward_dist);
-    const Point outward_dir = wipe_location.location - end;
-    const Point start = wipe_location.location + normal(outward_dir, start_dist);
-    if (wipe_from_middle)
+    
+    
+    for(unsigned int n=0; n<insets.size(); n++)
     {
-        // for hollow wipe tower:
-        // start from above
-        // go to wipe start
-        // go to the Z height of the previous/current layer
-        // wipe
-        // go to normal layer height (automatically on the next extrusion move)...
-        GCodePath& toward_middle = gcode_layer.addTravel(middle);
-        toward_middle.perform_z_hop = true;
-        gcode_layer.forceNewPathStart();
-        GCodePath& toward_wipe_start = gcode_layer.addTravel_simple(start);
-        toward_wipe_start.perform_z_hop = false;
-        toward_wipe_start.retract = true;
+        GCodePathConfig& config = config_per_extruder[new_extruder];
+        gcodeLayer.addPolygonsByOptimizer(insets[(prime_tower_dir_outward)? insets.size() - 1 - n : n], &config);
     }
-    else
-    {
-        gcode_layer.addTravel(start);
+    last_prime_tower_poly_printed[new_extruder] = layer_nr;
+    
+    if (wipe)
+    { //Make sure we wipe the old extruder on the prime tower.
+        gcodeLayer.addTravel(storage.wipePoint - gcode.getExtruderOffset(prev_extruder) + gcode.getExtruderOffset(new_extruder));
     }
-    float flow = 0.0001; // force this path being interpreted as an extrusion path, so that no Z hop will occur (TODO: really separately handle travel and extrusion moves)
-    gcode_layer.addExtrusionMove(end, &gcode_layer.configs_storage.prime_tower_config_per_extruder[extruder_nr], SpaceFillType::None, flow);
-}
-
-void PrimeTower::subtractFromSupport(SliceDataStorage& storage)
-{
-    const Polygons outside_polygon = ground_poly.getOutsidePolygons();
-    for(size_t layer = 0; layer <= (size_t)storage.max_print_height_second_to_last_extruder + 1 && layer < storage.support.supportLayers.size(); layer++)
-    {
-        storage.support.supportLayers[layer].supportAreas = storage.support.supportLayers[layer].supportAreas.difference(outside_polygon);
-    }
-}
-
-
-}//namespace cura
+};
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+}//namespace cura

src/PrimeTower.h

@@ -1,152 +1,63 @@
-//Copyright (c) 2016 Ultimaker B.V.
-//CuraEngine is released under the terms of the AGPLv3 or higher.
-
 #ifndef PRIME_TOWER_H
 #define PRIME_TOWER_H
 
-#include <vector>
-
 #include "GCodePathConfig.h"
 #include "MeshGroup.h"
 #include "utils/polygon.h" // Polygons
-#include "utils/polygonUtils.h"
 
 namespace cura 
 {
 
     
 class SliceDataStorage;
-class LayerPlan;
+class GCodePlanner;
 class GCodeExport;
 
-/*!
- * Class for everything to do with the prime tower:
- * - generating the areas
- * - checking up till which height the prime tower has to be printed
- * - generating the paths and adding them to the layer plan
- */
+typedef std::vector<IntPoint> PolyLine;
+
 class PrimeTower
 {
 private:
-    struct ExtrusionMoves
+    int extruder_count;
+    std::vector<GCodePathConfig> config_per_extruder;
+
+    class WallInfill
     {
-        Polygons polygons;
-        Polygons lines;
+        
     };
-    int extruder_count; //!< number of extruders
-
-    bool is_hollow; //!< Whether the prime tower is hollow
-
-    bool wipe_from_middle; //!< Whether to wipe on the inside of the hollow prime tower
-    Point middle; //!< The middle of the prime tower
-
-    Point post_wipe_point; //!< location to post-wipe the unused nozzle off on
-
-    std::vector<ClosestPolygonPoint> pre_wipe_locations; //!< The differernt locations where to pre-wipe the active nozzle
-    const unsigned int pre_wipe_location_skip = 13; //!< How big the steps are when stepping through \ref PrimeTower::wipe_locations
-    const unsigned int number_of_pre_wipe_locations = 21; //!< The required size of \ref PrimeTower::wipe_locations
-    // note that the above are two consecutive numbers in the Fibonacci sequence
-
 public:
-    bool enabled; //!< Whether the prime tower is enabled.
-    Polygons ground_poly; //!< The outline of the prime tower to be used for each layer
-
-    std::vector<std::vector<ExtrusionMoves>> patterns_per_extruder; //!< for each extruder a vector of patterns to alternate between, over the layers
-
-    /*!
-     * \brief Creates a prime tower instance that will determine where and how
-     * the prime tower gets printed.
-     *
-     * \param storage A storage where it retrieves the prime tower settings.
-     */
-    PrimeTower(const SliceDataStorage& storage);
-
-    /*!
-     * Generate the prime tower area to be used on each layer
-     * 
-     * Fills \ref PrimeTower::ground_poly and sets \ref PrimeTower::middle
-     * 
-     * \param storage Where to retrieve prime tower settings from
-     */
-    void generateGroundpoly(const SliceDataStorage& storage);
+    void initConfigs(MeshGroup* meshgroup, std::vector<RetractionConfig>& retraction_config_per_extruder);
+    void setConfigs(MeshGroup* configs, int layer_thickness);
+    
+    Polygons ground_poly;
+    
+    std::vector<PolyLine> extruder_paths;
+    
+    
+    void generateGroundpoly(SliceDataStorage& storage);
 
+    std::vector<std::vector<Polygons>> patterns_per_extruder; //!< for each extruder a vector of patterns to alternate between, over the layers
+    
+    void generatePaths3(SliceDataStorage& storage);
+    
+    void generatePaths2(SliceDataStorage& storage);
     /*!
      * Generate the area where the prime tower should be.
      * 
-     * \param storage where to get settings from
+     * \param storage Input and Output parameter: fetches the outline information (see SliceLayerPart::outline) and generates the other reachable field of the \p storage
      * \param total_layers The total number of layers 
      */
-    void generatePaths(const SliceDataStorage& storage);
+    void generatePaths(SliceDataStorage& storage, unsigned int total_layers);
+    void generatePaths_OLD(SliceDataStorage& storage, unsigned int total_layers);
 
-    /*!
-     * Add path plans for the prime tower to the \p gcode_layer
-     * 
-     * \param storage where to get settings from; where to get the maximum height of the prime tower from
-     * \param[in,out] gcode_layer Where to get the current extruder from; where to store the generated layer paths
-     * \param layer_nr The layer for which to generate the prime tower paths
-     * \param prev_extruder The previous extruder with which paths were planned; from which extruder a switch was made
-     * \param new_extruder The switched to extruder with which the prime tower paths should be generated.
-     */
-    void addToGcode(const SliceDataStorage& storage, LayerPlan& gcode_layer, const GCodeExport& gcode, const int layer_nr, const int prev_extruder, const int new_extruder) const;
+    void computePrimeTowerMax(SliceDataStorage& storage);
+    
+    PrimeTower();
 
-    /*!
-     * \brief Subtract the prime tower from the support areas in storage.
-     *
-     * \param storage The storage where to find the support from which to
-     * subtract a prime tower.
-     */
-    void subtractFromSupport(SliceDataStorage& storage);
+    void addToGcode(SliceDataStorage& storage, GCodePlanner& gcodeLayer, GCodeExport& gcode, int layer_nr, int prev_extruder, bool prime_tower_dir_outward, bool wipe, int* last_prime_tower_poly_printed);
+    void addToGcode_OLD(SliceDataStorage& storage, GCodePlanner& gcodeLayer, GCodeExport& gcode, int layer_nr, int prev_extruder, bool prime_tower_dir_outward, bool wipe, int* last_prime_tower_poly_printed);
+    void addToGcode3(SliceDataStorage& storage, GCodePlanner& gcodeLayer, GCodeExport& gcode, int layer_nr, int prev_extruder, bool prime_tower_dir_outward, bool wipe, int* last_prime_tower_poly_printed);
 
-private:
-
-    /*!
-     * Find an approriate representation for the point representing the location before going to the prime tower
-     * 
-     * \warning This is not the actual position each time before the wipe tower
-     * 
-     * \param storage where to get settings from
-     * \return that location
-     */
-    Point getLocationBeforePrimeTower(const SliceDataStorage& storage) const;
-
-    /*!
-     * \param storage where to get settings from
-     * Depends on ground_poly being generated
-     */
-    void generateWipeLocations(const SliceDataStorage& storage);
-
-    /*!
-     * \see WipeTower::generatePaths
-     * 
-     * Generate the extrude paths for each extruder on even and odd layers
-     * Fill the ground poly with dense infill.
-     * 
-     * \param storage where to get settings from
-     * \param total_layers The total number of layers 
-     */
-    void generatePaths_denseInfill(const SliceDataStorage& storage);
-
-    /*!
-     * \see PrimeTower::addToGcode
-     *
-     * Add path plans for the prime tower to the \p gcode_layer
-     *
-     * \param[in,out] gcode_layer Where to get the current extruder from; where to store the generated layer paths
-     * \param layer_nr The layer for which to generate the prime tower paths
-     * \param extruder The extruder we just switched to, with which the prime
-     * tower paths should be drawn.
-     */
-    void addToGcode_denseInfill(LayerPlan& gcode_layer, const int layer_nr, const int extruder) const;
-
-    /*!
-     * Plan the moves for wiping the current nozzles oozed material before starting to print the prime tower.
-     * 
-     * \param storage where to get settings from
-     * \param[out] gcode_layer where to add the planned paths for wiping
-     * \param layer_nr The layer number of the \p gcode_layer
-     * \param extruder_nr The current extruder
-     */
-    void preWipe(const SliceDataStorage& storage, LayerPlan& gcode_layer, const int layer_nr, const int extruder_nr) const;
 };
 
 

src/PrintFeature.h

@@ -4,19 +4,18 @@
 namespace cura
 {
 
-enum class PrintFeatureType: unsigned char
+enum class PrintFeatureType
 {
-    NoneType, // used to mark unspecified jumps in polygons. libArcus depends on it
+    NoneType, // unused, but libArcus depends on it
     OuterWall,
     InnerWall,
     Skin,
     Support,
-    SkirtBrim,
+    Skirt,
     Infill,
     SupportInfill,
     MoveCombing,
-    MoveRetraction,
-    SupportInterface
+    MoveRetraction
 };
 
 
@@ -24,4 +23,4 @@ enum class PrintFeatureType: unsigned char
 
 } // namespace cura
 
-#endif // PRINT_FEATURE
+#endif // PRINT_FEATURE

src/SkirtBrim.cpp

@@ -1,198 +0,0 @@
-//Copyright (C) 2013 David Braam
-//Copyright (c) 2016 Ultimaker B.V.
-//CuraEngine is released under the terms of the AGPLv3 or higher.
-
-#include "SkirtBrim.h"
-#include "support.h"
-
-namespace cura 
-{
-
-void SkirtBrim::getFirstLayerOutline(SliceDataStorage& storage, const unsigned int primary_line_count, const int primary_extruder_skirt_brim_line_width, const bool is_skirt, const bool outside_only, Polygons& first_layer_outline)
-{
-    bool external_only = is_skirt; // whether to include holes or not
-    const int layer_nr = 0;
-    if (is_skirt)
-    {
-        const bool include_helper_parts = true;
-        first_layer_outline = storage.getLayerOutlines(layer_nr, include_helper_parts, external_only);
-        first_layer_outline = first_layer_outline.approxConvexHull();
-    }
-    else
-    { // add brim underneath support by removing support where there's brim around the model
-        const bool include_helper_parts = false; // include manually below
-        first_layer_outline = storage.getLayerOutlines(layer_nr, include_helper_parts, external_only);
-        first_layer_outline = first_layer_outline.unionPolygons(); //To guard against overlapping outlines, which would produce holes according to the even-odd rule.
-        Polygons first_layer_empty_holes;
-        if (outside_only)
-        {
-            first_layer_empty_holes = first_layer_outline.getEmptyHoles();
-            first_layer_outline = first_layer_outline.removeEmptyHoles();
-        }
-        if (storage.support.generated && primary_line_count > 0)
-        { // remove model-brim from support
-            // avoid gap in the middle
-            //    V
-            //  +---+     +----+
-            //  |+-+|     |+--+|
-            //  || ||     ||[]|| > expand to fit an extra brim line
-            //  |+-+|     |+--+|
-            //  +---+     +----+ 
-            Polygons model_brim_covered_area = first_layer_outline.offset(primary_extruder_skirt_brim_line_width * (primary_line_count + primary_line_count % 2), ClipperLib::jtRound); // always leave a gap of an even number of brim lines, so that it fits if it's generating brim from both sides
-            if (outside_only)
-            { // don't remove support within empty holes where no brim is generated.
-                model_brim_covered_area.add(first_layer_empty_holes);
-            }
-            SupportLayer& support_layer = storage.support.supportLayers[0];
-            support_layer.supportAreas = support_layer.supportAreas.difference(model_brim_covered_area);
-            first_layer_outline.add(support_layer.supportAreas);
-            first_layer_outline.add(support_layer.skin);
-        }
-        if (storage.primeTower.enabled)
-        {
-            first_layer_outline.add(storage.primeTower.ground_poly); // don't remove parts of the prime tower, but make a brim for it
-        }
-    }
-    constexpr int join_distance = 20;
-    first_layer_outline = first_layer_outline.offset(join_distance).offset(-join_distance); // merge adjacent models into single polygon
-    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)
-{
-
-    int offset_distance = start_distance - primary_extruder_skirt_brim_line_width / 2;
-    for (unsigned int skirt_brim_number = 0; skirt_brim_number < primary_line_count; skirt_brim_number++)
-    {
-        offset_distance += primary_extruder_skirt_brim_line_width;
-
-        Polygons outer_skirt_brim_line = first_layer_outline.offset(offset_distance, ClipperLib::jtRound);
-
-        //Remove small inner skirt and brim holes. Holes have a negative area, remove anything smaller then 100x extrusion "area"
-        for (unsigned int n = 0; n < outer_skirt_brim_line.size(); n++)
-        {
-            double area = outer_skirt_brim_line[n].area();
-            if (area < 0 && area > -primary_extruder_skirt_brim_line_width * primary_extruder_skirt_brim_line_width * 100)
-            {
-                outer_skirt_brim_line.remove(n--);
-            }
-        }
-
-        skirt_brim_primary_extruder.add(outer_skirt_brim_line);
-
-        int length = skirt_brim_primary_extruder.polygonLength();
-        if (skirt_brim_number + 1 >= primary_line_count && length > 0 && length < primary_extruder_minimal_length) //Make brim or skirt have more lines when total length is too small.
-        {
-            primary_line_count++;
-        }
-    }
-    return offset_distance;
-}
-
-void SkirtBrim::generate(SliceDataStorage& storage, int start_distance, unsigned int primary_line_count, bool outside_only)
-{
-    const bool is_skirt = start_distance > 0;
-
-    const int adhesion_extruder_nr = storage.getSettingAsIndex("adhesion_extruder_nr");
-    const ExtruderTrain* adhesion_extruder = storage.meshgroup->getExtruderTrain(adhesion_extruder_nr);
-    const int primary_extruder_skirt_brim_line_width = adhesion_extruder->getSettingInMicrons("skirt_brim_line_width");
-    const int64_t primary_extruder_minimal_length = adhesion_extruder->getSettingInMicrons("skirt_brim_minimal_length");
-
-    Polygons& skirt_brim_primary_extruder = storage.skirt_brim[adhesion_extruder_nr];
-
-    Polygons first_layer_outline;
-    getFirstLayerOutline(storage, primary_line_count, primary_extruder_skirt_brim_line_width, is_skirt, outside_only, first_layer_outline);
-
-    const bool has_ooze_shield = storage.oozeShield.size() > 0 && storage.oozeShield[0].size() > 0;
-    const bool has_draft_shield = storage.draft_protection_shield.size() > 0;
-
-    if (is_skirt && (has_ooze_shield || has_draft_shield))
-    { // make sure we don't generate skirt through draft / ooze shield
-        first_layer_outline = first_layer_outline.offset(start_distance - primary_extruder_skirt_brim_line_width / 2, ClipperLib::jtRound).unionPolygons(storage.draft_protection_shield);
-        if (has_ooze_shield)
-        {
-            first_layer_outline = first_layer_outline.unionPolygons(storage.oozeShield[0]);
-        }
-        first_layer_outline = first_layer_outline.approxConvexHull();
-        start_distance = primary_extruder_skirt_brim_line_width / 2;
-    }
-
-    int offset_distance = generatePrimarySkirtBrimLines(storage, start_distance, primary_line_count, primary_extruder_skirt_brim_line_width, primary_extruder_minimal_length, first_layer_outline, skirt_brim_primary_extruder);
-
-
-    // generate brim for ooze shield and draft shield
-    if (!is_skirt && (has_ooze_shield || has_draft_shield))
-    {
-        // generate areas where to make extra brim for the shields
-        // avoid gap in the middle
-        //    V
-        //  +---+     +----+
-        //  |+-+|     |+--+|
-        //  || ||     ||[]|| > expand to fit an extra brim line
-        //  |+-+|     |+--+|
-        //  +---+     +----+ 
-        const int64_t primary_skirt_brim_width = (primary_line_count + primary_line_count % 2) * primary_extruder_skirt_brim_line_width; // always use an even number, because we will fil the area from both sides
-
-        Polygons shield_brim;
-        if (has_ooze_shield)
-        {
-            shield_brim = storage.oozeShield[0].difference(storage.oozeShield[0].offset(-primary_skirt_brim_width - primary_extruder_skirt_brim_line_width));
-        }
-        if (has_draft_shield)
-        {
-            shield_brim = shield_brim.unionPolygons(storage.draft_protection_shield.difference(storage.draft_protection_shield.offset(-primary_skirt_brim_width - primary_extruder_skirt_brim_line_width)));
-        }
-        const Polygons outer_primary_brim = first_layer_outline.offset(offset_distance, ClipperLib::jtRound);
-        shield_brim = shield_brim.difference(outer_primary_brim.offset(primary_extruder_skirt_brim_line_width));
-
-        // generate brim within shield_brim
-        skirt_brim_primary_extruder.add(shield_brim);
-        while (shield_brim.size() > 0)
-        {
-            shield_brim = shield_brim.offset(-primary_extruder_skirt_brim_line_width);
-            skirt_brim_primary_extruder.add(shield_brim);
-        }
-
-        // update parameters to generate secondary skirt around
-        first_layer_outline = outer_primary_brim;
-        if (has_draft_shield)
-        {
-            first_layer_outline = first_layer_outline.unionPolygons(storage.draft_protection_shield);
-        }
-        if (has_ooze_shield)
-        {
-            first_layer_outline = first_layer_outline.unionPolygons(storage.oozeShield[0]);
-        }
-
-        offset_distance = 0;
-    }
-
-    { // process other extruders' brim/skirt (as one brim line around the old brim)
-        int last_width = primary_extruder_skirt_brim_line_width;
-        for (int extruder = 0; extruder < storage.meshgroup->getExtruderCount(); extruder++)
-        {
-            if (extruder == adhesion_extruder_nr || !storage.meshgroup->getExtruderTrain(extruder)->getIsUsed())
-            {
-                continue;
-            }
-            const ExtruderTrain* train = storage.meshgroup->getExtruderTrain(extruder);
-            const int width = train->getSettingInMicrons("skirt_brim_line_width");
-            const int64_t minimal_length = train->getSettingInMicrons("skirt_brim_minimal_length");
-            offset_distance += last_width / 2 + width/2;
-            last_width = width;
-            while (storage.skirt_brim[extruder].polygonLength() < minimal_length)
-            {
-                storage.skirt_brim[extruder].add(first_layer_outline.offset(offset_distance, ClipperLib::jtRound));
-                offset_distance += width;
-            }
-        }
-    }
-}
-
-}//namespace cura

src/SkirtBrim.h

@@ -1,59 +0,0 @@
-/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
-#ifndef SKIRT_BRIM_H
-#define SKIRT_BRIM_H
-
-#include "sliceDataStorage.h"
-
-namespace cura 
-{
-
-class SkirtBrim
-{
-public:
-    /*!
-     * Generate skirt or brim (depending on parameters).
-     * 
-     * When \p distance > 0 and \p count == 1 a skirt is generated, which has
-     * slightly different configuration. Otherwise, a brim is generated.
-     * 
-     * \param storage Storage containing the parts at the first layer.
-     * \param distance The distance of the first outset from the parts at the first
-     * layer.
-     * \param primary_line_count Number of outsets / brim lines of the primary extruder.
-     * \param outside_only Whether to only generate a brim on the outside, rather than also in holes
-     */
-    static void generate(SliceDataStorage& storage, int distance, unsigned int primary_line_count, bool outside_only);
-
-private:
-    /*!
-     * Get the reference outline of the first layer around which to generate the first brim/skirt line.
-     * 
-     * This function may change the support polygons in the first layer
-     * in order to meet criteria for putting brim around the model as well as around the support.
-     * 
-     * \param storage Storage containing the parts at the first layer.
-     * \param primary_line_count Number of outsets / brim lines of the primary extruder.
-     * \param primary_extruder_skirt_brim_line_width Line widths of the initial skirt/brim lines
-     * \param is_skirt Whether a skirt is being generated vs a brim
-     * \param outside_only Whether to only generate a brim on the outside, rather than also in holes
-     * \param[out] first_layer_outline The resulting reference polygons
-     */
-    static void getFirstLayerOutline(SliceDataStorage& storage, const unsigned int primary_line_count, const int primary_extruder_skirt_brim_line_width, const bool is_skirt, const bool outside_only, Polygons& first_layer_outline);
-
-    /*!
-     * Generate the skirt/brim lines around the model
-     * 
-     * \param storage Storage containing the parts at the first layer.
-     * \param start_distance The distance of the first outset from the parts at the first
-     * \param primary_line_count Number of outsets / brim lines of the primary extruder.
-     * \param primary_extruder_skirt_brim_line_width Line widths of the initial skirt/brim lines
-     * \param primary_extruder_minimal_length The minimal total length of the skirt/brim lines of the primary extruder
-     * \param first_layer_outline The reference polygons from which to offset outward to generate skirt/brim lines
-     * \param[out] skirt_brim_primary_extruder Where to store the resulting brim/skirt lines in
-     * \return The offset of the last brim/skirt line from the reference polygon \p first_layer_outline
-     */
-    static int 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);
-};
-}//namespace cura
-
-#endif //SKIRT_BRIM_H

src/WallsComputation.cpp

@@ -12,12 +12,6 @@ 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)
@@ -44,7 +38,6 @@ void WallsComputation::generateInsets(SliceLayerPart* part)
         
         //Finally optimize all the polygons. Every point removed saves time in the long run.
         part->insets[i].simplify();
-        part->insets[i].removeDegenerateVerts();
         if (i == 0)
         {
             if (recompute_outline_based_on_outer_wall)
@@ -64,12 +57,6 @@ 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

@@ -19,7 +19,7 @@ void Weaver::weave(MeshGroup* meshgroup)
 
     int layer_count = (maxz - initial_layer_thickness) / connectionHeight + 1;
 
-    std::cerr << "Layer count: " << layer_count << "\n";
+    DEBUG_SHOW(layer_count);
 
     std::vector<cura::Slicer*> slicerList;
 
@@ -42,7 +42,7 @@ void Weaver::weave(MeshGroup* meshgroup)
         }
         if (starting_layer_idx > 0)
         {
-            logWarning("First %i layers are empty!\n", starting_layer_idx);
+            logError("First %i layers are empty!\n", starting_layer_idx);
         }
     }
     
@@ -53,7 +53,8 @@ void Weaver::weave(MeshGroup* meshgroup)
         for (cura::Slicer* slicer : slicerList)
             wireFrame.bottom_outline.add(slicer->layers[starting_layer_idx].polygons);
         
-        CommandSocket::sendPolygons(PrintFeatureType::OuterWall, /*0,*/ wireFrame.bottom_outline, 1);
+        if (CommandSocket::isInstantiated())
+            CommandSocket::getInstance()->sendPolygons(PrintFeatureType::OuterWall, 0, wireFrame.bottom_outline, 1);
         
         if (slicerList.empty()) //Wait, there is nothing to slice.
         {
@@ -84,8 +85,10 @@ void Weaver::weave(MeshGroup* meshgroup)
 
             chainify_polygons(parts1, starting_point_in_layer, chainified, false);
             
-            CommandSocket::sendPolygons(PrintFeatureType::OuterWall, /*layer_idx - starting_layer_idx,*/ chainified, 1);
-
+            if (CommandSocket::isInstantiated())
+            {
+                CommandSocket::getInstance()->sendPolygons(PrintFeatureType::OuterWall, layer_idx - starting_layer_idx, chainified, 1);
+            }
             if (chainified.size() > 0)
             {
                 if (starting_z == -1) starting_z = slicerList[0]->layers[layer_idx-1].z;
@@ -324,7 +327,7 @@ void Weaver::connections2moves(WeaveRoofPart& inset)
             WeaveConnectionSegment& segment = segments[idx];
             assert(segment.segmentType == WeaveSegmentType::UP);
             Point3 from = (idx == 0)? part.connection.from : segments[idx-1].to;
-            bool skipped = (segment.to - from).vSize2() < line_width * line_width;
+            bool skipped = (segment.to - from).vSize2() < extrusionWidth * extrusionWidth;
             if (skipped)
             {
                 unsigned int begin = idx;
@@ -333,11 +336,9 @@ void Weaver::connections2moves(WeaveRoofPart& inset)
                     WeaveConnectionSegment& segment = segments[idx];
                     assert(segments[idx].segmentType == WeaveSegmentType::UP);
                     Point3 from = (idx == 0)? part.connection.from : segments[idx-1].to;
-                    bool skipped = (segment.to - from).vSize2() < line_width * line_width;
+                    bool skipped = (segment.to - from).vSize2() < extrusionWidth * extrusionWidth;
                     if (!skipped) 
-                    {
                         break;
-                    }
                 }
                 int end = idx - ((include_half_of_last_down)? 2 : 1);
                 if (idx >= segments.size())
@@ -387,9 +388,11 @@ void Weaver::connect(Polygons& parts0, int z0, Polygons& parts1, int z1, WeaveCo
 
 void Weaver::chainify_polygons(Polygons& parts1, Point start_close_to, Polygons& result, bool include_last)
 {
+    
+        
     for (unsigned int prt = 0 ; prt < parts1.size(); prt++)
     {
-        ConstPolygonRef upperPart = parts1[prt];
+        const PolygonRef upperPart = parts1[prt];
         
         ClosestPolygonPoint closestInPoly = PolygonUtils::findClosest(start_close_to, upperPart);
 
@@ -427,7 +430,7 @@ void Weaver::connect_polygons(Polygons& supporting, int z0, Polygons& supported,
  
     if (supporting.size() < 1)
     {
-        std::cerr << "lower layer has zero parts!\n";
+        DEBUG_PRINTLN("lower layer has zero parts!");
         return;
     }
     
@@ -439,7 +442,7 @@ void Weaver::connect_polygons(Polygons& supporting, int z0, Polygons& supported,
     for (unsigned int prt = 0 ; prt < supported.size(); prt++)
     {
         
-        ConstPolygonRef upperPart(supported[prt]);
+        const PolygonRef upperPart = supported[prt];
         
         
         parts.emplace_back(prt);
@@ -473,4 +476,16 @@ void Weaver::connect_polygons(Polygons& supporting, int z0, Polygons& supported,
 }
 
 
+
+
+
+
+
+
+
+
+
+
+
 }//namespace cura
+    

src/Weaver.h

@@ -12,6 +12,8 @@
 #include "utils/polygon.h"
 #include "utils/polygonUtils.h"
 
+#include "debug.h"
+
 namespace cura
 {
 
@@ -28,7 +30,7 @@ private:
     
     int initial_layer_thickness;
     int connectionHeight; 
-    int line_width;
+    int extrusionWidth;
     
     int roof_inset; 
     
@@ -45,7 +47,7 @@ public:
         initial_layer_thickness = getSettingInMicrons("layer_height_0");
         connectionHeight = getSettingInMicrons("wireframe_height"); 
         
-        line_width = getSettingInMicrons("wall_line_width_x");
+        extrusionWidth = getSettingInMicrons("wall_line_width_x");
         
         roof_inset = getSettingInMicrons("wireframe_roof_inset"); 
         nozzle_outer_diameter = getSettingInMicrons("machine_nozzle_tip_outer_diameter");      // ___       ___   .

src/Wireframe2gcode.cpp

@@ -3,12 +3,10 @@
 #include <cmath> // sqrt
 #include <fstream> // debug IO
 
-#include "utils/math.h"
-#include "utils/logoutput.h"
 #include "weaveDataStorage.h"
 #include "progress/Progress.h"
 
-#include "pathOrderOptimizer.h" //For skirt/brim.
+#include "pathOrderOptimizer.h" // for skirt
 
 namespace cura 
 {
@@ -18,9 +16,8 @@ void Wireframe2gcode::writeGCode()
 {
 
     gcode.preSetup(wireFrame.meshgroup);
-
-    const unsigned int start_extruder_nr = getSettingAsIndex("adhesion_extruder_nr"); // TODO: figure out how Wireframe works with dual extrusion
-    gcode.setInitialTemps(*wireFrame.meshgroup, start_extruder_nr);
+    
+    gcode.setInitialTemps(wireFrame.meshgroup);
     
     if (CommandSocket::getInstance())
         CommandSocket::getInstance()->beginGCode();
@@ -36,22 +33,23 @@ void Wireframe2gcode::writeGCode()
     {
         maxObjectHeight = wireFrame.layers.back().z1;
     }
-
-    gcode.setZ(initial_layer_thickness);
-
+    
     processSkirt();
-
+    
+            
     unsigned int total_layers = wireFrame.layers.size();
     gcode.writeLayerComment(0);
-    gcode.writeTypeComment(PrintFeatureType::SkirtBrim);
+    gcode.writeTypeComment(PrintFeatureType::Skirt);
 
+    gcode.setZ(initial_layer_thickness);
+    
     for (PolygonRef bottom_part : wireFrame.bottom_infill.roof_outlines)
     {
         if (bottom_part.size() == 0) continue;
         writeMoveWithRetract(bottom_part[bottom_part.size()-1]);
         for (Point& segment_to : bottom_part)
         {
-            gcode.writeMove(segment_to, speedBottom, extrusion_mm3_per_mm_flat);
+            gcode.writeMove(segment_to, speedBottom, extrusion_per_mm_flat);
         }
     }
     
@@ -67,7 +65,7 @@ void Wireframe2gcode::writeGCode()
                         writeMoveWithRetract(segment.to); 
                     } else 
                     {
-                        gcode.writeMove(segment.to, speedBottom, extrusion_mm3_per_mm_connection);
+                        gcode.writeMove(segment.to, speedBottom, extrusion_per_mm_connection); 
                     }
                 }   
             , 
@@ -77,7 +75,7 @@ void Wireframe2gcode::writeGCode()
                     else if (segment.segmentType == WeaveSegmentType::DOWN_AND_FLAT)
                         return; // do nothing
                     else 
-                        gcode.writeMove(segment.to, speedBottom, extrusion_mm3_per_mm_flat);
+                        gcode.writeMove(segment.to, speedBottom, extrusion_per_mm_flat); 
                 }
             );
     Progress::messageProgressStage(Progress::Stage::EXPORT, nullptr);
@@ -127,7 +125,7 @@ void Wireframe2gcode::writeGCode()
                         writeMoveWithRetract(segment.to);
                     } else 
                     {
-                        gcode.writeMove(segment.to, speedFlat, extrusion_mm3_per_mm_flat);
+                        gcode.writeMove(segment.to, speedFlat, extrusion_per_mm_flat);
                         gcode.writeDelay(flat_delay);
                     }
                 }
@@ -149,7 +147,7 @@ void Wireframe2gcode::writeGCode()
                         // do nothing
                     } else 
                     {   
-                        gcode.writeMove(segment.to, speedFlat, extrusion_mm3_per_mm_flat);
+                        gcode.writeMove(segment.to, speedFlat, extrusion_per_mm_flat);
                         gcode.writeDelay(flat_delay);
                     }
                 });
@@ -160,7 +158,7 @@ void Wireframe2gcode::writeGCode()
     
     gcode.setZ(maxObjectHeight);
     
-    gcode.writeRetraction(standard_retraction_config);
+    gcode.writeRetraction(&standard_retraction_config);
     
     
     gcode.updateTotalPrintTime();
@@ -181,7 +179,7 @@ void Wireframe2gcode::go_down(WeaveLayer& layer, WeaveConnectionPart& part, unsi
         gcode.writeMove(from, speedDown, 0);
     if (straight_first_when_going_down <= 0)
     {
-        gcode.writeMove(segment.to, speedDown, extrusion_mm3_per_mm_connection);
+        gcode.writeMove(segment.to, speedDown, extrusion_per_mm_connection);
     } else 
     {
         Point3& to = segment.to;
@@ -193,14 +191,14 @@ void Wireframe2gcode::go_down(WeaveLayer& layer, WeaveConnectionPart& part, unsi
         int64_t new_length = (up - from).vSize() + (to - up).vSize() + 5;
         int64_t orr_length = vec.vSize();
         double enlargement = new_length / orr_length;
-        gcode.writeMove(up, speedDown*enlargement, extrusion_mm3_per_mm_connection / enlargement);
-        gcode.writeMove(to, speedDown*enlargement, extrusion_mm3_per_mm_connection / enlargement);
+        gcode.writeMove(up, speedDown*enlargement, extrusion_per_mm_connection / enlargement);
+        gcode.writeMove(to, speedDown*enlargement, extrusion_per_mm_connection / enlargement);
     }
     gcode.writeDelay(bottom_delay);
     if (up_dist_half_speed > 0)
     {
         
-        gcode.writeMove(Point3(0,0,up_dist_half_speed) + gcode.getPosition(), speedUp / 2, extrusion_mm3_per_mm_connection * 2);
+        gcode.writeMove(Point3(0,0,up_dist_half_speed) + gcode.getPosition(), speedUp / 2, extrusion_per_mm_connection * 2);
     }
 }
 
@@ -209,7 +207,7 @@ void Wireframe2gcode::go_down(WeaveLayer& layer, WeaveConnectionPart& part, unsi
 void Wireframe2gcode::strategy_knot(WeaveLayer& layer, WeaveConnectionPart& part, unsigned int segment_idx)
 {
     WeaveConnectionSegment& segment = part.connection.segments[segment_idx];
-    gcode.writeMove(segment.to, speedUp, extrusion_mm3_per_mm_connection);
+    gcode.writeMove(segment.to, speedUp, extrusion_per_mm_connection);
     Point3 next_vector;
     if (segment_idx + 1 < part.connection.segments.size())
     {
@@ -259,8 +257,8 @@ void Wireframe2gcode::strategy_retract(WeaveLayer& layer, WeaveConnectionPart& p
         Point3 vec = to - from;
         Point3 lowering = vec * retract_hop_dist / 2 / vec.vSize();
         Point3 lower = to - lowering;
-        gcode.writeMove(lower, speedUp, extrusion_mm3_per_mm_connection);
-        gcode.writeRetraction(retraction_config);
+        gcode.writeMove(lower, speedUp, extrusion_per_mm_connection);
+        gcode.writeRetraction(&retraction_config);
         gcode.writeMove(to + lowering, speedUp, 0);
         gcode.writeDelay(top_retract_pause);
         if (after_retract_hop)
@@ -268,8 +266,8 @@ void Wireframe2gcode::strategy_retract(WeaveLayer& layer, WeaveConnectionPart& p
         
     } else 
     {
-        gcode.writeMove(to, speedUp, extrusion_mm3_per_mm_connection);
-        gcode.writeRetraction(retraction_config);
+        gcode.writeMove(to, speedUp, extrusion_per_mm_connection);
+        gcode.writeRetraction(&retraction_config);
         gcode.writeMove(to + Point3(0, 0, retract_hop_dist), speedFlat, 0);
         gcode.writeDelay(top_retract_pause);
         if (after_retract_hop)    
@@ -306,7 +304,7 @@ void Wireframe2gcode::strategy_compensate(WeaveLayer& layer, WeaveConnectionPart
     int64_t orrLength = (segment.to - from).vSize() + next_vector.vSize() + 1; // + 1 in order to avoid division by zero
     int64_t newLength = (newTop - from).vSize() + (next_point - newTop).vSize() + 1; // + 1 in order to avoid division by zero
     
-    gcode.writeMove(newTop, speedUp * newLength / orrLength, extrusion_mm3_per_mm_connection * orrLength / newLength);
+    gcode.writeMove(newTop, speedUp * newLength / orrLength, extrusion_per_mm_connection * orrLength / newLength);
 }
 void Wireframe2gcode::handle_segment(WeaveLayer& layer, WeaveConnectionPart& part, unsigned int segment_idx) 
 {
@@ -321,7 +319,7 @@ void Wireframe2gcode::handle_segment(WeaveLayer& layer, WeaveConnectionPart& par
             go_down(layer, part, segment_idx);
             break;
         case WeaveSegmentType::FLAT:
-            logWarning("Warning: flat piece in wire print connection.\n");
+            DEBUG_SHOW("flat piece in connection?!!?!");
             break;
         case WeaveSegmentType::UP:
             if (strategy == STRATEGY_KNOT)
@@ -385,12 +383,12 @@ void Wireframe2gcode::handle_roof_segment(WeaveRoofPart& inset, WeaveConnectionP
                     detoured -= next_dir;
                 }
                 
-                gcode.writeMove(detoured, speedUp, extrusion_mm3_per_mm_connection);
+                gcode.writeMove(detoured, speedUp, extrusion_per_mm_connection);
 
             }
             break;
         case WeaveSegmentType::DOWN:
-            gcode.writeMove(segment.to, speedDown, extrusion_mm3_per_mm_connection);
+            gcode.writeMove(segment.to, speedDown, extrusion_per_mm_connection);
             gcode.writeDelay(roof_outer_delay);
             break;
         case WeaveSegmentType::FLAT:
@@ -468,14 +466,14 @@ void Wireframe2gcode::writeFill(std::vector<WeaveRoofPart>& infill_insets, Polyg
 void Wireframe2gcode::writeMoveWithRetract(Point3 to)
 {
     if ((gcode.getPosition() - to).vSize2() >= nozzle_top_diameter * nozzle_top_diameter * 2 * 2)
-        gcode.writeRetraction(standard_retraction_config);
+        gcode.writeRetraction(&standard_retraction_config);
     gcode.writeMove(to, moveSpeed, 0);
 }
 
 void Wireframe2gcode::writeMoveWithRetract(Point to)
 {
     if (vSize2(gcode.getPositionXY() - to) >= nozzle_top_diameter * nozzle_top_diameter * 2 * 2)
-        gcode.writeRetraction(standard_retraction_config);
+        gcode.writeRetraction(&standard_retraction_config);
     gcode.writeMove(to, moveSpeed, 0);
 }
 
@@ -489,15 +487,16 @@ Wireframe2gcode::Wireframe2gcode(Weaver& weaver, GCodeExport& gcode, SettingsBas
     roof_inset = getSettingInMicrons("wireframe_roof_inset"); 
     
     filament_diameter = getSettingInMicrons("material_diameter");
-    line_width = getSettingInMicrons("wall_line_width_x");
+    extrusionWidth = getSettingInMicrons("wall_line_width_x");
     
     flowConnection = getSettingInPercentage("wireframe_flow_connection");
     flowFlat = getSettingInPercentage("wireframe_flow_flat");
-
-    const double line_area = M_PI * square(INT2MM(line_width) / 2.0);
-    extrusion_mm3_per_mm_connection = line_area * flowConnection / 100.0;
-    extrusion_mm3_per_mm_flat = line_area * flowFlat / 100.0;
-
+    
+    double filament_area = /* M_PI * */ (INT2MM(filament_diameter) / 2.0) * (INT2MM(filament_diameter) / 2.0);
+    double lineArea = /* M_PI * */ (INT2MM(extrusionWidth) / 2.0) * (INT2MM(extrusionWidth) / 2.0);
+    extrusion_per_mm_connection = lineArea / filament_area * flowConnection / 100.0;
+    extrusion_per_mm_flat = lineArea / filament_area * flowFlat / 100.0;
+    
     nozzle_outer_diameter = getSettingInMicrons("machine_nozzle_tip_outer_diameter"); // ___       ___   .
     nozzle_head_distance = getSettingInMicrons("machine_nozzle_head_distance");      //    |     |      .
     nozzle_expansion_angle = getSettingInAngleRadians("machine_nozzle_expansion_angle");  //     \_U_/       .
@@ -551,44 +550,34 @@ void Wireframe2gcode::processStartingCode()
 {
     if (!CommandSocket::isInstantiated())
     {
-        std::string prefix = gcode.getFileHeader();
-        gcode.writeCode(prefix.c_str());
+        gcode.writeCode(gcode.getFileHeader().c_str());
     }
-
-    int start_extruder_nr = getSettingAsIndex("adhesion_extruder_nr");
-
-    gcode.writeComment("Generated with Cura_SteamEngine " VERSION);
-
-    if (gcode.getFlavor() != EGCodeFlavor::ULTIGCODE && gcode.getFlavor() != EGCodeFlavor::GRIFFIN)
+    else 
     {
         if (getSettingBoolean("material_bed_temp_prepend"))
         {
-            if (getSettingBoolean("machine_heated_bed") && getSettingInDegreeCelsius("material_bed_temperature") != 0)
+            if (getSettingBoolean("machine_heated_bed") && getSettingInDegreeCelsius("material_bed_temperature") > 0)
             {
                 gcode.writeBedTemperatureCommand(getSettingInDegreeCelsius("material_bed_temperature"), getSettingBoolean("material_bed_temp_wait"));
             }
         }
-
+        
         if (getSettingBoolean("material_print_temp_prepend"))
         {
-            for (int extruder_nr = 0; extruder_nr < getSettingAsCount("machine_extruder_count"); extruder_nr++)
+            if (getSettingInDegreeCelsius("material_print_temperature") > 0)
             {
-                double print_temp = getSettingInDegreeCelsius("material_print_temperature");
-                gcode.writeTemperatureCommand(extruder_nr, print_temp);
-            }
-            if (getSettingBoolean("material_print_temp_wait"))
-            {
-                for (int extruder_nr = 0; extruder_nr < getSettingAsCount("machine_extruder_count"); extruder_nr++)
+                gcode.writeTemperatureCommand(getSettingAsIndex("extruder_nr"), getSettingInDegreeCelsius("material_print_temperature"));
+                if (getSettingBoolean("machine_print_temp_wait"))
                 {
-                    double print_temp = getSettingInDegreeCelsius("material_print_temperature");
-                    gcode.writeTemperatureCommand(extruder_nr, print_temp, true);
+                    gcode.writeTemperatureCommand(getSettingAsIndex("extruder_nr"), getSettingInDegreeCelsius("material_print_temperature"), true);
                 }
             }
         }
+        
     }
-
     gcode.writeCode(getSettingString("machine_start_gcode").c_str());
-
+    
+    gcode.writeComment("Generated with Cura_SteamEngine " VERSION);
     if (gcode.getFlavor() == EGCodeFlavor::BFB)
     {
         gcode.writeComment("enable auto-retraction");
@@ -596,16 +585,6 @@ void Wireframe2gcode::processStartingCode()
         tmp << "M227 S" << (getSettingInMicrons("retraction_amount") * 2560 / 1000) << " P" << (getSettingInMicrons("retraction_amount") * 2560 / 1000);
         gcode.writeLine(tmp.str().c_str());
     }
-    else if (gcode.getFlavor() == EGCodeFlavor::GRIFFIN)
-    { // initialize extruder trains
-        gcode.writeCode("T0"); // Toolhead already assumed to be at T0, but writing it just to be safe...
-        CommandSocket::setSendCurrentPosition(gcode.getPositionXY());
-        gcode.startExtruder(start_extruder_nr);
-        constexpr bool wait = true;
-        gcode.writeTemperatureCommand(start_extruder_nr, getSettingInDegreeCelsius("material_print_temperature"), wait);
-        gcode.writePrimeTrain(getSettingInMillimetersPerSecond("speed_travel"));
-        gcode.writeRetraction(standard_retraction_config);
-    }
 }
 
 
@@ -619,7 +598,7 @@ void Wireframe2gcode::processSkirt()
     PathOrderOptimizer order(Point(INT32_MIN, INT32_MIN));
     order.addPolygons(skirt);
     order.optimize();
-
+    
     for (unsigned int poly_order_idx = 0; poly_order_idx < skirt.size(); poly_order_idx++)
     {
         unsigned int poly_idx = order.polyOrder[poly_order_idx];
@@ -628,7 +607,7 @@ void Wireframe2gcode::processSkirt()
         for (unsigned int point_idx = 0; point_idx < poly.size(); point_idx++)
         {
             Point& p = poly[(point_idx + order.polyStart[poly_idx] + 1) % poly.size()];
-            gcode.writeMove(p, getSettingInMillimetersPerSecond("skirt_brim_speed"), getSettingInMillimeters("skirt_brim_line_width") * INT2MM(initial_layer_thickness));
+            gcode.writeMove(p, getSettingInMillimetersPerSecond("skirt_speed"), getSettingInMillimetersPerSecond("skirt_line_width"));
         }
     }
 }

src/Wireframe2gcode.h

@@ -16,6 +16,8 @@
 #include "utils/polygon.h"
 #include "Weaver.h"
 
+#include "debug.h"
+
 namespace cura
 {
 
@@ -31,11 +33,11 @@ private:
     
     int initial_layer_thickness;
     int filament_diameter;
-    int line_width;
+    int extrusionWidth;
     double flowConnection;
     double flowFlat; 
-    double extrusion_mm3_per_mm_connection;
-    double extrusion_mm3_per_mm_flat;
+    double extrusion_per_mm_connection; 
+    double extrusion_per_mm_flat; 
     int nozzle_outer_diameter;
     int nozzle_head_distance;
     double nozzle_expansion_angle;

src/bridge.cpp

@@ -5,7 +5,7 @@
 
 namespace cura {
 
-int bridgeAngle(Polygons outline, const SliceLayer* prevLayer)
+int bridgeAngle(Polygons outline, SliceLayer* prevLayer)
 {
     AABB boundaryBox(outline);
     //To detect if we have a bridge, first calculate the intersection of the current layer with the previous layer.

src/bridge.h

@@ -6,7 +6,7 @@ namespace cura {
     class Polygons;
     class SliceLayer;
 
-int bridgeAngle(Polygons outline, const SliceLayer* prevLayer);
+int bridgeAngle(Polygons outline, SliceLayer* prevLayer);
 
 }//namespace cura
 

src/commandSocket.cpp

@@ -18,6 +18,8 @@
 #include <windows.h>
 #endif
 
+#include "settings/SettingRegistry.h" // loadExtruderJSONsettings
+
 #define DEBUG_OUTPUT_OBJECT_STL_THROUGH_CERR(x) 
 
 // std::cerr << x;
@@ -55,193 +57,45 @@ public:
     }
 };
 
-/*!
- * A template structure used to store data to be sent to the front end.
- */
-template <typename T>
-class SliceDataStruct
-{
-    SliceDataStruct(const SliceDataStruct&) = delete;
-    SliceDataStruct& operator=(const SliceDataStruct&) = delete;
-public:
-
-    SliceDataStruct()
-        : sliced_objects(0)
-        , current_layer_count(0)
-        , current_layer_offset(0)
-    { }
-
-    //! The number of sliced objects for this sliced object list
-    int sliced_objects;
-
-    int current_layer_count;//!< Number of layers for which data has been buffered in slice_data so far.
-    int current_layer_offset;//!< Offset to add to layer number for the current slice object when slicing one at a time.
-
-    std::unordered_map<int, std::shared_ptr<T>> slice_data;
-};
-
 class CommandSocket::Private
 {
 public:
     Private()
         : socket(nullptr)
         , object_count(0)
+        , sliced_objects(0)
+        , current_layer_count(0)
+        , current_layer_offset(0)
     { }
 
     std::shared_ptr<cura::proto::Layer> getLayerById(int id);
 
-    std::shared_ptr<cura::proto::LayerOptimized> getOptimizedLayerById(int id);
-
     Arcus::Socket* socket;
     
     // Number of objects that need to be sliced
     int object_count;
 
+    // Number of sliced objects for this sliced object list
+    int sliced_objects;
+
+    // Number of layers sent to the front end so far
+    // Used for incrementing the current layer in one at a time mode
+    int current_layer_count;
+    int current_layer_offset;
+
     std::string temp_gcode_file;
     std::ostringstream gcode_output_stream;
     
     // Print object that olds one or more meshes that need to be sliced. 
     std::vector< std::shared_ptr<MeshGroup> > objects_to_slice;
 
-    SliceDataStruct<cura::proto::Layer> sliced_layers;
-    SliceDataStruct<cura::proto::LayerOptimized> optimized_layers;
-};
-
-/*!
- * PathCompiler buffers and prepares the sliced data to be sent to the front end and saves them in
- * appropriate buffers
- */
-class CommandSocket::PathCompiler
-{
-    typedef cura::proto::PathSegment::PointType PointType;
-    static_assert(sizeof(PrintFeatureType) == 1, "To be compatible with the Cura frontend code PrintFeatureType needs to be of size 1");
-    //! Reference to the private data of the CommandSocket used to send the data to the front end.
-    CommandSocket::Private& _cs_private_data;
-    //! Keeps track of the current layer number being processed. If layer number is set to a different value, the current data is flushed to CommandSocket.
-    int _layer_nr;
-    int extruder;
-    PointType data_point_type;
-
-    std::vector<PrintFeatureType> line_types; //!< Line types for the line segments stored, the size of this vector is N.
-    std::vector<float> line_widths; //!< Line widths for the line segments stored, the size of this vector is N.
-    std::vector<float> points; //!< The points used to define the line segments, the size of this vector is D*(N+1) as each line segment is defined from one point to the next. D is the dimensionality of the point.
-
-    Point last_point;
-
-    PathCompiler(const PathCompiler&) = delete;
-    PathCompiler& operator=(const PathCompiler&) = delete;
-public:
-    PathCompiler(CommandSocket::Private& cs_private_data):
-        _cs_private_data(cs_private_data),
-        _layer_nr(0),
-        extruder(0),
-        data_point_type(cura::proto::PathSegment::Point2D),
-        line_types(),
-        line_widths(),
-        points(),
-        last_point{0,0}
-    {}
-    ~PathCompiler()
-    {
-        if (line_types.size())
-        {
-            flushPathSegments();
-        }
-    }
-
-    /*!
-     * Used to select which layer the following layer data is intended for.
-     */
-    void setLayer(int new_layer_nr)
-    {
-        if (_layer_nr != new_layer_nr)
-        {
-            flushPathSegments();
-            _layer_nr = new_layer_nr;
-        }
-    }
-    /*!
-     * Returns the current layer which data is written to.
-     */
-    int getLayer() const
-    {
-        return _layer_nr;
-    }
-    /*!
-     * Used to set which extruder will be used for printing the following layer data is intended for.
-     */
-    void setExtruder(int new_extruder)
-    {
-        if (extruder != new_extruder)
-        {
-            flushPathSegments();
-            extruder = new_extruder;
-        }
-    }
-
-    /*!
-     * Special handling of the first point in an added line sequence.
-     * If the new sequence of lines does not start at the current end point
-     * of the path this jump is marked as PrintFeatureType::NoneType
-     */
-    void handleInitialPoint(Point from)
-    {
-        if (points.size() == 0)
-        {
-            addPoint2D(from);
-        }
-        else if (from != last_point)
-        {
-            addLineSegment(PrintFeatureType::NoneType, from, 1.0);
-        }
-    }
-
-    /*!
-     * Transfers the currently buffered line segments to the
-     * CommandSocket layer message storage.
-     */
-    void flushPathSegments();
-    /*!
-     * Move the current point of this path to \position.
-     */
-    void setCurrentPosition(Point position)
-    {
-        handleInitialPoint(position);
-    }
-    /*!
-     * Adds a single line segment to the current path. The line segment added is from the current last point to point \p to
-     */
-    void sendLineTo(PrintFeatureType print_feature_type, Point to, int width);
-    /*!
-     * Adds closed polygon to the current path
-     */
-    void sendPolygon(PrintFeatureType print_feature_type, ConstPolygonRef poly, int width);
-private:
-    /*!
-     * Convert and add a point to the points buffer, each point being represented as two consecutive floats. All members adding a 2D point to the data should use this function.
-     */
-    void addPoint2D(Point point)
-    {
-        points.push_back(INT2MM(point.X));
-        points.push_back(INT2MM(point.Y));
-        last_point = point;
-    }
-    /*!
-     * Implements the functionality of adding a single 2D line segment to the path data. All member functions adding a 2D line segment should use this functions.
-     */
-    void addLineSegment(PrintFeatureType print_feature_type, Point point, int line_width)
-    {
-        addPoint2D(point);
-        line_types.push_back(print_feature_type);
-        line_widths.push_back(INT2MM(line_width));
-    }
+    std::unordered_map<int, std::shared_ptr<cura::proto::Layer>> sliced_layers;
 };
 #endif
 
 CommandSocket::CommandSocket()
 #ifdef ARCUS
     : private_data(new Private)
-    , path_comp(new PathCompiler(*private_data))
 #endif
 {
 #ifdef ARCUS
@@ -273,14 +127,12 @@ void CommandSocket::connect(const std::string& ip, int port)
     //private_data->socket->registerMessageType(1, &Cura::ObjectList::default_instance());
     private_data->socket->registerMessageType(&cura::proto::Slice::default_instance());
     private_data->socket->registerMessageType(&cura::proto::Layer::default_instance());
-    private_data->socket->registerMessageType(&cura::proto::LayerOptimized::default_instance());
     private_data->socket->registerMessageType(&cura::proto::Progress::default_instance());
     private_data->socket->registerMessageType(&cura::proto::GCodeLayer::default_instance());
     private_data->socket->registerMessageType(&cura::proto::PrintTimeMaterialEstimates::default_instance());
     private_data->socket->registerMessageType(&cura::proto::SettingList::default_instance());
     private_data->socket->registerMessageType(&cura::proto::GCodePrefix::default_instance());
     private_data->socket->registerMessageType(&cura::proto::SlicingFinished::default_instance());
-    private_data->socket->registerMessageType(&cura::proto::SettingExtruder::default_instance());
 
     private_data->socket->connect(ip, port);
 
@@ -323,7 +175,6 @@ void CommandSocket::connect(const std::string& ip, int port)
         cura::proto::Slice* slice = dynamic_cast<cura::proto::Slice*>(message.get()); // See if the message is of the message type Slice; returns nullptr otherwise
         if (slice)
         {
-            logDebug("Received a Slice message\n");
             const cura::proto::SettingList& global_settings = slice->global_settings();
             for (auto setting : global_settings.settings())
             {
@@ -335,44 +186,19 @@ void CommandSocket::connect(const std::string& ip, int port)
             {
                 handleObjectList(&object, slice->extruders());
             }
-            //For every object, set the extruder fallbacks from the limit_to_extruder.
-            for (const cura::proto::SettingExtruder setting_extruder : slice->limit_to_extruder())
-            {
-                const int32_t extruder_nr = setting_extruder.extruder(); //Implicit cast from Protobuf's int32 to normal int32.
-                for (std::shared_ptr<MeshGroup> meshgroup : private_data->objects_to_slice)
-                {
-                    if (extruder_nr < 0 || extruder_nr >= meshgroup->getExtruderCount()) //We obtained an invalid value from the front-end. Ignore.
-                    {
-                        continue;
-                    }
-                    const ExtruderTrain* settings_base = meshgroup->getExtruderTrain(extruder_nr); //The extruder train that the setting should fall back to.
-                    for (Mesh& mesh : meshgroup->meshes)
-                    {
-                        mesh.setSettingInheritBase(setting_extruder.name(), *settings_base);
-                    }
-                }
-            }
-            logDebug("Done reading Slice message\n");
         }
 
         //If there is an object to slice, do so.
         if (private_data->objects_to_slice.size())
         {
-            int object_count = private_data->objects_to_slice.size();
-            logDebug("Slicing %i objects\n", object_count);
             FffProcessor::getInstance()->resetMeshGroupNumber();
-            int i = 1;
             for (auto object : private_data->objects_to_slice)
             {
-                logDebug("Slicing object %i of %i\n", i, object_count);
                 if (!FffProcessor::getInstance()->processMeshGroup(object.get()))
                 {
                     logError("Slicing mesh group failed!");
                 }
-                i++;
             }
-            logDebug("Done slicing objects\n");
-
             private_data->objects_to_slice.clear();
             FffProcessor::getInstance()->finalize();
             flushGcode();
@@ -417,13 +243,14 @@ void CommandSocket::handleObjectList(cura::proto::ObjectList* list, const google
     { // load extruder settings
         for (int extruder_nr = 0; extruder_nr < FffProcessor::getInstance()->getSettingAsCount("machine_extruder_count"); extruder_nr++)
         { // initialize remaining extruder trains and load the defaults
-            meshgroup->createExtruderTrain(extruder_nr); // create new extruder train objects or use already existing ones
+            ExtruderTrain* train = meshgroup->createExtruderTrain(extruder_nr); // create new extruder train objects or use already existing ones
+            SettingRegistry::getInstance()->loadExtruderJSONsettings(extruder_nr, train);
         }
 
         for (auto extruder : settings_per_extruder_train)
         {
             int extruder_nr = extruder.id();
-            ExtruderTrain* train = meshgroup->getExtruderTrain(extruder_nr);
+            ExtruderTrain* train = meshgroup->createExtruderTrain(extruder_nr); // create new extruder train objects or use already existing ones
             for (auto setting : extruder.settings().settings())
             {
                 train->setSetting(setting.name(), setting.value());
@@ -493,99 +320,41 @@ void CommandSocket::handleObjectList(cura::proto::ObjectList* list, const google
 }
 #endif
 
-void CommandSocket::sendOptimizedLayerInfo(int layer_nr, int32_t z, int32_t height)
+void CommandSocket::sendLayerInfo(int layer_nr, int32_t z, int32_t height)
 {
 #ifdef ARCUS
-    std::shared_ptr<cura::proto::LayerOptimized> layer = private_data->getOptimizedLayerById(layer_nr);
+    std::shared_ptr<cura::proto::Layer> layer = private_data->getLayerById(layer_nr);
     layer->set_height(z);
     layer->set_thickness(height);
 #endif
 }
 
-void CommandSocket::sendPolygons(PrintFeatureType type, const Polygons& polygons, int line_width)
+void CommandSocket::sendPolygons(PrintFeatureType type, int layer_nr, const Polygons& polygons, int line_width)
 {
 #ifdef ARCUS
     if (polygons.size() == 0)
-    {
         return;
-    }
 
-    if (CommandSocket::isInstantiated())
+    std::shared_ptr<cura::proto::Layer> proto_layer = private_data->getLayerById(layer_nr);
+
+    for (unsigned int i = 0; i < polygons.size(); ++i)
     {
-        auto& path_comp = CommandSocket::getInstance()->path_comp;
-
-        for (unsigned int i = 0; i < polygons.size(); ++i)
-        {
-            path_comp->sendPolygon(type, polygons[i], line_width);
-        }
+        cura::proto::Polygon* p = proto_layer->add_polygons();
+        p->set_type(static_cast<cura::proto::Polygon_Type>(type));
+        std::string polydata;
+        polydata.append(reinterpret_cast<const char*>(polygons[i].data()), polygons[i].size() * sizeof(Point));
+        p->set_points(polydata);
+        p->set_line_width(line_width);
     }
 #endif
 }
 
-void CommandSocket::sendPolygon(PrintFeatureType type, ConstPolygonRef polygon, int line_width)
-{
-#ifdef ARCUS
-    if (CommandSocket::isInstantiated())
-    {
-        auto& path_comp = CommandSocket::getInstance()->path_comp;
-
-        path_comp->sendPolygon(type, polygon, line_width);
-    }
-#endif
-}
-
-void CommandSocket::sendLineTo(cura::PrintFeatureType type, Point to, int line_width)
-{
-#ifdef ARCUS
-    if (CommandSocket::isInstantiated())
-    {
-        auto& path_comp = CommandSocket::getInstance()->path_comp;
-
-        path_comp->sendLineTo(type, to, line_width);
-    }
-#endif
-}
-
-void CommandSocket::setSendCurrentPosition(Point position)
-{
-#ifdef ARCUS
-    if (CommandSocket::isInstantiated())
-    {
-        auto& path_comp = CommandSocket::getInstance()->path_comp;
-        path_comp->setCurrentPosition(position);
-    }
-#endif
-}
-
-void CommandSocket::setLayerForSend(int layer_nr)
-{
-#ifdef ARCUS
-    if (CommandSocket::isInstantiated())
-    {
-        auto& path_comp = CommandSocket::getInstance()->path_comp;
-        path_comp->setLayer(layer_nr);
-    }
-#endif
-}
-
-void CommandSocket::setExtruderForSend(int extruder)
-{
-#ifdef ARCUS
-    if (CommandSocket::isInstantiated())
-    {
-        auto& path_comp = CommandSocket::getInstance()->path_comp;
-        path_comp->setExtruder(extruder);
-    }
-#endif
-}
-
-
 void CommandSocket::sendProgress(float amount)
 {
 #ifdef ARCUS
     auto message = std::make_shared<cura::proto::Progress>();
     amount /= private_data->object_count;
-    amount += private_data->optimized_layers.sliced_objects * (1. / private_data->object_count);
+    amount += private_data->sliced_objects * (1. / private_data->object_count);
     message->set_amount(amount);
     private_data->socket->sendMessage(message);
 #endif
@@ -599,7 +368,6 @@ void CommandSocket::sendProgressStage(Progress::Stage stage)
 void CommandSocket::sendPrintTimeMaterialEstimates()
 {
 #ifdef ARCUS
-    logDebug("Sending print time and material estimates.\n");
     auto message = std::make_shared<cura::proto::PrintTimeMaterialEstimates>();
 
     message->set_time(FffProcessor::getInstance()->getTotalPrintTime());
@@ -613,7 +381,6 @@ void CommandSocket::sendPrintTimeMaterialEstimates()
     }
 
     private_data->socket->sendMessage(message);
-    logDebug("Done sending print time and material estimates.\n");
 #endif
 }
 
@@ -631,50 +398,20 @@ void CommandSocket::sendLayerData()
 #ifdef ARCUS
 #endif
 #ifdef ARCUS
-    auto& data = private_data->sliced_layers;
+    private_data->sliced_objects++;
+    private_data->current_layer_offset = private_data->current_layer_count;
+    log("End sliced object called. Sending %d layers.", private_data->current_layer_count);
 
-    data.sliced_objects++;
-    data.current_layer_offset = data.current_layer_count;
-//    log("End sliced object called. Sending %d layers.", data.current_layer_count);
-
-    // Only send the data to the front end when all mesh groups have been processed.
-    if (data.sliced_objects >= private_data->object_count)
+    if (private_data->sliced_objects >= private_data->object_count)
     {
-        for (std::pair<const int, std::shared_ptr<cura::proto::Layer>> entry : data.slice_data) //Note: This is in no particular order!
+        for (std::pair<const int, std::shared_ptr<cura::proto::Layer>> entry : private_data->sliced_layers) //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;
-        data.current_layer_count = 0;
-        data.current_layer_offset = 0;
-        data.slice_data.clear();
-    }
-#endif
-}
-
-void CommandSocket::sendOptimizedLayerData()
-{
-#ifdef ARCUS
-    path_comp->flushPathSegments(); // make sure the last path segment has been flushed from the compiler
-
-    auto& data = private_data->optimized_layers;
-
-    data.sliced_objects++;
-    data.current_layer_offset = data.current_layer_count;
-    log("End sliced object called. Sending %d layers.", data.current_layer_count);
-
-    if (data.sliced_objects >= private_data->object_count)
-    {
-        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;
-        data.current_layer_count = 0;
-        data.current_layer_offset = 0;
-        data.slice_data.clear();
+        private_data->sliced_objects = 0;
+        private_data->current_layer_count = 0;
+        private_data->current_layer_offset = 0;
+        private_data->sliced_layers.clear();
     }
 #endif
 }
@@ -682,10 +419,8 @@ void CommandSocket::sendOptimizedLayerData()
 void CommandSocket::sendFinishedSlicing()
 {
 #ifdef ARCUS
-    logDebug("Sending Slicing Finished message.\n");
     std::shared_ptr<cura::proto::SlicingFinished> done_message = std::make_shared<cura::proto::SlicingFinished>();
     private_data->socket->sendMessage(done_message);
-    logDebug("Done sending Slicing Finished message.\n");
 #endif
 }
 
@@ -719,12 +454,12 @@ void CommandSocket::sendGCodePrefix(std::string prefix)
 #ifdef ARCUS
 std::shared_ptr<cura::proto::Layer> CommandSocket::Private::getLayerById(int id)
 {
-    id += sliced_layers.current_layer_offset;
+    id += current_layer_offset;
 
-    auto itr = sliced_layers.slice_data.find(id);
+    auto itr = sliced_layers.find(id);
 
     std::shared_ptr<cura::proto::Layer> layer;
-    if (itr != sliced_layers.slice_data.end())
+    if (itr != sliced_layers.end())
     {
         layer = itr->second;
     }
@@ -732,98 +467,12 @@ std::shared_ptr<cura::proto::Layer> CommandSocket::Private::getLayerById(int id)
     {
         layer = std::make_shared<cura::proto::Layer>();
         layer->set_id(id);
-        sliced_layers.current_layer_count++;
-        sliced_layers.slice_data[id] = layer;
+        current_layer_count++;
+        sliced_layers[id] = layer;
     }
 
     return layer;
 }
 #endif
 
-#ifdef ARCUS
-std::shared_ptr<cura::proto::LayerOptimized> CommandSocket::Private::getOptimizedLayerById(int id)
-{
-    id += optimized_layers.current_layer_offset;
-
-    auto itr = optimized_layers.slice_data.find(id);
-
-    std::shared_ptr<cura::proto::LayerOptimized> layer;
-    if (itr != optimized_layers.slice_data.end())
-    {
-        layer = itr->second;
-    }
-    else
-    {
-        layer = std::make_shared<cura::proto::LayerOptimized>();
-        layer->set_id(id);
-        optimized_layers.current_layer_count++;
-        optimized_layers.slice_data[id] = layer;
-    }
-
-    return layer;
-}
-#endif
-
-#ifdef ARCUS
-void CommandSocket::PathCompiler::flushPathSegments()
-{
-    if (line_types.size() > 0 && CommandSocket::isInstantiated())
-    {
-        std::shared_ptr<cura::proto::LayerOptimized> proto_layer = _cs_private_data.getOptimizedLayerById(_layer_nr);
-
-        cura::proto::PathSegment* p = proto_layer->add_path_segment();
-        p->set_extruder(extruder);
-        p->set_point_type(data_point_type);
-        std::string line_type_data;
-        line_type_data.append(reinterpret_cast<const char*>(line_types.data()), line_types.size()*sizeof(PrintFeatureType));
-        p->set_line_type(line_type_data);
-        std::string polydata;
-        polydata.append(reinterpret_cast<const char*>(points.data()), points.size() * sizeof(float));
-        p->set_points(polydata);
-        std::string line_width_data;
-        line_width_data.append(reinterpret_cast<const char*>(line_widths.data()), line_widths.size()*sizeof(float));
-        p->set_line_width(line_width_data);
-    }
-    points.clear();
-    line_widths.clear();
-    line_types.clear();
-}
-
-void CommandSocket::PathCompiler::sendLineTo(PrintFeatureType print_feature_type, Point to, int width)
-{
-    assert(points.size() > 0 && "A point must already be in the buffer for sendLineTo(.) to function properly");
-
-    if (to != last_point)
-    {
-        addLineSegment(print_feature_type, to, width);
-    }
-}
-
-void CommandSocket::PathCompiler::sendPolygon(PrintFeatureType print_feature_type, ConstPolygonRef polygon, int width)
-{
-    if (polygon.size() < 2)
-    {
-        return;
-    }
-
-    auto it = polygon.begin();
-    handleInitialPoint(*it);
-
-    const auto it_end = polygon.end();
-    while (++it != it_end)
-    {
-        // Ignore zero-length segments.
-        if (*it != last_point)
-        {
-            addLineSegment(print_feature_type, *it, width);
-        }
-    }
-    // Make sure the polygon is closed
-    if (*polygon.begin() != polygon.back())
-    {
-        addLineSegment(print_feature_type, *polygon.begin(), width);
-    }
-}
-#endif
-
 }//namespace cura

src/commandSocket.h

@@ -50,44 +50,19 @@ public:
      */
     void handleObjectList(cura::proto::ObjectList* list, const google::protobuf::RepeatedPtrField<cura::proto::Extruder> settings_per_extruder_train);
 #endif
-
+    
     /*!
-     * Send info on an optimized layer to be displayed by the forntend: set the z and the thickness of the layer.
+     * Send info on a layer to be displayed by the forntend: set the z and the thickness of the layer.
      */
-    void sendOptimizedLayerInfo(int layer_nr, int32_t z, int32_t height);
+    void sendLayerInfo(int layer_nr, int32_t z, int32_t height);
+    
+    /*! 
+     * Send a polygon to the engine. This is used for the layerview in the GUI
+     */
+    void sendPolygons(cura::PrintFeatureType type, int layer_nr, const cura::Polygons& polygons, int line_width);
 
     /*! 
-     * Send a polygon to the front-end. This is used for the layerview in the GUI
-     */
-    static void sendPolygons(cura::PrintFeatureType type, const cura::Polygons& polygons, int line_width);
-
-    /*! 
-     * Send a polygon to the front-end. This is used for the layerview in the GUI
-     */
-    static void sendPolygon(cura::PrintFeatureType type, ConstPolygonRef polygon, int line_width);
-
-    /*!
-     * Send a line to the front-end. This is used for the layerview in the GUI
-     */
-    static void sendLineTo(cura::PrintFeatureType type, Point to, int line_width);
-
-    /*!
-     * Set the current position of the path compiler to \p position. This is used for the layerview in the GUI
-     */
-    static void setSendCurrentPosition(Point position);
-
-    /*!
-    * Set which layer is being used for the following calls to SendPolygons, SendPolygon and SendLineTo.
-    */
-    static void setLayerForSend(int layer_nr);
-
-     /*!
-     * Set which extruder is being used for the following calls to SendPolygons, SendPolygon and SendLineTo.
-     */
-    static void setExtruderForSend(int extruder);
-
-    /*!
-     * Send a polygon to the front-end if the command socket is instantiated. This is used for the layerview in the GUI
+     * Send a polygon to the engine if the command socket is instantiated. This is used for the layerview in the GUI
      */
     static void sendPolygonsToCommandSocket(cura::PrintFeatureType type, int layer_nr, const cura::Polygons& polygons, int line_width);
 
@@ -112,21 +87,12 @@ public:
     void sendPrintMaterialForObject(int index, int extruder_nr, float material_amount);
     
     /*!
-     * Send the slices of the model as polygons to the GUI.
+     * Send the sliced layer data to the GUI.
      *
-     * The GUI may use this to visualize the early result of the slicing
-     * process.
-     */
-    void sendLayerData();
-
-    /*!
-     * Send the sliced layer data to the GUI after the optimization is done and
-     * the actual order in which to print has been set.
-     *
-     * The GUI may use this to visualize the g-code, so that the user can
+     * The GUI may use this to visualise the g-code, so that the user can
      * inspect the result of slicing.
      */
-    void sendOptimizedLayerData();
+    void sendLayerData();
 
     /*!
      * \brief Sends a message to indicate that all the slicing is done.
@@ -148,8 +114,6 @@ public:
 private:
     class Private;
     const std::unique_ptr<Private> private_data;
-    class PathCompiler;
-    const std::unique_ptr<PathCompiler> path_comp;
 #endif
 };
 

src/debug.h

@@ -0,0 +1,61 @@
+#ifndef DEBUG_H
+#define DEBUG_H
+
+#include <string.h>
+
+#define __FILE_NAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
+
+
+#define DEBUG_HERE std::cerr << __FILE_NAME__ << " : " << __LINE__ << std::endl
+
+
+
+
+
+#define DEBUG 1
+
+#define DEBUG_SHOW_LINE 1
+
+#if DEBUG_SHOW_LINE == 1
+#define DEBUG_FILE_LINE __FILE_NAME__ << "." << __LINE__ << ": "
+#else
+#define DEBUG_FILE_LINE  ""
+#endif
+
+#if DEBUG == 1
+#   define DEBUG_DO(x) do { x } while (0)
+#   define DEBUG_SHOW(x) do {       std::cerr << DEBUG_FILE_LINE << #x << " = " << x << std::endl; } while (0)
+#   define DEBUG_PRINTLN(x) do {    std::cerr << DEBUG_FILE_LINE << x << std::endl; } while (0)
+#else
+#   define DEBUG_DO(x)
+#   define DEBUG_SHOW(x)
+#   define DEBUG_PRINTLN(x)
+#endif
+
+
+
+#include <sstream>
+
+#if 0==1
+#define ENUM(name, ...) enum class name { __VA_ARGS__, __COUNT};
+#endif
+#define ENUM(name, ...) enum class name { __VA_ARGS__}; \
+inline std::ostream& operator<<(std::ostream& os, name value) { \
+std::string enumName = #name; \
+std::string str = #__VA_ARGS__; \
+int len = str.length(); \
+std::vector<std::string> strings; \
+std::ostringstream temp; \
+for(int i = 0; i < len; i ++) { \
+if(isspace(str[i])) continue; \
+        else if(str[i] == ',') { \
+        strings.push_back(temp.str()); \
+        temp.str(std::string());\
+        } \
+        else temp<< str[i]; \
+} \
+strings.push_back(temp.str()); \
+os << enumName << "::" << strings[static_cast<int>(value)]; \
+return os;}
+
+#endif // DEBUG_H

src/gcodeExport.cpp

@@ -7,12 +7,9 @@
 #include "utils/logoutput.h"
 #include "PrintFeature.h"
 #include "utils/Date.h"
-#include "utils/string.h" // MMtoStream, PrecisionedDouble
 
 namespace cura {
 
-double layer_height; //!< report basic layer height in RepRap gcode file.
-
 GCodeExport::GCodeExport()
 : output_stream(&std::cout)
 , currentPosition(0,0,MM2INT(20))
@@ -29,56 +26,42 @@ GCodeExport::GCodeExport()
     currentSpeed = 1;
     current_acceleration = -1;
     current_jerk = -1;
-    current_max_z_feedrate = -1;
 
     isZHopped = 0;
     setFlavor(EGCodeFlavor::REPRAP);
     initial_bed_temp = 0;
 
     extruder_count = 0;
-
-    total_bounding_box = AABB3D();
 }
 
 GCodeExport::~GCodeExport()
 {
 }
 
-void GCodeExport::preSetup(const MeshGroup* meshgroup)
+void GCodeExport::preSetup(const MeshGroup* settings)
 {
-    setFlavor(meshgroup->getSettingAsGCodeFlavor("machine_gcode_flavor"));
-    use_extruder_offset_to_offset_coords = meshgroup->getSettingBoolean("machine_use_extruder_offset_to_offset_coords");
+    setFlavor(settings->getSettingAsGCodeFlavor("machine_gcode_flavor"));
+    use_extruder_offset_to_offset_coords = settings->getSettingBoolean("machine_use_extruder_offset_to_offset_coords");
 
-    extruder_count = meshgroup->getSettingAsCount("machine_extruder_count");
+    extruder_count = settings->getSettingAsCount("machine_extruder_count");
 
-    for (const Mesh& mesh : meshgroup->meshes)
+    for (const Mesh& mesh : settings->meshes)
     {
-        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;
     }
 
     for (unsigned int extruder_nr = 0; extruder_nr < extruder_count; extruder_nr++)
     {
-        const ExtruderTrain* train = meshgroup->getExtruderTrain(extruder_nr);
+        const ExtruderTrain* train = settings->getExtruderTrain(extruder_nr);
 
-        if (meshgroup->getSettingAsIndex("adhesion_extruder_nr") == int(extruder_nr) && meshgroup->getSettingAsPlatformAdhesion("adhesion_type") != EPlatformAdhesion::NONE)
+        if (settings->getSettingAsIndex("adhesion_extruder_nr") == int(extruder_nr)
+            || (settings->getSettingBoolean("support_enable") && settings->getSettingAsIndex("support_infill_extruder_nr") == int(extruder_nr))
+            || (settings->getSettingBoolean("support_enable") && settings->getSettingAsIndex("support_extruder_nr_layer_0") == int(extruder_nr))
+            || (settings->getSettingBoolean("support_enable") && settings->getSettingBoolean("support_roof_enable") && settings->getSettingAsIndex("support_roof_extruder_nr") == int(extruder_nr))
+            )
         {
             extruder_attr[extruder_nr].is_used = true;
         }
-        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))
-                )
-            {
-                extruder_attr[extruder_nr].is_used = true;
-            }
-        }
         setFilamentDiameter(extruder_nr, train->getSettingInMicrons("material_diameter")); 
 
         extruder_attr[extruder_nr].prime_pos = Point3(train->getSettingInMicrons("extruder_prime_pos_x"), train->getSettingInMicrons("extruder_prime_pos_y"), train->getSettingInMicrons("extruder_prime_pos_z"));
@@ -93,13 +76,11 @@ void GCodeExport::preSetup(const MeshGroup* meshgroup)
 
         extruder_attr[extruder_nr].last_retraction_prime_speed = train->getSettingInMillimetersPerSecond("retraction_prime_speed"); // the alternative would be switch_extruder_prime_speed, but dual extrusion might not even be configured...
     }
-    machine_dimensions.x = meshgroup->getSettingInMicrons("machine_width");
-    machine_dimensions.y = meshgroup->getSettingInMicrons("machine_depth");
-    machine_dimensions.z = meshgroup->getSettingInMicrons("machine_height");
+    machine_dimensions.x = settings->getSettingInMicrons("machine_width");
+    machine_dimensions.y = settings->getSettingInMicrons("machine_depth");
+    machine_dimensions.z = settings->getSettingInMicrons("machine_height");
 
-    machine_name = meshgroup->getSettingString("machine_name");
-
-    layer_height = meshgroup->getSettingInMillimeters("layer_height");
+    machine_name = settings->getSettingString("machine_name");
 
     if (flavor == EGCodeFlavor::BFB)
     {
@@ -110,22 +91,20 @@ void GCodeExport::preSetup(const MeshGroup* meshgroup)
         new_line = "\n";
     }
 
-    estimateCalculator.setFirmwareDefaults(meshgroup);
+    estimateCalculator.setFirmwareDefaults(settings);
 }
 
-void GCodeExport::setInitialTemps(const MeshGroup& settings, const unsigned int start_extruder_nr)
+void GCodeExport::setInitialTemps(const MeshGroup& settings)
 {
     for (unsigned int extr_nr = 0; extr_nr < extruder_count; extr_nr++)
     {
-        const ExtruderTrain& train = *settings.getExtruderTrain(extr_nr);
-        
-        double print_temp_0 = train.getSettingInDegreeCelsius("material_print_temperature_layer_0");
-        double print_temp_here = (print_temp_0 != 0)? print_temp_0 : train.getSettingInDegreeCelsius("material_print_temperature");
-        double temp = (extr_nr == start_extruder_nr)? print_temp_here : train.getSettingInDegreeCelsius("material_standby_temperature");
+        const ExtruderTrain* extr_train = settings.getExtruderTrain(extr_nr);
+        assert(extr_train);
+        double temp = extr_train->getSettingInDegreeCelsius((extr_nr == 0)? "material_print_temperature" : "material_standby_temperature");
         setInitialTemp(extr_nr, temp);
     }
 
-    initial_bed_temp = settings.getSettingInDegreeCelsius("material_bed_temperature_layer_0");
+    initial_bed_temp = settings.getSettingInDegreeCelsius("material_bed_temperature");
 }
 
 void GCodeExport::setInitialTemp(int extruder_nr, double temp)
@@ -176,12 +155,12 @@ std::string GCodeExport::getFileHeader(const double* print_time, const std::vect
             prefix << ";PRINT.TIME:" << static_cast<int>(*print_time) << new_line;
         }
 
-        prefix << ";PRINT.SIZE.MIN.X:" << INT2MM(total_bounding_box.min.x) << new_line;
-        prefix << ";PRINT.SIZE.MIN.Y:" << INT2MM(total_bounding_box.min.y) << new_line;
-        prefix << ";PRINT.SIZE.MIN.Z:" << INT2MM(total_bounding_box.min.z) << new_line;
-        prefix << ";PRINT.SIZE.MAX.X:" << INT2MM(total_bounding_box.max.x) << new_line;
-        prefix << ";PRINT.SIZE.MAX.Y:" << INT2MM(total_bounding_box.max.y) << new_line;
-        prefix << ";PRINT.SIZE.MAX.Z:" << INT2MM(total_bounding_box.max.z) << new_line;
+        prefix << ";PRINT.SIZE.MIN.X:0" << new_line;
+        prefix << ";PRINT.SIZE.MIN.Y:0" << new_line;
+        prefix << ";PRINT.SIZE.MIN.Z:0" << new_line;
+        prefix << ";PRINT.SIZE.MAX.X:" << INT2MM(machine_dimensions.x) << new_line;
+        prefix << ";PRINT.SIZE.MAX.Y:" << INT2MM(machine_dimensions.y) << new_line;
+        prefix << ";PRINT.SIZE.MAX.Z:" << INT2MM(machine_dimensions.z) << new_line;
         prefix << ";END_OF_HEADER" << new_line;
         return prefix.str();
     default:
@@ -195,11 +174,6 @@ std::string GCodeExport::getFileHeader(const double* print_time, const std::vect
             prefix << ";NOZZLE_DIAMETER:" << float(INT2MM(getNozzleSize(0))) << new_line;
             // TODO: the second nozzle size isn't always initiated! ";NOZZLE_DIAMETER2:"
         }
-        else if (flavor == EGCodeFlavor::REPRAP)
-        {
-            prefix << ";Filament used: " << ((filament_used.size() >= 1)? filament_used[0] / (1000 * extruder_attr[0].filament_area) : 0) << "m" << new_line;
-            prefix << ";Layer height: " << layer_height << new_line;
-        }
         return prefix.str();
     }
 }
@@ -215,27 +189,27 @@ void GCodeExport::setOutputStream(std::ostream* stream)
     *output_stream << std::fixed;
 }
 
-bool GCodeExport::getExtruderIsUsed(const int extruder_nr) const
+bool GCodeExport::getExtruderIsUsed(int extruder_nr)
 {
     return extruder_attr[extruder_nr].is_used;
 }
 
-int GCodeExport::getNozzleSize(const int extruder_nr) const
+int GCodeExport::getNozzleSize(int extruder_nr)
 {
     return extruder_attr[extruder_nr].nozzle_size;
 }
 
-Point GCodeExport::getExtruderOffset(const int id) const
+Point GCodeExport::getExtruderOffset(int id)
 {
     return extruder_attr[id].nozzle_offset;
 }
 
-std::string GCodeExport::getMaterialGUID(const int extruder_nr) const
+std::string GCodeExport::getMaterialGUID(int extruder_nr)
 {
     return extruder_attr[extruder_nr].material_guid;
 }
 
-Point GCodeExport::getGcodePos(const int64_t x, const int64_t y, const int extruder_train) const
+Point GCodeExport::getGcodePos(int64_t x, int64_t y, int extruder_train)
 {
     if (use_extruder_offset_to_offset_coords) { return Point(x,y) - getExtruderOffset(extruder_train); }
     else { return Point(x,y); }
@@ -270,14 +244,14 @@ void GCodeExport::setFlavor(EGCodeFlavor flavor)
     }
 }
 
-EGCodeFlavor GCodeExport::getFlavor() const
+EGCodeFlavor GCodeExport::getFlavor()
 {
     return this->flavor;
 }
 
 void GCodeExport::setZ(int z)
 {
-    this->current_layer_z = z;
+    this->zPos = z;
 }
 
 Point3 GCodeExport::getPosition()
@@ -428,7 +402,7 @@ void GCodeExport::writeTypeComment(PrintFeatureType type)
         case PrintFeatureType::Support:
             *output_stream << ";TYPE:SUPPORT" << new_line;
             break;
-        case PrintFeatureType::SkirtBrim:
+        case PrintFeatureType::Skirt:
             *output_stream << ";TYPE:SKIRT" << new_line;
             break;
         case PrintFeatureType::Infill:
@@ -485,7 +459,7 @@ void GCodeExport::writeDelay(double timeAmount)
 
 void GCodeExport::writeMove(Point p, double speed, double extrusion_mm3_per_mm)
 {
-    writeMove(p.X, p.Y, current_layer_z, speed, extrusion_mm3_per_mm);
+    writeMove(p.X, p.Y, zPos, speed, extrusion_mm3_per_mm);
 }
 
 void GCodeExport::writeMove(Point3 p, double speed, double extrusion_mm3_per_mm)
@@ -512,7 +486,7 @@ void GCodeExport::writeMoveBFB(int x, int y, int z, double speed, double extrusi
             {
                 //fprintf(f, "; %f e-per-mm %d mm-width %d mm/s\n", extrusion_per_mm, lineWidth, speed);
                 //fprintf(f, "M108 S%0.1f\r\n", rpm);
-                *output_stream << "M108 S" << PrecisionedDouble{1, rpm} << new_line;
+                *output_stream << "M108 S" << std::setprecision(1) << rpm << new_line;
                 currentSpeed = double(rpm);
             }
             //Add M101 or M201 to enable the proper extruder.
@@ -537,8 +511,10 @@ void GCodeExport::writeMoveBFB(int x, int y, int z, double speed, double extrusi
             extruder_attr[current_extruder].retraction_e_amount_current = 1.0; // 1.0 used as stub; BFB doesn't use the actual retraction amount; it performs retraction on the firmware automatically
         }
     }
-    *output_stream << "G1 X" << MMtoStream{gcode_pos.X} << " Y" << MMtoStream{gcode_pos.Y} << " Z" << MMtoStream{z};
-    *output_stream << " F" << PrecisionedDouble{1, fspeed} << new_line;
+    *output_stream << std::setprecision(3) << 
+        "G1 X" << INT2MM(gcode_pos.X) << 
+        " Y" << INT2MM(gcode_pos.Y) << 
+        " Z" << INT2MM(z) << std::setprecision(1) << " F" << fspeed << new_line;
     
     currentPosition = Point3(x, y, z);
     estimateCalculator.plan(TimeEstimateCalculator::Position(INT2MM(currentPosition.x), INT2MM(currentPosition.y), INT2MM(currentPosition.z), eToMm(current_e_value)), speed);
@@ -550,9 +526,8 @@ void GCodeExport::writeMove(int x, int y, int z, double speed, double extrusion_
         return;
 
 #ifdef ASSERT_INSANE_OUTPUT
-    assert(speed < 400 && speed > 1); // normal F values occurring in UM2 gcode (this code should not be compiled for release)
+    assert(speed < 200 && speed > 1); // normal F values occurring in UM2 gcode (this code should not be compiled for release)
     assert(currentPosition != no_point3);
-    assert(Point3(x, y, z) != no_point3);
     assert((Point3(x,y,z) - currentPosition).vSize() < MM2INT(300)); // no crazy positions (this code should not be compiled for release)
 #endif //ASSERT_INSANE_OUTPUT
 
@@ -568,14 +543,13 @@ 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)
     {
         Point3 diff = Point3(x,y,z) - getPosition();
         if (isZHopped > 0)
         {
-            *output_stream << "G1 Z" << MMtoStream{currentPosition.z} << new_line;
+            *output_stream << std::setprecision(3) << "G1 Z" << INT2MM(currentPosition.z) << new_line;
             isZHopped = 0;
         }
         double prime_volume = extruder_attr[current_extruder].prime_volume;
@@ -588,7 +562,7 @@ void GCodeExport::writeMove(int x, int y, int z, double speed, double extrusion_
                 //Assume default UM2 retraction settings.
                 if (prime_volume > 0)
                 {
-                    *output_stream << "G1 F" << PrecisionedDouble{1, extruder_attr[current_extruder].last_retraction_prime_speed * 60} << " " << extruder_attr[current_extruder].extruderCharacter << PrecisionedDouble{5, current_e_value} << new_line;
+                    *output_stream << "G1 F" << (extruder_attr[current_extruder].last_retraction_prime_speed * 60) << " " << extruder_attr[current_extruder].extruderCharacter << std::setprecision(5) << current_e_value << new_line;
                     currentSpeed = extruder_attr[current_extruder].last_retraction_prime_speed;
                 }
                 estimateCalculator.plan(TimeEstimateCalculator::Position(INT2MM(currentPosition.x), INT2MM(currentPosition.y), INT2MM(currentPosition.z), eToMm(current_e_value)), 25.0);
@@ -596,7 +570,7 @@ void GCodeExport::writeMove(int x, int y, int z, double speed, double extrusion_
             else
             {
                 current_e_value += extruder_attr[current_extruder].retraction_e_amount_current;
-                *output_stream << "G1 F" << PrecisionedDouble{1, extruder_attr[current_extruder].last_retraction_prime_speed * 60} << " " << extruder_attr[current_extruder].extruderCharacter << PrecisionedDouble{5, current_e_value} << new_line;
+                *output_stream << "G1 F" << (extruder_attr[current_extruder].last_retraction_prime_speed * 60) << " " << extruder_attr[current_extruder].extruderCharacter << std::setprecision(5) << current_e_value << new_line;
                 currentSpeed = extruder_attr[current_extruder].last_retraction_prime_speed;
                 estimateCalculator.plan(TimeEstimateCalculator::Position(INT2MM(currentPosition.x), INT2MM(currentPosition.y), INT2MM(currentPosition.z), eToMm(current_e_value)), currentSpeed);
             }
@@ -608,7 +582,7 @@ void GCodeExport::writeMove(int x, int y, int z, double speed, double extrusion_
         }
         else if (prime_volume > 0.0)
         {
-            *output_stream << "G1 F" << PrecisionedDouble{1, extruder_attr[current_extruder].last_retraction_prime_speed * 60} << " " << extruder_attr[current_extruder].extruderCharacter << PrecisionedDouble{5, current_e_value} << new_line;
+            *output_stream << "G1 F" << (extruder_attr[current_extruder].last_retraction_prime_speed * 60) << " " << extruder_attr[current_extruder].extruderCharacter << std::setprecision(5) << current_e_value << new_line;
             currentSpeed = extruder_attr[current_extruder].last_retraction_prime_speed;
             estimateCalculator.plan(TimeEstimateCalculator::Position(INT2MM(currentPosition.x), INT2MM(currentPosition.y), INT2MM(currentPosition.z), eToMm(current_e_value)), currentSpeed);
         }
@@ -620,29 +594,37 @@ void GCodeExport::writeMove(int x, int y, int z, double speed, double extrusion_
     {
         *output_stream << "G0";
 
-        CommandSocket::sendLineTo(extruder_attr[current_extruder].retraction_e_amount_current ? PrintFeatureType::MoveRetraction : PrintFeatureType::MoveCombing, Point(x, y), extruder_attr[current_extruder].retraction_e_amount_current ? MM2INT(0.2) : MM2INT(0.1));
+        if (CommandSocket::isInstantiated()) 
+        {
+            // we should send this travel as a non-retraction move
+            cura::Polygons travelPoly;
+            PolygonRef travel = travelPoly.newPoly();
+            travel.add(Point(currentPosition.x, currentPosition.y));
+            travel.add(Point(x, y));
+            CommandSocket::getInstance()->sendPolygons(extruder_attr[current_extruder].retraction_e_amount_current ? PrintFeatureType::MoveRetraction : PrintFeatureType::MoveCombing, layer_nr, travelPoly, extruder_attr[current_extruder].retraction_e_amount_current ? MM2INT(0.2) : MM2INT(0.1));
+        }
     }
 
     if (currentSpeed != speed)
     {
-        *output_stream << " F" << PrecisionedDouble{1, speed * 60};
+        *output_stream << " F" << (speed * 60);
         currentSpeed = speed;
     }
 
-    *output_stream << " X" << MMtoStream{gcode_pos.X} << " Y" << MMtoStream{gcode_pos.Y};
+    *output_stream << std::setprecision(3) << 
+        " X" << INT2MM(gcode_pos.X) << 
+        " Y" << INT2MM(gcode_pos.Y);
     if (z != currentPosition.z + isZHopped)
-    {
-        *output_stream << " Z" << MMtoStream{z + isZHopped};
-    }
+        *output_stream << " Z" << INT2MM(z + isZHopped);
     if (extrusion_mm3_per_mm > 0.000001)
-        *output_stream << " " << extruder_attr[current_extruder].extruderCharacter << PrecisionedDouble{5, current_e_value};
+        *output_stream << " " << extruder_attr[current_extruder].extruderCharacter << std::setprecision(5) << current_e_value;
     *output_stream << new_line;
     
     currentPosition = Point3(x, y, z);
     estimateCalculator.plan(TimeEstimateCalculator::Position(INT2MM(currentPosition.x), INT2MM(currentPosition.y), INT2MM(currentPosition.z), eToMm(current_e_value)), speed);
 }
 
-void GCodeExport::writeRetraction(const RetractionConfig& config, bool force, bool extruder_switch)
+void GCodeExport::writeRetraction(RetractionConfig* config, bool force, bool extruder_switch)
 {
     ExtruderTrainAttributes& extr_attr = extruder_attr[current_extruder];
 
@@ -659,7 +641,7 @@ void GCodeExport::writeRetraction(const RetractionConfig& config, bool force, bo
     }
 
     double old_retraction_e_amount = extr_attr.retraction_e_amount_current;
-    double new_retraction_e_amount = mmToE(config.distance);
+    double new_retraction_e_amount = mmToE(config->distance);
     double retraction_diff_e_amount = old_retraction_e_amount - new_retraction_e_amount;
     if (std::abs(retraction_diff_e_amount) < 0.000001)
     {
@@ -669,23 +651,23 @@ void GCodeExport::writeRetraction(const RetractionConfig& config, bool force, bo
     { // handle retraction limitation
         double current_extruded_volume = getCurrentExtrudedVolume();
         std::deque<double>& extruded_volume_at_previous_n_retractions = extr_attr.extruded_volume_at_previous_n_retractions;
-        while (int(extruded_volume_at_previous_n_retractions.size()) > config.retraction_count_max && !extruded_volume_at_previous_n_retractions.empty()) 
+        while (int(extruded_volume_at_previous_n_retractions.size()) > config->retraction_count_max && !extruded_volume_at_previous_n_retractions.empty()) 
         {
             // extruder switch could have introduced data which falls outside the retraction window
             // also the retraction_count_max could have changed between the last retraction and this
             extruded_volume_at_previous_n_retractions.pop_back();
         }
-        if (!force && config.retraction_count_max <= 0)
+        if (!force && config->retraction_count_max <= 0)
         {
             return;
         }
-        if (!force && int(extruded_volume_at_previous_n_retractions.size()) == config.retraction_count_max
-            && current_extruded_volume < extruded_volume_at_previous_n_retractions.back() + config.retraction_extrusion_window * extr_attr.filament_area) 
+        if (!force && int(extruded_volume_at_previous_n_retractions.size()) == config->retraction_count_max
+            && current_extruded_volume < extruded_volume_at_previous_n_retractions.back() + config->retraction_extrusion_window * extr_attr.filament_area) 
         {
             return;
         }
         extruded_volume_at_previous_n_retractions.push_front(current_extruded_volume);
-        if (int(extruded_volume_at_previous_n_retractions.size()) == config.retraction_count_max + 1) 
+        if (int(extruded_volume_at_previous_n_retractions.size()) == config->retraction_count_max + 1) 
         {
             extruded_volume_at_previous_n_retractions.pop_back();
         }
@@ -708,17 +690,17 @@ void GCodeExport::writeRetraction(const RetractionConfig& config, bool force, bo
     }
     else
     {
-        double speed = ((retraction_diff_e_amount < 0.0)? config.speed : extr_attr.last_retraction_prime_speed) * 60;
+        double speed = ((retraction_diff_e_amount < 0.0)? config->speed : extr_attr.last_retraction_prime_speed) * 60;
         current_e_value += retraction_diff_e_amount;
-        *output_stream << "G1 F" << PrecisionedDouble{1, speed} << " "
-            << extr_attr.extruderCharacter << PrecisionedDouble{5, current_e_value} << new_line;
+        *output_stream << "G1 F" << speed << " "
+            << extr_attr.extruderCharacter << std::setprecision(5) << current_e_value << new_line;
         currentSpeed = speed;
         estimateCalculator.plan(TimeEstimateCalculator::Position(INT2MM(currentPosition.x), INT2MM(currentPosition.y), INT2MM(currentPosition.z), eToMm(current_e_value)), currentSpeed);
-        extr_attr.last_retraction_prime_speed = config.primeSpeed;
+        extr_attr.last_retraction_prime_speed = config->primeSpeed;
     }
 
     extr_attr.retraction_e_amount_current = new_retraction_e_amount; // suppose that for UM2 the retraction amount in the firmware is equal to the provided amount
-    extr_attr.prime_volume += config.prime_volume;
+    extr_attr.prime_volume += config->prime_volume;
 
 }
 
@@ -727,17 +709,7 @@ void GCodeExport::writeZhopStart(int hop_height)
     if (hop_height > 0)
     {
         isZHopped = hop_height;
-        *output_stream << "G1 Z" << MMtoStream{currentPosition.z + isZHopped} << new_line;
-        total_bounding_box.includeZ(currentPosition.z + isZHopped);
-    }
-}
-
-void GCodeExport::writeZhopEnd()
-{
-    if (isZHopped)
-    {
-        isZHopped = 0;
-        *output_stream << "G1 Z" << MMtoStream{currentPosition.z} << new_line;
+        *output_stream << std::setprecision(3) << "G1 Z" << INT2MM(currentPosition.z + isZHopped) << new_line;
     }
 }
 
@@ -761,8 +733,6 @@ void GCodeExport::startExtruder(int new_extruder)
     resetExtrusionValue(); // zero the E value on the new extruder, just to be sure
 
     writeCode(extruder_attr[new_extruder].start_code.c_str());
-    CommandSocket::setExtruderForSend(new_extruder);
-    CommandSocket::setSendCurrentPosition( getPositionXY() );
 
     //Change the Z position so it gets re-writting again. We do not know if the switch code modified the Z position.
     currentPosition.z += 1;
@@ -775,7 +745,7 @@ void GCodeExport::switchExtruder(int new_extruder, const RetractionConfig& retra
 
     bool force = true;
     bool extruder_switch = true;
-    writeRetraction(retraction_config_old_extruder, force, extruder_switch);
+    writeRetraction(&const_cast<RetractionConfig&>(retraction_config_old_extruder), force, extruder_switch);
 
     resetExtrusionValue(); // zero the E value on the old extruder, so that the current_e_value is registered on the old extruder
 
@@ -826,7 +796,7 @@ void GCodeExport::writeFanCommand(double speed)
         if (flavor == EGCodeFlavor::MAKERBOT)
             *output_stream << "M126 T0" << new_line; //value = speed * 255 / 100 // Makerbot cannot set fan speed...;
         else
-            *output_stream << "M106 S" << PrecisionedDouble{1, speed * 255 / 100} << new_line;
+            *output_stream << "M106 S" << (speed * 255 / 100) << new_line;
     }
     else
     {
@@ -842,44 +812,31 @@ void GCodeExport::writeTemperatureCommand(int extruder, double temperature, bool
 {
     if (!wait && extruder_attr[extruder].currentTemperature == temperature)
         return;
-
-    if (flavor == EGCodeFlavor::ULTIGCODE)
-    { // The UM2 family doesn't support temperature commands (they are fixed in the firmware)
-        return;
-    }
-
+    
     if (wait)
         *output_stream << "M109";
     else
         *output_stream << "M104";
     if (extruder != current_extruder)
         *output_stream << " T" << extruder;
-#ifdef ASSERT_INSANE_OUTPUT
-    assert(temperature >= 0);
-#endif // ASSERT_INSANE_OUTPUT
-    *output_stream << " S" << PrecisionedDouble{1, temperature} << new_line;
+    *output_stream << " S" << temperature << new_line;
     extruder_attr[extruder].currentTemperature = temperature;
 }
 
 void GCodeExport::writeBedTemperatureCommand(double temperature, bool wait)
 {
-    if (flavor == EGCodeFlavor::ULTIGCODE)
-    { // The UM2 family doesn't support temperature commands (they are fixed in the firmware)
-        return;
-    }
-
     if (wait)
         *output_stream << "M190 S";
     else
         *output_stream << "M140 S";
-    *output_stream << PrecisionedDouble{1, temperature} << new_line;
+    *output_stream << temperature << new_line;
 }
 
 void GCodeExport::writeAcceleration(double acceleration)
 {
     if (current_acceleration != acceleration)
     {
-        *output_stream << "M204 S" << PrecisionedDouble{0, acceleration} << new_line; // Print and Travel acceleration
+        *output_stream << "M204 S" << acceleration << new_line; // Print and Travel acceleration
         current_acceleration = acceleration;
         estimateCalculator.setAcceleration(acceleration);
     }
@@ -889,40 +846,17 @@ void GCodeExport::writeJerk(double jerk)
 {
     if (current_jerk != jerk)
     {
-        if (getFlavor() == EGCodeFlavor::REPETIER)
-        {
-            *output_stream << "M207 X";
-        }
-        else
-        {
-            *output_stream << "M205 X";
-        }
-        *output_stream << PrecisionedDouble{2, jerk} << new_line;
+        *output_stream << "M205 X" << jerk << new_line;
         current_jerk = jerk;
         estimateCalculator.setMaxXyJerk(jerk);
     }
 }
 
-void GCodeExport::writeMaxZFeedrate(double max_z_feedrate)
-{
-    if (current_max_z_feedrate != max_z_feedrate)
-    {
-        *output_stream << "M203 Z" << PrecisionedDouble{2, max_z_feedrate} << new_line;
-        current_max_z_feedrate = max_z_feedrate;
-        estimateCalculator.setMaxZFeedrate(max_z_feedrate);
-    }
-}
-
-double GCodeExport::getCurrentMaxZFeedrate()
-{
-    return current_max_z_feedrate;
-}
-
 void GCodeExport::finalize(const char* endCode)
 {
     writeFanCommand(0);
     writeCode(endCode);
-    int64_t print_time = getTotalPrintTime();
+    long 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/gcodeExport.h

@@ -42,7 +42,7 @@ private:
         bool prime_pos_is_abs; //!< Whether the prime position is absolute, rather than relative to the last given position
         bool is_primed; //!< Whether this extruder has currently already been primed in this print
 
-        bool is_used; //!< Whether this extruder train is actually used during the printing of all meshgroups
+        bool is_used; //!< Whether this extruder train is actually used during the printing of the current meshgroup
         int nozzle_size; //!< The nozzle size label of the nozzle (e.g. 0.4mm; irrespective of tolerances)
         Point nozzle_offset;
         char extruderCharacter;
@@ -97,18 +97,8 @@ private:
     double currentSpeed; //!< The current speed (F values / 60) in mm/s
     double current_acceleration; //!< The current acceleration in the XY direction (in mm/s^2)
     double current_jerk; //!< The current jerk in the XY direction (in mm/s^3)
-    double current_max_z_feedrate; //!< The current max z speed
 
-    AABB3D total_bounding_box; //!< The bounding box of all g-code.
-
-    /*!
-     * The z position to be used on the next xy move, if the head wasn't in the correct z position yet.
-     * 
-     * \see GCodeExport::writeMove(Point, double, double)
-     * 
-     * \note After GCodeExport::writeMove(Point, double, double) has been called currentPosition.z coincides with this value
-     */
-    int current_layer_z;
+    int zPos; // TODO: why is this different from currentPosition.z ? zPos is set every layer, while currentPosition.z is set every move. However, the z position is generally not changed within a layer!
     int isZHopped; //!< The amount by which the print head is currently z hopped, or zero if it is not z hopped. (A z hop is used during travel moves to avoid collision with other layer parts)
 
     int current_extruder;
@@ -177,18 +167,18 @@ public:
     
     void setOutputStream(std::ostream* stream);
 
-    bool getExtruderIsUsed(const int extruder_nr) const; //!< Returns whether the extruder with the given index is used up until the current meshgroup
+    bool getExtruderIsUsed(int extruder_nr); //!< Returns whether the extruder with the given index is used up until the current meshgroup
 
-    int getNozzleSize(const int extruder_nr) const;
+    int getNozzleSize(int extruder_nr);
 
-    Point getExtruderOffset(const int id) const;
+    Point getExtruderOffset(int id);
 
-    std::string getMaterialGUID(const int extruder_nr) const; //!< returns the GUID of the material used for the nozzle with id \p extruder_nr
+    std::string getMaterialGUID(int extruder_nr); //!< returns the GUID of the material used for the nozzle with id \p extruder_nr
 
-    Point getGcodePos(const int64_t x, const int64_t y, const int extruder_train) const;
+    Point getGcodePos(int64_t x, int64_t y, int extruder_train);
     
     void setFlavor(EGCodeFlavor flavor);
-    EGCodeFlavor getFlavor() const;
+    EGCodeFlavor getFlavor();
     
     void setZ(int z);
     
@@ -251,17 +241,17 @@ public:
     
     void writeDelay(double timeAmount);
     
-    void writeMove(Point p, double speed, double extrusion_mm3_per_mm);
+    void writeMove(Point p, double speed, double extrusion_per_mm);
     
-    void writeMove(Point3 p, double speed, double extrusion_mm3_per_mm);
+    void writeMove(Point3 p, double speed, double extrusion_per_mm);
 private:
-    void writeMove(int x, int y, int z, double speed, double extrusion_mm3_per_mm);
+    void writeMove(int x, int y, int z, double speed, double extrusion_per_mm);
     /*!
      * The writeMove when flavor == BFB
      */
-    void writeMoveBFB(int x, int y, int z, double speed, double extrusion_mm3_per_mm);
+    void writeMoveBFB(int x, int y, int z, double speed, double extrusion_per_mm);
 public:
-    void writeRetraction(const RetractionConfig& config, bool force = false, bool extruder_switch = false);
+    void writeRetraction(RetractionConfig* config, bool force = false, bool extruder_switch = false);
 
     /*!
      * Start a z hop with the given \p hop_height
@@ -270,12 +260,6 @@ public:
      */
     void writeZhopStart(int hop_height);
 
-    /*!
-     * End a z hop: go back to the layer height
-     * 
-     */
-    void writeZhopEnd();
-
     /*!
      * Start the new_extruder: 
      * - set new extruder
@@ -323,18 +307,6 @@ public:
      */
     void writeJerk(double jerk);
 
-    /*!
-     * Write the command for setting the maximum z feedrate to a specific value
-     */
-    void writeMaxZFeedrate(double max_z_feedrate);
-
-    /*!
-     * Get the last set max z feedrate value sent in the gcode.
-     * 
-     * Returns a value <= 0 when no value is set.
-     */
-    double getCurrentMaxZFeedrate();
-
     /*!
      * Set member variables using the settings in \p settings
      * 
@@ -349,17 +321,13 @@ public:
      * See FffGcodeWriter::processStartingCode
      * 
      * \param settings The meshgroup to get the global bed temp from and to get the extruder trains from which to get the nozzle temperatures
-     * \param start_extruder_nr The extruder with which to start this print
      */
-    void setInitialTemps(const MeshGroup& settings, const unsigned int start_extruder_nr);
+    void setInitialTemps(const MeshGroup& settings);
 
     /*!
      * Override or set an initial nozzle temperature as written by GCodeExport::setInitialTemps
      * This is used primarily during better specification of temperatures in LayerPlanBuffer::insertPreheatCommand
      * 
-     * \warning This function must be called before any of the layers in the meshgroup are written to file!
-     * That's because it sets the current temperature in the gcode!
-     * 
      * \param extruder_nr The extruder number for which to better specify the temp
      * \param temp The temp at which the nozzle should be at startup
      */

src/gcodePlanner.cpp

@@ -1,23 +1,32 @@
-/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
 #include <cstring>
-#include "LayerPlan.h"
+#include "gcodePlanner.h"
 #include "pathOrderOptimizer.h"
 #include "sliceDataStorage.h"
+#include "debug.h" // debugging
 #include "utils/polygonUtils.h"
 #include "MergeInfillLines.h"
-#include "raft.h" // getTotalExtraLayers
 
 namespace cura {
 
+TimeMaterialEstimates TimeMaterialEstimates::operator-(const TimeMaterialEstimates& other)
+{
+    return TimeMaterialEstimates(extrude_time - other.extrude_time,unretracted_travel_time - other.unretracted_travel_time,retracted_travel_time - other.retracted_travel_time,material - other.material);
+}
 
-ExtruderPlan::ExtruderPlan(int extruder, Point start_position, int layer_nr, bool is_initial_layer, int layer_thickness, const FanSpeedLayerTimeSettings& fan_speed_layer_time_settings, const RetractionConfig& retraction_config)
+TimeMaterialEstimates& TimeMaterialEstimates::operator-=(const TimeMaterialEstimates& other)
+{
+    extrude_time -= other.extrude_time;
+    unretracted_travel_time -= other.unretracted_travel_time;
+    retracted_travel_time -= other.retracted_travel_time;
+    material -= other.material;
+    return *this;
+}
+
+ExtruderPlan::ExtruderPlan(int extruder, Point start_position, int layer_nr, int layer_thickness, FanSpeedLayerTimeSettings& fan_speed_layer_time_settings, const RetractionConfig& retraction_config)
 : extruder(extruder)
-, heated_pre_travel_time(0)
-, initial_printing_temperature(-1)
-, printing_temperature(-1)
+, required_temp(-1)
 , start_position(start_position)
 , layer_nr(layer_nr)
-, is_initial_layer(is_initial_layer)
 , layer_thickness(layer_thickness)
 , fan_speed_layer_time_settings(fan_speed_layer_time_settings)
 , retraction_config(retraction_config)
@@ -56,7 +65,7 @@ double ExtruderPlan::getFanSpeed()
 }
 
 
-GCodePath* LayerPlan::getLatestPathWithConfig(const GCodePathConfig* config, SpaceFillType space_fill_type, float flow, bool spiralize)
+GCodePath* GCodePlanner::getLatestPathWithConfig(GCodePathConfig* config, SpaceFillType space_fill_type, float flow, bool spiralize)
 {
     std::vector<GCodePath>& paths = extruder_plans.back().paths;
     if (paths.size() > 0 && paths.back().config == config && !paths.back().done && paths.back().flow == flow) // spiralize can only change when a travel path is in between
@@ -64,7 +73,6 @@ GCodePath* LayerPlan::getLatestPathWithConfig(const GCodePathConfig* config, Spa
     paths.emplace_back();
     GCodePath* ret = &paths.back();
     ret->retract = false;
-    ret->perform_prime = false;
     ret->perform_z_hop = false;
     ret->config = config;
     ret->done = false;
@@ -74,33 +82,29 @@ GCodePath* LayerPlan::getLatestPathWithConfig(const GCodePathConfig* config, Spa
     return ret;
 }
 
-void LayerPlan::forceNewPathStart()
+void GCodePlanner::forceNewPathStart()
 {
     std::vector<GCodePath>& paths = extruder_plans.back().paths;
     if (paths.size() > 0)
         paths[paths.size()-1].done = true;
 }
 
-LayerPlan::LayerPlan(const SliceDataStorage& storage, int layer_nr, int z, int layer_thickness, PlanningState last_planned_state, const std::vector<FanSpeedLayerTimeSettings>& fan_speed_layer_time_settings_per_extruder, CombingMode combing_mode, int64_t comb_boundary_offset, bool travel_avoid_other_parts, int64_t travel_avoid_distance)
+GCodePlanner::GCodePlanner(SliceDataStorage& storage, unsigned int layer_nr, int z, int layer_thickness, Point last_position, int current_extruder, bool is_inside_mesh, std::vector<FanSpeedLayerTimeSettings>& fan_speed_layer_time_settings_per_extruder, CombingMode combing_mode, int64_t comb_boundary_offset, bool travel_avoid_other_parts, int64_t travel_avoid_distance)
 : storage(storage)
-, configs_storage(storage, layer_nr, layer_thickness)
 , layer_nr(layer_nr)
-, is_initial_layer(layer_nr == 0 - Raft::getTotalExtraLayers(storage))
 , z(z)
 , layer_thickness(layer_thickness)
-, start_position(last_planned_state.last_position)
-, lastPosition(last_planned_state.last_position)
-, has_prime_tower_planned(false)
-, last_extruder_previous_layer(last_planned_state.current_extruder)
-, last_planned_extruder_setting_base(storage.meshgroup->getExtruderTrain(last_planned_state.current_extruder))
+, start_position(last_position)
+, lastPosition(last_position)
+, last_extruder_previous_layer(current_extruder)
+, last_planned_extruder_setting_base(storage.meshgroup->getExtruderTrain(current_extruder))
 , comb_boundary_inside(computeCombBoundaryInside(combing_mode))
 , fan_speed_layer_time_settings_per_extruder(fan_speed_layer_time_settings_per_extruder)
 {
-    int current_extruder = last_planned_state.current_extruder;
     extruder_plans.reserve(storage.meshgroup->getExtruderCount());
-    extruder_plans.emplace_back(current_extruder, start_position, layer_nr, is_initial_layer, layer_thickness, fan_speed_layer_time_settings_per_extruder[current_extruder], storage.retraction_config_per_extruder[current_extruder]);
+    extruder_plans.emplace_back(current_extruder, start_position, layer_nr, layer_thickness, fan_speed_layer_time_settings_per_extruder[current_extruder], storage.retraction_config_per_extruder[current_extruder]);
     comb = nullptr;
-    was_inside = last_planned_state.is_inside_mesh_layer_part;
+    was_inside = is_inside_mesh; 
     is_inside = false; // assumes the next move will not be to inside a layer part (overwritten just before going into a layer part)
     if (combing_mode != CombingMode::OFF)
     {
@@ -110,19 +114,19 @@ LayerPlan::LayerPlan(const SliceDataStorage& storage, int layer_nr, int z, int l
         comb = nullptr;
 }
 
-LayerPlan::~LayerPlan()
+GCodePlanner::~GCodePlanner()
 {
     if (comb)
         delete comb;
 }
 
-SettingsBaseVirtual* LayerPlan::getLastPlannedExtruderTrainSettings()
+SettingsBaseVirtual* GCodePlanner::getLastPlannedExtruderTrainSettings()
 {
     return last_planned_extruder_setting_base;
 }
 
 
-Polygons LayerPlan::computeCombBoundaryInside(CombingMode combing_mode)
+Polygons GCodePlanner::computeCombBoundaryInside(CombingMode combing_mode)
 {
     if (combing_mode == CombingMode::OFF)
     {
@@ -142,12 +146,12 @@ Polygons LayerPlan::computeCombBoundaryInside(CombingMode combing_mode)
     else 
     {
         Polygons comb_boundary;
-        for (const SliceMeshStorage& mesh : storage.meshes)
+        for (SliceMeshStorage& mesh : storage.meshes)
         {
-            const SliceLayer& layer = mesh.layers[layer_nr];
+            SliceLayer& layer = mesh.layers[layer_nr];
             if (mesh.getSettingAsCombingMode("retraction_combing") == CombingMode::NO_SKIN)
             {
-                for (const SliceLayerPart& part : layer.parts)
+                for (SliceLayerPart& part : layer.parts)
                 {
                     comb_boundary.add(part.infill_area);
                 }
@@ -165,12 +169,12 @@ Polygons LayerPlan::computeCombBoundaryInside(CombingMode combing_mode)
     }
 }
 
-void LayerPlan::setIsInside(bool _is_inside)
+void GCodePlanner::setIsInside(bool _is_inside)
 {
     is_inside = _is_inside;
 }
 
-bool LayerPlan::setExtruder(int extruder)
+bool GCodePlanner::setExtruder(int extruder)
 {
     if (extruder == getExtruder())
     {
@@ -198,8 +202,7 @@ bool LayerPlan::setExtruder(int extruder)
     }
     else 
     {
-        extruder_plans.emplace_back(extruder, lastPosition, layer_nr, is_initial_layer, layer_thickness, fan_speed_layer_time_settings_per_extruder[extruder], storage.retraction_config_per_extruder[extruder]);
-        assert((int)extruder_plans.size() <= storage.meshgroup->getExtruderCount() && "Never use the same extruder twice on one layer!");
+        extruder_plans.emplace_back(extruder, lastPosition, layer_nr, layer_thickness, fan_speed_layer_time_settings_per_extruder[extruder], storage.retraction_config_per_extruder[extruder]);
     }
     last_planned_extruder_setting_base = storage.meshgroup->getExtruderTrain(extruder);
 
@@ -223,7 +226,7 @@ bool LayerPlan::setExtruder(int extruder)
     return true;
 }
 
-void LayerPlan::moveInsideCombBoundary(int distance)
+void GCodePlanner::moveInsideCombBoundary(int distance)
 {
     int max_dist2 = MM2INT(2.0) * MM2INT(2.0); // if we are further than this distance, we conclude we are not inside even though we thought we were.
     // this function is to be used to move from the boudary of a part to inside the part
@@ -241,15 +244,15 @@ void LayerPlan::moveInsideCombBoundary(int distance)
     }
 }
 
-GCodePath& LayerPlan::addTravel(Point p)
+void GCodePlanner::addTravel(Point p)
 {
     GCodePath* path = nullptr;
-    const GCodePathConfig& travel_config = configs_storage.travel_config_per_extruder[getExtruder()];
-    const RetractionConfig& retraction_config = storage.retraction_config_per_extruder[getExtruder()];
+    GCodePathConfig& travel_config = storage.travel_config_per_extruder[getExtruder()];
+    RetractionConfig& retraction_config = storage.retraction_config_per_extruder[getExtruder()];
     
     bool combed = false;
 
-    const SettingsBaseVirtual* extr = getLastPlannedExtruderTrainSettings();
+    SettingsBaseVirtual* extr = getLastPlannedExtruderTrainSettings();
 
     const bool perform_z_hops = extr->getSettingBoolean("retraction_hop_enabled");
 
@@ -327,92 +330,57 @@ GCodePath& LayerPlan::addTravel(Point p)
         }
     }
 
-    GCodePath& ret = addTravel_simple(p, path);
+    addTravel_simple(p, path);
     was_inside = is_inside;
-    return ret;
 }
 
-GCodePath& LayerPlan::addTravel_simple(Point p, GCodePath* path)
+void GCodePlanner::addTravel_simple(Point p, GCodePath* path)
 {
     if (path == nullptr)
     {
-        path = getLatestPathWithConfig(&configs_storage.travel_config_per_extruder[getExtruder()], SpaceFillType::None);
+        path = getLatestPathWithConfig(&storage.travel_config_per_extruder[getExtruder()], SpaceFillType::None);
     }
     path->points.push_back(p);
     lastPosition = p;
-    return *path;
 }
 
-void LayerPlan::planPrime()
-{
-    forceNewPathStart();
-    GCodePath& prime_travel = addTravel_simple(lastPosition + Point(0, 100));
-    prime_travel.retract = false;
-    prime_travel.perform_prime = true;
-    forceNewPathStart();
-}
 
-void LayerPlan::addExtrusionMove(Point p, const GCodePathConfig* config, SpaceFillType space_fill_type, float flow, bool spiralize)
+void GCodePlanner::addExtrusionMove(Point p, GCodePathConfig* config, SpaceFillType space_fill_type, float flow, bool spiralize)
 {
     getLatestPathWithConfig(config, space_fill_type, flow, spiralize)->points.push_back(p);
     lastPosition = p;
 }
 
-void LayerPlan::addPolygon(ConstPolygonRef polygon, int start_idx, const GCodePathConfig* config, WallOverlapComputation* wall_overlap_computation, coord_t wall_0_wipe_dist, bool spiralize)
+void GCodePlanner::addPolygon(PolygonRef polygon, int startIdx, GCodePathConfig* config, WallOverlapComputation* wall_overlap_computation, bool spiralize)
 {
-    Point p0 = polygon[start_idx];
+    Point p0 = polygon[startIdx];
     addTravel(p0);
-    for (unsigned int point_idx = 1; point_idx < polygon.size(); point_idx++)
+    for(unsigned int i=1; i<polygon.size(); i++)
     {
-        Point p1 = polygon[(start_idx + point_idx) % polygon.size()];
+        Point p1 = polygon[(startIdx + i) % polygon.size()];
         float flow = (wall_overlap_computation)? wall_overlap_computation->getFlow(p0, p1) : 1.0;
         addExtrusionMove(p1, config, SpaceFillType::Polygons, flow, spiralize);
         p0 = p1;
     }
     if (polygon.size() > 2)
     {
-        const Point& p1 = polygon[start_idx];
+        Point& p1 = polygon[startIdx];
         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)
-        { // apply outer wall wipe
-            p0 = polygon[start_idx];
-            int distance_traversed = 0;
-            for (unsigned int point_idx = 1; ; point_idx++)
-            {
-                Point p1 = polygon[(start_idx + point_idx) % polygon.size()];
-                int p0p1_dist = vSize(p1 - p0);
-                if (distance_traversed + p0p1_dist >= wall_0_wipe_dist)
-                {
-                    Point vector = p1 - p0;
-                    Point half_way = p0 + normal(vector, wall_0_wipe_dist - distance_traversed);
-                    addTravel_simple(half_way);
-                    break;
-                }
-                else
-                {
-                    addTravel_simple(p1);
-                    distance_traversed += p0p1_dist;
-                }
-                p0 = p1;
-            }
-            forceNewPathStart();
-        }
     }
     else 
     {
-        logWarning("WARNING: line added as polygon! (LayerPlan)\n");
+        logWarning("WARNING: line added as polygon! (gcodePlanner)\n");
     }
 }
 
-void LayerPlan::addPolygonsByOptimizer(const Polygons& polygons, const GCodePathConfig* config, WallOverlapComputation* wall_overlap_computation, 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, bool spiralize)
 {
     if (polygons.size() == 0)
     {
         return;
     }
-    PathOrderOptimizer orderOptimizer(lastPosition, z_seam_pos, z_seam_type);
+    PathOrderOptimizer orderOptimizer(lastPosition, z_seam_type);
     for (unsigned int poly_idx = 0; poly_idx < polygons.size(); poly_idx++)
     {
         orderOptimizer.addPolygon(polygons[poly_idx]);
@@ -420,10 +388,10 @@ void LayerPlan::addPolygonsByOptimizer(const Polygons& polygons, const GCodePath
     orderOptimizer.optimize();
     for (unsigned int poly_idx : orderOptimizer.polyOrder)
     {
-        addPolygon(polygons[poly_idx], orderOptimizer.polyStart[poly_idx], config, wall_overlap_computation, wall_0_wipe_dist, spiralize);
+        addPolygon(polygons[poly_idx], orderOptimizer.polyStart[poly_idx], config, wall_overlap_computation, spiralize);
     }
 }
-void LayerPlan::addLinesByOptimizer(const Polygons& polygons, const GCodePathConfig* config, SpaceFillType space_fill_type, int wipe_dist)
+void GCodePlanner::addLinesByOptimizer(Polygons& polygons, GCodePathConfig* config, SpaceFillType space_fill_type, int wipe_dist)
 {
     LineOrderOptimizer orderOptimizer(lastPosition);
     for (unsigned int line_idx = 0; line_idx < polygons.size(); line_idx++)
@@ -433,12 +401,12 @@ void LayerPlan::addLinesByOptimizer(const Polygons& polygons, const GCodePathCon
     orderOptimizer.optimize();
     for (int poly_idx : orderOptimizer.polyOrder)
     {
-        ConstPolygonRef polygon = polygons[poly_idx];
+        PolygonRef polygon = polygons[poly_idx];
         int start = orderOptimizer.polyStart[poly_idx];
         int end = 1 - start;
-        const Point& p0 = polygon[start];
+        Point& p0 = polygon[start];
         addTravel(p0);
-        const Point& p1 = polygon[end];
+        Point& p1 = polygon[end];
         addExtrusionMove(p1, config, space_fill_type);
         if (wipe_dist != 0)
         {
@@ -556,7 +524,7 @@ TimeMaterialEstimates ExtruderPlan::computeNaiveTimeEstimates()
 
 void ExtruderPlan::processFanSpeedAndMinimalLayerTime(bool force_minimal_layer_time)
 {
-    const FanSpeedLayerTimeSettings& fsml = fan_speed_layer_time_settings;
+    FanSpeedLayerTimeSettings& fsml = fan_speed_layer_time_settings;
     TimeMaterialEstimates estimates = computeNaiveTimeEstimates();
     totalPrintTime = estimates.getTotalTime();
     if (force_minimal_layer_time)
@@ -595,27 +563,26 @@ void ExtruderPlan::processFanSpeedAndMinimalLayerTime(bool force_minimal_layer_t
     }
     /*
     Supposing no influence of minimal layer time; i.e. layer time > min layer time fan speed min:
-
-              max..   fan 'full' on layer
-                   |  :
-                   |  :
-      ^       min..|..:________________
-     fan           |  /
-    speed          | /
-          speed_0..|/
-                   |
-                   |__________________
-                     layer nr >
-
+    
+           max..   fan 'full' on layer
+                |  :
+                |  :
+      ^    min..|..:________________
+     fan        |  / 
+    speed       | / 
+          zero..|/__________________
+                  layer nr >
+                  
+       
     */
     if (layer_nr < fsml.cool_fan_full_layer)
     {
         //Slow down the fan on the layers below the [cool_fan_full_layer], where layer 0 is speed 0.
-        fan_speed = fsml.cool_fan_speed_0 + (fan_speed - fsml.cool_fan_speed_0) * std::max(0, layer_nr) / fsml.cool_fan_full_layer;
+        fan_speed = fan_speed * layer_nr / fsml.cool_fan_full_layer;
     }
 }
 
-TimeMaterialEstimates LayerPlan::computeNaiveTimeEstimates()
+TimeMaterialEstimates GCodePlanner::computeNaiveTimeEstimates()
 {
     TimeMaterialEstimates ret;
     for (ExtruderPlan& extruder_plan : extruder_plans)
@@ -625,7 +592,7 @@ TimeMaterialEstimates LayerPlan::computeNaiveTimeEstimates()
     return ret;
 }
 
-void LayerPlan::processFanSpeedAndMinimalLayerTime()
+void GCodePlanner::processFanSpeedAndMinimalLayerTime()
 {
     for (unsigned int extr_plan_idx = 0; extr_plan_idx < extruder_plans.size(); extr_plan_idx++)
     {
@@ -637,140 +604,97 @@ void LayerPlan::processFanSpeedAndMinimalLayerTime()
 
 
 
-void LayerPlan::writeGCode(GCodeExport& gcode)
+void GCodePlanner::writeGCode(GCodeExport& gcode)
 {
-    CommandSocket::setLayerForSend(layer_nr);
-    CommandSocket::setSendCurrentPosition( gcode.getPositionXY() );
+    completeConfigs();
+    
     gcode.setLayerNr(layer_nr);
     
     gcode.writeLayerComment(layer_nr);
-
-    if (layer_nr == 1 - Raft::getTotalExtraLayers(storage))
-    {
-        bool wait = false;
-        gcode.writeBedTemperatureCommand(storage.getSettingInDegreeCelsius("material_bed_temperature"), wait);
-    }
-
+    
     gcode.setZ(z);
     
     
-    const GCodePathConfig* last_extrusion_config = nullptr; // used to check whether we need to insert a TYPE comment in the gcode.
+    GCodePathConfig* last_extrusion_config = nullptr; // used to check whether we need to insert a TYPE comment in the gcode.
 
     int extruder = gcode.getExtruderNr();
-    bool acceleration_enabled = storage.getSettingBoolean("acceleration_enabled");
-    bool jerk_enabled = storage.getSettingBoolean("jerk_enabled");
 
     for(unsigned int extruder_plan_idx = 0; extruder_plan_idx < extruder_plans.size(); extruder_plan_idx++)
     {
-        ExtruderPlan& extruder_plan = extruder_plans[extruder_plan_idx];
-        const RetractionConfig& retraction_config = storage.retraction_config_per_extruder[extruder_plan.extruder];
+        RetractionConfig& retraction_config = storage.retraction_config_per_extruder[gcode.getExtruderNr()];
 
+        ExtruderPlan& extruder_plan = extruder_plans[extruder_plan_idx];
         if (extruder != extruder_plan.extruder)
         {
             int prev_extruder = extruder;
             extruder = extruder_plan.extruder;
             gcode.switchExtruder(extruder, storage.extruder_switch_retraction_config_per_extruder[prev_extruder]);
 
-            const ExtruderTrain* train = storage.meshgroup->getExtruderTrain(extruder);
-            if (train->getSettingInMillimetersPerSecond("max_feedrate_z_override") > 0)
-            {
-                gcode.writeMaxZFeedrate(train->getSettingInMillimetersPerSecond("max_feedrate_z_override"));
-            }
-
             { // require printing temperature to be met
                 constexpr bool wait = true;
-                gcode.writeTemperatureCommand(extruder, extruder_plan.initial_printing_temperature, wait);
+                gcode.writeTemperatureCommand(extruder, extruder_plan.required_temp, wait);
             }
 
             // prime extruder if it hadn't been used yet
             gcode.writePrimeTrain(storage.meshgroup->getExtruderTrain(extruder)->getSettingInMillimetersPerSecond("speed_travel"));
-            gcode.writeRetraction(retraction_config);
+            gcode.writeRetraction(&retraction_config);
 
             if (extruder_plan.prev_extruder_standby_temp)
             { // turn off previous extruder
                 constexpr bool wait = false;
-                double prev_extruder_temp = *extruder_plan.prev_extruder_standby_temp;
-                int prev_layer_nr = (extruder_plan_idx == 0)? layer_nr - 1 : layer_nr;
-                if (prev_layer_nr == storage.max_print_height_per_extruder[prev_extruder])
-                {
-                    prev_extruder_temp = 0; // TODO ? should there be a setting for extruder_off_temperature ?
-                }
-                gcode.writeTemperatureCommand(prev_extruder, prev_extruder_temp, wait);
+                gcode.writeTemperatureCommand(prev_extruder, *extruder_plan.prev_extruder_standby_temp, wait);
             }
         }
-        else if (extruder_plan_idx == 0 && layer_nr != 0 && storage.meshgroup->getExtruderTrain(extruder)->getSettingBoolean("retract_at_layer_change"))
-        {
-            gcode.writeRetraction(retraction_config);
-        }
         gcode.writeFanCommand(extruder_plan.getFanSpeed());
         std::vector<GCodePath>& paths = extruder_plan.paths;
 
         extruder_plan.inserts.sort([](const NozzleTempInsert& a, const NozzleTempInsert& b) -> bool { 
                 return  a.path_idx < b.path_idx; 
             } );
-
-        const ExtruderTrain* train = storage.meshgroup->getExtruderTrain(extruder);
-        if (train->getSettingInMillimetersPerSecond("max_feedrate_z_override") > 0)
-        {
-            gcode.writeMaxZFeedrate(train->getSettingInMillimetersPerSecond("max_feedrate_z_override"));
-        }
-        bool speed_equalize_flow_enabled = train->getSettingBoolean("speed_equalize_flow_enabled");
-        double speed_equalize_flow_max = train->getSettingInMillimetersPerSecond("speed_equalize_flow_max");
-        int64_t nozzle_size = gcode.getNozzleSize(extruder);
-
+        
         for(unsigned int path_idx = 0; path_idx < paths.size(); path_idx++)
         {
             extruder_plan.handleInserts(path_idx, gcode);
             
             GCodePath& path = paths[path_idx];
 
-            if (path.perform_prime)
-            {
-                gcode.writePrimeTrain(train->getSettingInMillimetersPerSecond("speed_travel"));
-                gcode.writeRetraction(retraction_config);
-            }
-
-            if (acceleration_enabled)
+            if (storage.getSettingBoolean("acceleration_enabled"))
             {
                 gcode.writeAcceleration(path.config->getAcceleration());
             }
-            if (jerk_enabled)
+            if (storage.getSettingBoolean("jerk_enabled"))
             {
                 gcode.writeJerk(path.config->getJerk());
             }
 
             if (path.retract)
             {
-                gcode.writeRetraction(retraction_config);
+                gcode.writeRetraction(&retraction_config);
                 if (path.perform_z_hop)
                 {
                     gcode.writeZhopStart(retraction_config.zHop);
                 }
-                else
-                {
-                    gcode.writeZhopEnd();
-                }
             }
             if (!path.config->isTravelPath() && last_extrusion_config != path.config)
             {
                 gcode.writeTypeComment(path.config->type);
                 last_extrusion_config = path.config;
             }
-
             double speed = path.config->getSpeed();
 
-            // Apply the relevant factor
-            if (path.config->isTravelPath())
+            if (path.isTravelPath())// Only apply the extrudeSpeed to extrusion moves
                 speed *= extruder_plan.getTravelSpeedFactor();
             else
                 speed *= extruder_plan.getExtrudeSpeedFactor();
-
-            if (MergeInfillLines(gcode, layer_nr, paths, extruder_plan, configs_storage.travel_config_per_extruder[extruder], nozzle_size, speed_equalize_flow_enabled, speed_equalize_flow_max).mergeInfillLines(path_idx)) // !! has effect on path_idx !!
+            
+            int64_t nozzle_size = 400; // TODO
+            
+            if (MergeInfillLines(gcode, layer_nr, paths, extruder_plan, storage.travel_config_per_extruder[extruder], nozzle_size).mergeInfillLines(speed, path_idx)) // !! has effect on path_idx !!
             { // !! has effect on path_idx !!
                 // works when path_idx is the index of the travel move BEFORE the infill lines to be merged
                 continue;
             }
-
+            
             if (path.config->isTravelPath())
             { // early comp for travel paths, which are handled more simply
                 for(unsigned int point_idx = 0; point_idx < path.points.size(); point_idx++)
@@ -788,7 +712,7 @@ void LayerPlan::writeGCode(GCodeExport& gcode)
             bool spiralize = path.spiralize;
             if (!spiralize) // normal (extrusion) move (with coasting
             {
-                const CoastingConfig& coasting_config = storage.coasting_config[extruder];
+                CoastingConfig& coasting_config = storage.coasting_config[extruder];
                 bool coasting = coasting_config.coasting_enable; 
                 if (coasting)
                 {
@@ -807,7 +731,7 @@ void LayerPlan::writeGCode(GCodeExport& gcode)
                         && shorterThen(paths[path_idx+2].points.back() - paths[path_idx+1].points.back(), 2 * nozzle_size) // consecutive extrusion is close by
                     )
                     {
-                        sendLineTo(paths[path_idx+2].config->type, paths[path_idx+2].points.back(), paths[path_idx+2].getLineWidth());
+                        sendPolygon(paths[path_idx+2].config->type, gcode.getPositionXY(), paths[path_idx+2].points.back(), paths[path_idx+2].getLineWidth());
                         gcode.writeMove(paths[path_idx+2].points.back(), speed, paths[path_idx+1].getExtrusionMM3perMM());
                         path_idx += 2;
                     }
@@ -815,7 +739,7 @@ void LayerPlan::writeGCode(GCodeExport& gcode)
                     {
                         for(unsigned int point_idx = 0; point_idx < path.points.size(); point_idx++)
                         {
-                            sendLineTo(path.config->type, path.points[point_idx], path.getLineWidth());
+                            sendPolygon(path.config->type, gcode.getPositionXY(), path.points[point_idx], path.getLineWidth());
                             gcode.writeMove(path.points[point_idx], speed, path.getExtrusionMM3perMM());
                         }
                     }
@@ -848,7 +772,7 @@ void LayerPlan::writeGCode(GCodeExport& gcode)
                         length += vSizeMM(p0 - p1);
                         p0 = p1;
                         gcode.setZ(z + layer_thickness * length / totalLength);
-                        sendLineTo(path.config->type, path.points[point_idx], path.getLineWidth());
+                        sendPolygon(path.config->type, gcode.getPositionXY(), path.points[point_idx], path.getLineWidth());
                         gcode.writeMove(path.points[point_idx], speed, path.getExtrusionMM3perMM());
                     }
                 }
@@ -856,18 +780,19 @@ void LayerPlan::writeGCode(GCodeExport& gcode)
             }
         } // paths for this extruder /\  .
 
+        ExtruderTrain* train = storage.meshgroup->getExtruderTrain(extruder);
         if (train->getSettingBoolean("cool_lift_head") && extruder_plan.extraTime > 0.0)
         {
             gcode.writeComment("Small layer, adding delay");
-            const RetractionConfig& retraction_config = storage.retraction_config_per_extruder[gcode.getExtruderNr()];
-            gcode.writeRetraction(retraction_config);
+            RetractionConfig& retraction_config = storage.retraction_config_per_extruder[gcode.getExtruderNr()];
+            gcode.writeRetraction(&retraction_config);
             if (extruder_plan_idx == extruder_plans.size() - 1 || !train->getSettingBoolean("machine_extruder_end_pos_abs"))
             { // only move the head if it's the last extruder plan; otherwise it's already at the switching bay area 
                 // or do it anyway when we switch extruder in-place
                 gcode.setZ(gcode.getPositionZ() + MM2INT(3.0));
-                gcode.writeMove(gcode.getPositionXY(), configs_storage.travel_config_per_extruder[extruder].getSpeed(), 0);
+                gcode.writeMove(gcode.getPositionXY(), storage.travel_config_per_extruder[extruder].getSpeed(), 0);
                 // TODO: is this safe?! wouldn't the head move into the sides then?!
-                gcode.writeMove(gcode.getPositionXY() - Point(-MM2INT(20.0), 0), configs_storage.travel_config_per_extruder[extruder].getSpeed(), 0);
+                gcode.writeMove(gcode.getPositionXY() - Point(-MM2INT(20.0), 0), storage.travel_config_per_extruder[extruder].getSpeed(), 0);
             }
             gcode.writeDelay(extruder_plan.extraTime);
         }
@@ -878,7 +803,7 @@ void LayerPlan::writeGCode(GCodeExport& gcode)
     gcode.updateTotalPrintTime();
 }
 
-void LayerPlan::overrideFanSpeeds(double speed)
+void GCodePlanner::overrideFanSpeeds(double speed)
 {
     for (ExtruderPlan& extruder_plan : extruder_plans)
     {
@@ -887,7 +812,81 @@ void LayerPlan::overrideFanSpeeds(double speed)
 }
 
 
-bool LayerPlan::makeRetractSwitchRetract(GCodeExport& gcode, unsigned int extruder_plan_idx, unsigned int path_idx)
+void GCodePlanner::completeConfigs()
+{
+    storage.support_config.setLayerHeight(layer_thickness);
+    storage.support_roof_config.setLayerHeight(layer_thickness);
+    
+    for (SliceMeshStorage& mesh : storage.meshes)
+    {
+        mesh.inset0_config.setLayerHeight(layer_thickness);
+
+        mesh.insetX_config.setLayerHeight(layer_thickness);
+        mesh.skin_config.setLayerHeight(layer_thickness);
+        for(unsigned int idx=0; idx<MAX_INFILL_COMBINE; idx++)
+        {
+            mesh.infill_config[idx].setLayerHeight(layer_thickness);
+        }
+    }
+    
+    storage.primeTower.setConfigs(storage.meshgroup, layer_thickness);
+    
+    processInitialLayersSpeedup();
+}
+
+
+void GCodePlanner::processInitialLayersSpeedup()
+{
+    int initial_speedup_layers = storage.getSettingAsCount("speed_slowdown_layers");
+    if (static_cast<int>(layer_nr) < initial_speedup_layers)
+    {
+        GCodePathConfig::BasicConfig initial_layer_speed_config;
+        int extruder_nr_support_infill = storage.getSettingAsIndex((layer_nr == 0)? "support_extruder_nr_layer_0" : "support_infill_extruder_nr");
+        initial_layer_speed_config.speed = storage.meshgroup->getExtruderTrain(extruder_nr_support_infill)->getSettingInMillimetersPerSecond("speed_layer_0");
+        initial_layer_speed_config.acceleration = storage.meshgroup->getExtruderTrain(extruder_nr_support_infill)->getSettingInMillimetersPerSecond("acceleration_layer_0");
+        initial_layer_speed_config.jerk = storage.meshgroup->getExtruderTrain(extruder_nr_support_infill)->getSettingInMillimetersPerSecond("jerk_layer_0");
+
+        storage.support_config.smoothSpeed(initial_layer_speed_config, layer_nr, initial_speedup_layers);
+
+        int extruder_nr_support_roof = storage.getSettingAsIndex("support_roof_extruder_nr");
+        initial_layer_speed_config.speed = storage.meshgroup->getExtruderTrain(extruder_nr_support_roof)->getSettingInMillimetersPerSecond("speed_layer_0");
+        initial_layer_speed_config.acceleration = storage.meshgroup->getExtruderTrain(extruder_nr_support_roof)->getSettingInMillimetersPerSecond("acceleration_layer_0");
+        initial_layer_speed_config.jerk = storage.meshgroup->getExtruderTrain(extruder_nr_support_roof)->getSettingInMillimetersPerSecond("jerk_layer_0");
+        storage.support_roof_config.smoothSpeed(initial_layer_speed_config, layer_nr, initial_speedup_layers);
+        for (SliceMeshStorage& mesh : storage.meshes)
+        {
+            initial_layer_speed_config.speed = mesh.getSettingInMillimetersPerSecond("speed_layer_0");
+            initial_layer_speed_config.acceleration = mesh.getSettingInMillimetersPerSecond("acceleration_layer_0");
+            initial_layer_speed_config.jerk = mesh.getSettingInMillimetersPerSecond("jerk_layer_0");
+            mesh.inset0_config.smoothSpeed(initial_layer_speed_config, layer_nr, initial_speedup_layers);
+            mesh.insetX_config.smoothSpeed(initial_layer_speed_config, layer_nr, initial_speedup_layers);
+            mesh.skin_config.smoothSpeed(initial_layer_speed_config, layer_nr, initial_speedup_layers);
+            for (unsigned int idx = 0; idx < MAX_INFILL_COMBINE; idx++)
+            {
+                mesh.infill_config[idx].smoothSpeed(initial_layer_speed_config, layer_nr, initial_speedup_layers);
+            }
+        }
+    }
+    else if (static_cast<int>(layer_nr) == initial_speedup_layers)
+    {
+        storage.support_config.setSpeedIconic();
+        storage.support_roof_config.setSpeedIconic();
+        for (SliceMeshStorage& mesh : storage.meshes)
+        {
+            mesh.inset0_config.setSpeedIconic();
+            mesh.insetX_config.setSpeedIconic();
+            mesh.skin_config.setSpeedIconic();
+            for (unsigned int idx = 0; idx < MAX_INFILL_COMBINE; idx++)
+            {
+                mesh.infill_config[idx].setSpeedIconic();
+            }
+        }
+    }
+}
+
+
+
+bool GCodePlanner::makeRetractSwitchRetract(GCodeExport& gcode, unsigned int extruder_plan_idx, unsigned int path_idx)
 {
     std::vector<GCodePath>& paths = extruder_plans[extruder_plan_idx].paths;
     for (unsigned int path_idx2 = path_idx + 1; path_idx2 < paths.size(); path_idx2++)
@@ -913,7 +912,7 @@ bool LayerPlan::makeRetractSwitchRetract(GCodeExport& gcode, unsigned int extrud
     }
 }
     
-bool LayerPlan::writePathWithCoasting(GCodeExport& gcode, unsigned int extruder_plan_idx, unsigned int path_idx, int64_t layerThickness, double coasting_volume, double coasting_speed, double coasting_min_volume)
+bool GCodePlanner::writePathWithCoasting(GCodeExport& gcode, unsigned int extruder_plan_idx, unsigned int path_idx, int64_t layerThickness, double coasting_volume, double coasting_speed, double coasting_min_volume)
 {
     if (coasting_volume <= 0) 
     { 
@@ -1008,10 +1007,10 @@ bool LayerPlan::writePathWithCoasting(GCodeExport& gcode, unsigned int extruder_
     { // write normal extrude path:
         for(unsigned int point_idx = 0; point_idx <= point_idx_before_start; point_idx++)
         {
-            sendLineTo(path.config->type, path.points[point_idx], path.getLineWidth());
+            sendPolygon(path.config->type, gcode.getPositionXY(), path.points[point_idx], path.getLineWidth());
             gcode.writeMove(path.points[point_idx], extrude_speed, path.getExtrusionMM3perMM());
         }
-        sendLineTo(path.config->type, start, path.getLineWidth());
+        sendPolygon(path.config->type, gcode.getPositionXY(), start, path.getLineWidth());
         gcode.writeMove(start, extrude_speed, path.getExtrusionMM3perMM());
     }
 

src/gcodePlanner.h

@@ -1,14 +1,10 @@
-/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
-#ifndef LAYER_PLAN_H
-#define LAYER_PLAN_H
+#ifndef GCODE_PLANNER_H
+#define GCODE_PLANNER_H
 
 #include <vector>
 
 #include "gcodeExport.h"
 #include "pathPlanning/Comb.h"
-#include "pathPlanning/GCodePath.h"
-#include "pathPlanning/NozzleTempInsert.h"
-#include "pathPlanning/TimeMaterialEstimates.h"
 #include "utils/polygon.h"
 #include "utils/logoutput.h"
 #include "wallOverlap.h"
@@ -16,7 +12,6 @@
 #include "FanSpeedLayerTime.h"
 #include "SpaceFillType.h"
 #include "GCodePathConfig.h"
-#include "settings/PathConfigStorage.h"
 
 #include "utils/optional.h"
 
@@ -25,7 +20,250 @@ namespace cura
 
 class SliceDataStorage;
 
-class LayerPlan; // forward declaration so that ExtruderPlan can be a friend
+/*!
+ * A gcode command to insert before a specific path.
+ * 
+ * Currently only used for preheat commands
+ */
+struct NozzleTempInsert
+{
+    const unsigned int path_idx; //!< The path before which to insert this command
+    double time_after_path_start; //!< The time after the start of the path, before which to insert the command // TODO: use this to insert command in between moves in a path!
+    int extruder; //!< The extruder for which to set the temp
+    double temperature; //!< The temperature of the temperature command to insert
+    bool wait; //!< Whether to wait for the temperature to be reached
+    NozzleTempInsert(unsigned int path_idx, int extruder, double temperature, bool wait, double time_after_path_start = 0.0)
+    : path_idx(path_idx)
+    , time_after_path_start(time_after_path_start)
+    , extruder(extruder)
+    , temperature(temperature)
+    , wait(wait)
+    {}
+    
+    /*!
+     * Write the temperature command at the current position in the gcode.
+     * \param gcode The actual gcode writer
+     */
+    void write(GCodeExport& gcode)
+    {
+        gcode.writeTemperatureCommand(extruder, temperature, wait);
+    }
+};
+
+class ExtruderPlan; // forward declaration so that TimeMaterialEstimates can be a friend
+
+
+/*!
+ * Time and material estimates for a portion of paths, e.g. layer, extruder plan, path.
+ */
+class TimeMaterialEstimates
+{
+    friend class ExtruderPlan; // cause there the naive estimates are calculated
+private:
+    double extrude_time; //!< Time in seconds occupied by extrusion
+    double unretracted_travel_time; //!< Time in seconds occupied by non-retracted travel (non-extrusion)
+    double retracted_travel_time; //!< Time in seconds occupied by retracted travel (non-extrusion)
+    double material; //!< Material used (in mm^3)
+public:
+    /*!
+     * Basic contructor
+     * 
+     * \param extrude_time Time in seconds occupied by extrusion
+     * \param unretracted_travel_time Time in seconds occupied by non-retracted travel (non-extrusion)
+     * \param retracted_travel_time Time in seconds occupied by retracted travel (non-extrusion)
+     * \param material Material used (in mm^3)
+     */
+    TimeMaterialEstimates(double extrude_time, double unretracted_travel_time, double retracted_travel_time, double material)
+    : extrude_time(extrude_time)
+    , unretracted_travel_time(unretracted_travel_time)
+    , retracted_travel_time(retracted_travel_time)
+    , material(material)
+    {
+    }
+
+    /*!
+     * Basic constructor initializing all estimates to zero.
+     */
+    TimeMaterialEstimates()
+    : extrude_time(0.0)
+    , unretracted_travel_time(0.0)
+    , retracted_travel_time(0.0)
+    , material(0.0)
+    {
+    }
+
+    /*!
+     * Set all estimates to zero.
+     */
+    void reset() 
+    {
+        extrude_time = 0.0;
+        unretracted_travel_time = 0.0;
+        retracted_travel_time = 0.0;
+        material = 0.0;
+    }
+
+    /*!
+     * Pointwise addition of estimate stats
+     * 
+     * \param other The estimates to add to these estimates.
+     * \return The resulting estimates
+     */
+    TimeMaterialEstimates operator+(const TimeMaterialEstimates& other)
+    {
+        return TimeMaterialEstimates(extrude_time+other.extrude_time, unretracted_travel_time+other.unretracted_travel_time, retracted_travel_time+other.retracted_travel_time, material+other.material);
+    }
+
+    /*!
+     * In place pointwise addition of estimate stats
+     * 
+     * \param other The estimates to add to these estimates.
+     * \return These estimates
+     */
+    TimeMaterialEstimates& operator+=(const TimeMaterialEstimates& other)
+    {
+        extrude_time += other.extrude_time;
+        unretracted_travel_time += other.unretracted_travel_time;
+        retracted_travel_time += other.retracted_travel_time;
+        material += other.material;
+        return *this;
+    }
+
+    /*!
+     * \brief Subtracts the specified estimates from these estimates and returns
+     * the result.
+     * 
+     * Each of the estimates in this class are individually subtracted.
+     * 
+     * \param other The estimates to subtract from these estimates.
+     * \return These estimates with the specified estimates subtracted.
+     */
+    TimeMaterialEstimates operator-(const TimeMaterialEstimates& other);
+
+    /*!
+     * \brief Subtracts the specified elements from these estimates.
+     * 
+     * This causes the estimates in this instance to change. Each of the
+     * estimates in this class are individually subtracted.
+     * 
+     * \param other The estimates to subtract from these estimates.
+     * \return A reference to this instance.
+     */
+    TimeMaterialEstimates& operator-=(const TimeMaterialEstimates& other);
+
+    /*!
+     * Get total time estimate. The different time estimate member values added together.
+     * 
+     * \return the total of all different time estimate values 
+     */
+    double getTotalTime() const
+    {
+        return extrude_time + unretracted_travel_time + retracted_travel_time;
+    }
+
+    /*!
+     * Get the total time during which the head is not retracted.
+     * 
+     * This includes extrusion time and non-retracted travel time
+     * 
+     * \return the total time during which the head is not retracted.
+     */
+    double getTotalUnretractedTime() const
+    {
+        return extrude_time + unretracted_travel_time;
+    }
+
+    /*!
+     * Get the total travel time.
+     * 
+     * This includes the retracted travel time as well as the unretracted travel time.
+     * 
+     * \return the total travel time.
+     */
+    double getTravelTime() const
+    {
+        return retracted_travel_time + unretracted_travel_time;
+    }
+
+    /*!
+     * Get the extrusion time.
+     * 
+     * \return extrusion time.
+     */
+    double getExtrudeTime() const
+    {
+        return extrude_time;
+    }
+
+    /*!
+     * Get the amount of material used in mm^3.
+     * 
+     * \return amount of material
+     */
+    double getMaterial() const
+    {
+        return material;
+    }
+};
+
+/*!
+ * A class for representing a planned path.
+ * 
+ * A path consists of several segments of the same type of movement: retracted travel, infill extrusion, etc.
+ * 
+ * This is a compact premature representation in which are line segments have the same config, i.e. the config of this path.
+ * 
+ * In the final representation (gcode) each line segment may have different properties, 
+ * which are added when the generated GCodePaths are processed.
+ */
+class GCodePath
+{
+public:
+    GCodePathConfig* config; //!< The configuration settings of the path.
+    SpaceFillType space_fill_type; //!< The type of space filling of which this path is a part
+    float flow; //!< A type-independent flow configuration (used for wall overlap compensation)
+    bool retract; //!< Whether the path is a move path preceded by a retraction move; whether the path is a retracted move path. 
+    bool perform_z_hop; //!< Whether to perform a z_hop in this path, which is assumed to be a travel path.
+    std::vector<Point> points; //!< The points constituting this path.
+    bool done;//!< Path is finished, no more moves should be added, and a new path should be started instead of any appending done to this one.
+
+    bool spiralize; //!< Whether to gradually increment the z position during the printing of this path. A sequence of spiralized paths should start at the given layer height and end in one layer higher.
+
+    TimeMaterialEstimates estimates; //!< Naive time and material estimates
+
+    /*!
+     * Whether this config is the config of a travel path.
+     * 
+     * \return Whether this config is the config of a travel path.
+     */
+    bool isTravelPath()
+    {
+        return config->isTravelPath();
+    }
+
+    /*!
+     * Get the material flow in mm^3 per mm traversed.
+     * 
+     * \warning Can only be called after the layer height has been set (which is done while writing the gcode!)
+     * 
+     * \return The flow
+     */
+    double getExtrusionMM3perMM()
+    {
+        return flow * config->getExtrusionMM3perMM();
+    }
+    
+    /*!
+     * Get the actual line width (modulated by the flow)
+     * \return the actual line width as shown in layer view
+     */
+    int getLineWidth()
+    {
+        return flow * config->getLineWidth() * config->getFlowPercentage() / 100.0;
+    }
+};
+
+class GCodePlanner; // forward declaration so that ExtruderPlan can be a friend
 class LayerPlanBuffer; // forward declaration so that ExtruderPlan can be a friend
 
 /*!
@@ -35,17 +273,14 @@ class LayerPlanBuffer; // forward declaration so that ExtruderPlan can be a frie
  */
 class ExtruderPlan
 {
-    friend class LayerPlan; // TODO: LayerPlan still does a lot which should actually be handled in this class.
+    friend class GCodePlanner; // TODO: GCodePlanner still does a lot which should actually be handled in this class.
     friend class LayerPlanBuffer; // TODO: LayerPlanBuffer handles paths directly
 protected:
     std::vector<GCodePath> paths; //!< The paths planned for this extruder
     std::list<NozzleTempInsert> inserts; //!< The nozzle temperature command inserts, to be inserted in between paths
 
     int extruder; //!< The extruder used for this paths in the current plan.
-    double heated_pre_travel_time; //!< The time at the start of this ExtruderPlan during which the head travels and has a temperature of initial_print_temperature
-    double initial_printing_temperature; //!< The required temperature at the start of this extruder plan.
-    double printing_temperature; //!< The normal temperature for printing this extruder plan. That start and end of this extruder plan may deviate because of the initial and final print temp
-    std::optional<std::list<NozzleTempInsert>::iterator> printing_temperature_command; //!< The command to heat from the printing temperature of this extruder plan to the printing temperature of the next extruder plan (if it has the same extruder).
+    double required_temp; //!< The required temperature at the start of this extruder plan.
     std::optional<double> prev_extruder_standby_temp; //!< The temperature to which to set the previous extruder. Not used if the previous extruder plan was the same extruder.
 
     TimeMaterialEstimates estimates; //!< Accumulated time and material estimates for all planned paths within this extruder plan.
@@ -58,7 +293,7 @@ public:
      * \param extruder The extruder number for which this object is a plan.
      * \param start_position The position the head is when this extruder plan starts
      */
-    ExtruderPlan(int extruder, Point start_position, int layer_nr, bool is_initial_layer, int layer_thickness, const FanSpeedLayerTimeSettings& fan_speed_layer_time_settings, const RetractionConfig& retraction_config);
+    ExtruderPlan(int extruder, Point start_position, int layer_nr, int layer_thickness, FanSpeedLayerTimeSettings& fan_speed_layer_time_settings, const RetractionConfig& retraction_config);
 
     /*!
      * Add a new Insert, constructed with the given arguments
@@ -162,11 +397,9 @@ protected:
     Point start_position; //!< The position the print head was at at the start of this extruder plan
 
     int layer_nr; //!< The layer number at which we are currently printing.
-    bool is_initial_layer; //!< Whether this extruder plan is printed on the very first layer (which might be raft)
-
     int layer_thickness; //!< The thickness of this layer in Z-direction
 
-    const FanSpeedLayerTimeSettings& fan_speed_layer_time_settings; //!< The fan speed and layer time settings used to limit this extruder plan
+    FanSpeedLayerTimeSettings& fan_speed_layer_time_settings; //!< The fan speed and layer time settings used to limit this extruder plan
 
     const RetractionConfig& retraction_config; //!< The retraction settings for the extruder of this plan
 
@@ -203,40 +436,23 @@ protected:
 class LayerPlanBuffer; // forward declaration to prevent circular dependency
 
 /*! 
- * The LayerPlan class stores multiple moves that are planned.
+ * The GCodePlanner class stores multiple moves that are planned.
  * 
  * 
  * It facilitates the combing to keep the head inside the print.
  * It also keeps track of the print time estimate for this planning so speed adjustments can be made for the minimal-layer-time.
  * 
- * A LayerPlan is also knows as a 'layer plan'.
+ * A GCodePlanner is also knows as a 'layer plan'.
  * 
  */
-class LayerPlan : public NoCopy
+class GCodePlanner : public NoCopy
 {
     friend class LayerPlanBuffer;
-    friend class LayerPlanTest;
-public:
-    /*!
-     * The state which is passed along between layer plans.
-     * This is what a \ref LayerPlan delivers to further computation in \ref FffGcodeWriter
-     * This is the state which is currently planned, not which is written to gcode.
-     */
-    struct PlanningState
-    {
-        Point last_position; //!< The position of the head before planning the next layer
-        int current_extruder; //!< The extruder train in use before planning the next layer
-        bool is_inside_mesh_layer_part; //!< Whether the last position was inside a layer part (used in combing)
-    };
+    friend class GCodePlannerTest;
 private:
-    const SliceDataStorage& storage; //!< The polygon data obtained from FffPolygonProcessor
+    SliceDataStorage& storage; //!< The polygon data obtained from FffPolygonProcessor
 
-public:
-    const PathConfigStorage configs_storage; //!< The line configs for this layer for each feature type
-
-private:
     int layer_nr; //!< The layer number of this layer plan
-    int is_initial_layer; //!< Whether this is the first layer (which might be raft)
     
     int z; 
     
@@ -244,9 +460,7 @@ private:
     
     Point start_position;
     Point lastPosition;
-
-    bool has_prime_tower_planned;
-
+    
     std::vector<ExtruderPlan> extruder_plans; //!< should always contain at least one ExtruderPlan
 
     int last_extruder_previous_layer; //!< The last id of the extruder with which was printed in the previous layer
@@ -257,34 +471,33 @@ private:
     Comb* comb;
 
 
-    const std::vector<FanSpeedLayerTimeSettings>& fan_speed_layer_time_settings_per_extruder;
+    std::vector<FanSpeedLayerTimeSettings>& fan_speed_layer_time_settings_per_extruder;
     
 private:
     /*!
      * Either create a new path with the given config or return the last path if it already had that config.
-     * If LayerPlan::forceNewPathStart has been called a new path will always be returned.
+     * If GCodePlanner::forceNewPathStart has been called a new path will always be returned.
      * 
      * \param config The config used for the path returned
      * \param space_fill_type The type of space filling which this path employs
      * \param flow (optional) A ratio for the extrusion speed
      * \param spiralize Whether to gradually increase the z while printing. (Note that this path may be part of a sequence of spiralized paths, forming one polygon)
-     * \return A path with the given config which is now the last path in LayerPlan::paths
+     * \return A path with the given config which is now the last path in GCodePlanner::paths
      */
-    GCodePath* getLatestPathWithConfig(const GCodePathConfig* config, SpaceFillType space_fill_type, float flow = 1.0, bool spiralize = false);
-
-public:
+    GCodePath* getLatestPathWithConfig(GCodePathConfig* config, SpaceFillType space_fill_type, float flow = 1.0, bool spiralize = false);
+    
     /*!
-     * Force LayerPlan::getLatestPathWithConfig to return a new path.
+     * Force GCodePlanner::getLatestPathWithConfig to return a new path.
      * 
      * This function is introduced because in some cases 
-     * LayerPlan::getLatestPathWithConfig is called consecutively with the same config pointer, 
+     * GCodePlanner::getLatestPathWithConfig is called consecutively with the same config pointer, 
      * though the content of the config has changed.
      * 
      * Example cases: 
      * - when changing extruder, the same travel config is used, but its extruder field is changed.
      */
     void forceNewPathStart();
-
+public:
     /*!
      * 
      * \param fan_speed_layer_time_settings_per_extruder The fan speed and layer time settings for each extruder.
@@ -293,8 +506,8 @@ public:
      * \param last_position The position of the head at the start of this gcode layer
      * \param combing_mode Whether combing is enabled and full or within infill only.
      */
-    LayerPlan(const SliceDataStorage& storage, int layer_nr, int z, int layer_height, PlanningState last_planned_state, const std::vector<FanSpeedLayerTimeSettings>& fan_speed_layer_time_settings_per_extruder, CombingMode combing_mode, int64_t comb_boundary_offset, bool travel_avoid_other_parts, int64_t travel_avoid_distance);
-    ~LayerPlan();
+    GCodePlanner(SliceDataStorage& storage, unsigned int layer_nr, int z, int layer_height, Point last_position, int current_extruder, bool is_inside_mesh, std::vector<FanSpeedLayerTimeSettings>& fan_speed_layer_time_settings_per_extruder, CombingMode combing_mode, int64_t comb_boundary_offset, bool travel_avoid_other_parts, int64_t travel_avoid_distance);
+    ~GCodePlanner();
 
     void overrideFanSpeeds(double speed);
     /*!
@@ -311,21 +524,12 @@ private:
     Polygons computeCombBoundaryInside(CombingMode combing_mode);
 
 public:
-    int getLayerNr() const
+    int getLayerNr()
     {
         return layer_nr;
     }
-
-    PlanningState getPlanningState() const
-    {
-        PlanningState ret;
-        ret.last_position = lastPosition;
-        ret.current_extruder = getExtruder();
-        ret.is_inside_mesh_layer_part = was_inside;
-        return ret;
-    }
-
-    Point getLastPosition() const
+    
+    Point getLastPosition()
     {
         return lastPosition;
     }
@@ -333,27 +537,24 @@ public:
     /*!
      * return whether the last position planned was inside the mesh (used in combing)
      */
-    bool getIsInsideMesh() const
+    bool getIsInsideMesh()
     {
         return was_inside;
     }
-
-    bool getPrimeTowerIsPlanned() const
-    {
-        return has_prime_tower_planned;
-    }
-
-    void setPrimeTowerIsPlanned()
-    {
-        has_prime_tower_planned = true;
-    }
-
     /*!
-     * send a line segment through the command socket from the previous point to the given point \p to
+     * send a polygon through the command socket from the previous point to the given point
      */
-    void sendLineTo(PrintFeatureType print_feature_type, Point to, int line_width) const
+    void sendPolygon(PrintFeatureType print_feature_type, Point from, Point to, int line_width)
     {
-        CommandSocket::sendLineTo(print_feature_type, to, line_width);
+        if (CommandSocket::isInstantiated()) 
+        {
+            // we should send this travel as a non-retraction move
+            cura::Polygons pathPoly;
+            PolygonRef path = pathPoly.newPoly();
+            path.add(from);
+            path.add(to);
+            CommandSocket::getInstance()->sendPolygons(print_feature_type, layer_nr, pathPoly, line_width);
+        }
     }
 
     /*!
@@ -363,19 +564,13 @@ public:
     * Features like prime tower and support are considered outside.
     */
     void setIsInside(bool going_to_comb);
-
-    /*!
-     * Plan a switch to a new extruder
-     * 
-     * \param extruder The extruder number to which to switch
-     * \return whether the extruder has changed
-     */
+    
     bool setExtruder(int extruder);
 
     /*!
      * Get the last planned extruder.
      */
-    int getExtruder() const
+    int getExtruder()
     {
         return extruder_plans.back().extruder;
     }
@@ -388,7 +583,7 @@ public:
      * 
      * \param p The point to travel to
      */
-    GCodePath& addTravel(Point p);
+    void addTravel(Point p);
     
     /*!
      * Add a travel path to a certain point and retract if needed.
@@ -398,14 +593,7 @@ public:
      * \param p The point to travel to
      * \param path (optional) The travel path to which to add the point \p p
      */
-    GCodePath& addTravel_simple(Point p, GCodePath* path = nullptr);
-
-    /*!
-     * Plan a prime poop at the current location.
-     * 
-     * \warning A nonretracted move is introduced so that the LayerPlanBuffer classifies this move as an extrusion move.
-     */
-    void planPrime();
+    void addTravel_simple(Point p, GCodePath* path = nullptr);
 
     /*!
      * Add an extrusion move to a certain point, optionally with a different flow than the one in the \p config.
@@ -416,7 +604,7 @@ public:
      * \param flow A modifier of the extrusion width which would follow from the \p config
      * \param spiralize Whether to gradually increase the z while printing. (Note that this path may be part of a sequence of spiralized paths, forming one polygon)
      */
-    void addExtrusionMove(Point p, const GCodePathConfig* config, SpaceFillType space_fill_type, float flow = 1.0, bool spiralize = false);
+    void addExtrusionMove(Point p, GCodePathConfig* config, SpaceFillType space_fill_type, float flow = 1.0, bool spiralize = false);
 
     /*!
      * Add polygon to the gcode starting at vertex \p startIdx
@@ -424,10 +612,9 @@ public:
      * \param startIdx The index of the starting vertex of the \p polygon
      * \param config The config with which to print the polygon lines
      * \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(ConstPolygonRef polygon, int startIdx, const GCodePathConfig* config, WallOverlapComputation* wall_overlap_computation = nullptr, coord_t wall_0_wipe_dist = 0, bool spiralize = false);
+    void addPolygon(PolygonRef polygon, int startIdx, GCodePathConfig* config, WallOverlapComputation* wall_overlap_computation = nullptr, bool spiralize = false);
 
     /*!
      * Add polygons to the gcode with optimized order.
@@ -442,11 +629,9 @@ public:
      * \param config The config with which to print the polygon lines
      * \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(const Polygons& polygons, const 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);
+    void addPolygonsByOptimizer(Polygons& polygons, GCodePathConfig* config, WallOverlapComputation* wall_overlap_computation = nullptr, EZSeamType z_seam_type = EZSeamType::SHORTEST, bool spiralize = false);
 
     /*!
      * Add lines to the gcode with optimized order.
@@ -455,7 +640,7 @@ public:
      * \param space_fill_type The type of space filling used to generate the line segments (should be either Lines or PolyLines!)
      * \param wipe_dist (optional) the distance wiped without extruding after laying down a line.
      */
-    void addLinesByOptimizer(const Polygons& polygons, const GCodePathConfig* config, SpaceFillType space_fill_type, int wipe_dist = 0);
+    void addLinesByOptimizer(Polygons& polygons, GCodePathConfig* config, SpaceFillType space_fill_type, int wipe_dist = 0);
 
     /*!
      * Compute naive time estimates (without accounting for slow down at corners etc.) and naive material estimates (without accounting for MergeInfillLines)
@@ -473,7 +658,19 @@ public:
      * \param gcode The gcode to write the planned paths to
      */
     void writeGCode(GCodeExport& gcode);
-
+    
+    /*!
+     * Complete all GcodePathConfig s by 
+     * - altering speed to conform to speed_layer_0
+     * - setting the layer_height (and thereby computing the extrusionMM3perMM)
+     */
+    void completeConfigs();
+    
+    /*!
+     * Interpolate between the initial layer speeds and the eventual speeds.
+     */
+    void processInitialLayersSpeedup();
+    
     /*!
      * Whether the current retracted path is to be an extruder switch retraction.
      * This function is used to avoid a G10 S1 after a G10.
@@ -492,7 +689,7 @@ public:
      * 
      * \param gcode The gcode to write the planned paths to
      * \param extruder_plan_idx The index of the current extruder plan
-     * \param path_idx The index into LayerPlan::paths for the next path to be written to GCode.
+     * \param path_idx The index into GCodePlanner::paths for the next path to be written to GCode.
      * \param layerThickness The height of the current layer.
      * \param coasting_volume The volume otherwise leaked during a normal move.
      * \param coasting_speed The speed at which to move during move-coasting.
@@ -517,4 +714,4 @@ public:
 
 }//namespace cura
 
-#endif // LAYER_PLAN_H
+#endif//GCODE_PLANNER_H

src/infill.cpp

@@ -17,10 +17,11 @@ int Infill::computeScanSegmentIdx(int x, int line_width)
     return x / line_width;
 }
 
-void Infill::generate(Polygons& result_polygons, Polygons& result_lines, const SliceMeshStorage* mesh)
+void Infill::generate(Polygons& result_polygons, Polygons& result_lines)
 {
     if (in_outline.size() == 0) return;
     if (line_distance == 0) return;
+    const Polygons* outline = &in_outline;
     Polygons outline_offsetted;
     switch(pattern)
     {
@@ -40,75 +41,28 @@ void Infill::generate(Polygons& result_polygons, Polygons& result_lines, const S
         generateTriangleInfill(result_lines);
         break;
     case EFillMethod::CONCENTRIC:
-        generateConcentricInfill(result_polygons, line_distance);
-        break;
-    case EFillMethod::CONCENTRIC_3D:
-        generateConcentric3DInfill(result_polygons);
+        outline_offsetted = in_outline.offset(outline_offset - infill_line_width / 2); // - infill_line_width / 2 cause generateConcentricInfill expects [outline] to be the outer most polygon instead of the outer outline 
+        outline = &outline_offsetted;
+        generateConcentricInfill(*outline, result_polygons, line_distance);
         break;
     case EFillMethod::ZIG_ZAG:
         generateZigZagInfill(result_lines, line_distance, fill_angle, connected_zigzags, use_endpieces);
         break;
-    case EFillMethod::CUBICSUBDIV:
-        if (!mesh)
-        {
-            logError("Cannot generate Cubic Subdivision infill without a mesh!\n");
-            break;
-        }
-        generateCubicSubDivInfill(result_lines, *mesh);
-        break;
     default:
         logError("Fill pattern has unknown value.\n");
         break;
     }
 }
 
-void Infill::generateConcentricInfill(Polygons& result, int inset_value)
+void Infill::generateConcentricInfill(Polygons outline, Polygons& result, int inset_value)
 {
-    Polygons first_concentric_wall = in_outline.offset(outline_offset - line_distance + infill_line_width / 2); // - infill_line_width / 2 cause generateConcentricInfill expects [outline] to be the outer most polygon instead of the outer outline
-
-    if (perimeter_gaps)
+    while(outline.size() > 0)
     {
-        const Polygons inner = first_concentric_wall.offset(infill_line_width / 2 + perimeter_gaps_extra_offset);
-        const Polygons gaps_here = in_outline.difference(inner);
-        perimeter_gaps->add(gaps_here);
-    }
-    generateConcentricInfill(first_concentric_wall, result, inset_value);
+        result.add(outline);
+        outline = outline.offset(-inset_value);
+    } 
 }
 
-void Infill::generateConcentricInfill(Polygons& first_concentric_wall, Polygons& result, int inset_value)
-{
-    result.add(first_concentric_wall);
-    Polygons* prev_inset = &first_concentric_wall;
-    Polygons next_inset;
-    while (prev_inset->size() > 0)
-    {
-        next_inset = prev_inset->offset(-inset_value);
-        result.add(next_inset);
-        if (perimeter_gaps)
-        {
-            const Polygons outer = prev_inset->offset(-infill_line_width / 2 - perimeter_gaps_extra_offset);
-            const Polygons inner = next_inset.offset(infill_line_width / 2);
-            const Polygons gaps_here = outer.difference(inner);
-            perimeter_gaps->add(gaps_here);
-        }
-        prev_inset = &next_inset;
-    }
-}
-
-void Infill::generateConcentric3DInfill(Polygons& result)
-{
-    int period = line_distance * 2;
-    int shift = int64_t(one_over_sqrt_2 * z) % period;
-    shift = std::min(shift, period - shift); // symmetry due to the fact that we are applying the shift in both directions
-    shift = std::min(shift, period / 2 - infill_line_width / 2); // don't put lines too close to each other
-    shift = std::max(shift, infill_line_width / 2); // don't put lines too close to each other
-    Polygons first_wall;
-    // in contrast to concentric infill we dont do "- infill_line_width / 2" cause this is already handled by the max two lines above
-    first_wall = in_outline.offset(outline_offset - shift);
-    generateConcentricInfill(first_wall, result, period);
-    first_wall = in_outline.offset(outline_offset - period + shift);
-    generateConcentricInfill(first_wall, result, period);
-}
 
 void Infill::generateGridInfill(Polygons& result)
 {
@@ -126,15 +80,14 @@ void Infill::generateCubicInfill(Polygons& result)
 
 void Infill::generateTetrahedralInfill(Polygons& result)
 {
-    int period = line_distance * 2;
-    int shift = int64_t(one_over_sqrt_2 * z) % period;
-    shift = std::min(shift, period - shift); // symmetry due to the fact that we are applying the shift in both directions
-    shift = std::min(shift, period / 2 - infill_line_width / 2); // don't put lines too close to each other
+    int shift = int64_t(one_over_sqrt_2 * z) % line_distance;
+    shift = std::min(shift, line_distance - shift); // symmetry due to the fact that we are applying the shift in both directions
+    shift = std::min(shift, line_distance / 2 - infill_line_width / 2); // don't put lines too close to each other
     shift = std::max(shift, infill_line_width / 2); // don't put lines too close to each other
-    generateLineInfill(result, period, fill_angle, shift);
-    generateLineInfill(result, period, fill_angle, -shift);
-    generateLineInfill(result, period, fill_angle + 90, shift);
-    generateLineInfill(result, period, fill_angle + 90, -shift);
+    generateLineInfill(result, line_distance, fill_angle, shift);
+    generateLineInfill(result, line_distance, fill_angle, -shift);
+    generateLineInfill(result, line_distance, fill_angle + 90, shift);
+    generateLineInfill(result, line_distance, fill_angle + 90, -shift);
 }
 
 void Infill::generateTriangleInfill(Polygons& result)
@@ -144,26 +97,15 @@ void Infill::generateTriangleInfill(Polygons& result)
     generateLineInfill(result, line_distance, fill_angle + 120, 0);
 }
 
-void Infill::generateCubicSubDivInfill(Polygons& result, const SliceMeshStorage& mesh)
-{
-    Polygons uncropped;
-    mesh.base_subdiv_cube->generateSubdivisionLines(z, uncropped);
-    addLineSegmentsInfill(result, uncropped);
-}
-
-void Infill::addLineSegmentsInfill(Polygons& result, Polygons& input)
-{
-    ClipperLib::PolyTree interior_segments_tree = in_outline.lineSegmentIntersection(input);
-    ClipperLib::Paths interior_segments;
-    ClipperLib::OpenPathsFromPolyTree(interior_segments_tree, interior_segments);
-    for (uint64_t idx = 0; idx < interior_segments.size(); idx++)
-    {
-        result.addLine(interior_segments[idx][0], interior_segments[idx][1]);
-    }
-}
-
 void Infill::addLineInfill(Polygons& result, const PointMatrix& rotation_matrix, const int scanline_min_idx, const int line_distance, const AABB boundary, std::vector<std::vector<int64_t>>& cut_list, int64_t shift)
 {
+    auto addLine = [&](Point from, Point to)
+    {
+        PolygonRef p = result.newPoly();
+        p.add(rotation_matrix.unapply(from));
+        p.add(rotation_matrix.unapply(to));
+    };
+
     auto compare_int64_t = [](const void* a, const void* b)
     {
         int64_t n = (*(int64_t*)a) - (*(int64_t*)b);
@@ -189,7 +131,7 @@ void Infill::addLineInfill(Polygons& result, const PointMatrix& rotation_matrix,
             { // segment is too short to create infill
                 continue;
             }
-            result.addLine(rotation_matrix.unapply(Point(x, crossings[crossing_idx])), rotation_matrix.unapply(Point(x, crossings[crossing_idx + 1])));
+            addLine(Point(x, crossings[crossing_idx]), Point(x, crossings[crossing_idx + 1]));
         }
         scanline_idx += 1;
     }
@@ -268,18 +210,14 @@ void Infill::generateLinearBasedInfill(const int outline_offset, Polygons& resul
     if (outline_offset != 0)
     {
         outline = in_outline.offset(outline_offset);
-        if (perimeter_gaps)
-        {
-            perimeter_gaps->add(in_outline.difference(outline.offset(infill_line_width / 2 + perimeter_gaps_extra_offset)));
-        }
     }
     else
     {
         outline = in_outline;
     }
-
-    outline = outline.offset(infill_overlap);
-
+    
+        outline = outline.offset(infill_overlap);
+    
     if (outline.size() == 0)
     {
         return;

src/infill.h

@@ -12,7 +12,6 @@
 #include "infill/ZigzagConnectorProcessorEndPieces.h"
 #include "infill/ZigzagConnectorProcessorConnectedEndPieces.h"
 #include "infill/ZigzagConnectorProcessorDisconnectedEndPieces.h"
-#include "infill/SubDivCube.h"
 #include "utils/intpoint.h"
 #include "utils/AABB.h"
 
@@ -21,8 +20,6 @@ namespace cura
 
 class Infill 
 {
-    static constexpr int perimeter_gaps_extra_offset = 15; // extra offset so that the perimeter gaps aren't created everywhere due to rounding errors
-
     EFillMethod pattern; //!< the space filling pattern of the infill to generate
     const Polygons& in_outline; //!< a reference polygon for getting the actual area within which to generate infill (see outline_offset)
     int outline_offset; //!< Offset from Infill::in_outline to get the actual area within which to generate infill
@@ -32,33 +29,12 @@ class Infill
     double fill_angle; //!< for linear infill types: the angle of the infill lines (or the angle of the grid)
     int64_t z; //!< height of the layer for which we generate infill
     int64_t shift; //!< shift of the scanlines in the direction perpendicular to the fill_angle
-    Polygons* perimeter_gaps; //!< (optional output) The areas in between consecutive insets when Concentric infill is used.
     bool connected_zigzags; //!< (ZigZag) Whether endpieces of zigzag infill should be connected to the nearest infill line on both sides of the zigzag connector
     bool use_endpieces; //!< (ZigZag) Whether to include endpieces: zigzag connector segments from one infill line to itself
 
     static constexpr double one_over_sqrt_2 = 0.7071067811865475244008443621048490392848359376884740; //!< 1.0 / sqrt(2.0)
 public:
-    /*!
-     * \warning If \p perimeter_gaps is given, then the difference between the \p in_outline
-     * and the polygons which result from offsetting it by the \p outline_offset
-     * and then expanding it again by half the \p infill_line_width
-     * is added to the \p perimeter_gaps
-     * 
-     * \param[out] perimeter_gaps (optional output) The areas in between consecutive insets when Concentric infill is used.
-     */
-    Infill(EFillMethod pattern
-        , const Polygons& in_outline
-        , int outline_offset
-        , int infill_line_width
-        , int line_distance
-        , int infill_overlap
-        , double fill_angle
-        , int64_t z
-        , int64_t shift
-        , Polygons* perimeter_gaps = nullptr
-        , bool connected_zigzags = false
-        , bool use_endpieces = false
-    )
+    Infill(EFillMethod pattern, const Polygons& in_outline, int outline_offset, int infill_line_width, int line_distance, int infill_overlap, double fill_angle, int64_t z, int64_t shift, bool connected_zigzags = false, bool use_endpieces = false)
     : pattern(pattern)
     , in_outline(in_outline)
     , outline_offset(outline_offset)
@@ -68,7 +44,6 @@ public:
     , fill_angle(fill_angle)
     , z(z)
     , shift(shift)
-    , perimeter_gaps(perimeter_gaps)
     , connected_zigzags(connected_zigzags)
     , use_endpieces(use_endpieces)
     {
@@ -78,9 +53,8 @@ public:
      * 
      * \param result_polygons (output) The resulting polygons (from concentric infill)
      * \param result_lines (output) The resulting line segments (from linear infill types)
-     * \param mesh The mesh for which to geenrate infill (should only be used for non-helper objects)
      */
-    void generate(Polygons& result_polygons, Polygons& result_lines, const SliceMeshStorage* mesh = nullptr);
+    void generate(Polygons& result_polygons, Polygons& result_lines);
 
 private:
     /*!
@@ -94,30 +68,13 @@ private:
      * \param line_distance the width of the scan segments
      */
     static inline int computeScanSegmentIdx(int x, int line_distance);
-
-    /*!
-     * Generate sparse concentric infill
-     * 
-     * Also adds \ref Inifll::perimeter_gaps between \ref Infill::in_outline and the first wall
-     * 
-     * \param result (output) The resulting polygons
-     * \param inset_value The offset between each consecutive two polygons
-     */
-    void generateConcentricInfill(Polygons& result, int inset_value);
-
-    /*!
-     * Generate sparse concentric infill starting from a specific outer wall
-     * \param first_wall The outer wall from which to start
-     * \param result (output) The resulting polygons
-     * \param inset_value The offset between each consecutive two polygons
-     */
-    void generateConcentricInfill(Polygons& first_wall, Polygons& result, int inset_value);
-
     /*!
      * Generate sparse concentric infill 
+     * \param outline The actual outline of the area within which to generate infill
      * \param result (output) The resulting polygons
+     * \param inset_value The offset between each consecutive two polygons
      */
-    void generateConcentric3DInfill(Polygons& result);
+    void generateConcentricInfill(Polygons outline, Polygons& result, int inset_value);
 
     /*!
      * Generate a rectangular grid of infill lines
@@ -142,14 +99,7 @@ private:
      * \param result (output) The resulting lines
      */
     void generateTriangleInfill(Polygons& result);
-
-    /*!
-     * Generate a 3d pattern of subdivided cubes on their points
-     * \param[out] result The resulting lines
-     * \param[in] mesh Where the Cubic Subdivision Infill precomputation is stored
-     */
-    void generateCubicSubDivInfill(Polygons& result, const SliceMeshStorage& mesh);
-
+    
     /*!
      * Convert a mapping from scanline to line_segment-scanline-intersections (\p cut_list) into line segments, using the even-odd rule
      * \param result (output) The resulting lines
@@ -162,13 +112,6 @@ private:
      */
     void addLineInfill(Polygons& result, const PointMatrix& rotation_matrix, const int scanline_min_idx, const int line_distance, const AABB boundary, std::vector<std::vector<int64_t>>& cut_list, int64_t total_shift);
 
-    /*!
-     * Crop line segments by the infill polygon using Clipper
-     * \param result (output) The resulting lines
-     * \param input The line segments to be cropped
-     */
-    void addLineSegmentsInfill(Polygons& result, Polygons& input);
-
     /*!
      * generate lines within the area of \p in_outline, at regular intervals of \p line_distance
      * 

src/infill/SubDivCube.cpp

@@ -1,282 +0,0 @@
-#include "SubDivCube.h"
-
-#include <functional>
-
-#include "../utils/polygonUtils.h"
-#include "../sliceDataStorage.h"
-#include "../utils/math.h"
-
-#define ONE_OVER_SQRT_2 0.7071067811865475244008443621048490392848359376884740 //1 / sqrt(2)
-#define ONE_OVER_SQRT_3 0.577350269189625764509148780501957455647601751270126876018 //1 / sqrt(3)
-#define ONE_OVER_SQRT_6 0.408248290463863016366214012450981898660991246776111688072 //1 / sqrt(6)
-#define SQRT_TWO_THIRD 0.816496580927726032732428024901963797321982493552223376144 //sqrt(2 / 3)
-
-namespace cura
-{
-
-std::vector<SubDivCube::CubeProperties> SubDivCube::cube_properties_per_recursion_step;
-double SubDivCube::radius_multiplier = 1;
-int32_t SubDivCube::radius_addition = 0;
-Point3Matrix SubDivCube::rotation_matrix;
-PointMatrix SubDivCube::infill_rotation_matrix;
-
-SubDivCube::~SubDivCube()
-{
-    for (int child_idx = 0; child_idx < 8; child_idx++)
-    {
-        if (children[child_idx])
-        {
-            delete children[child_idx];
-        }
-    }
-}
-
-void SubDivCube::precomputeOctree(SliceMeshStorage& mesh)
-{
-    radius_multiplier = mesh.getSettingAsRatio("sub_div_rad_mult");
-    radius_addition = mesh.getSettingInMicrons("sub_div_rad_add");
-    double infill_angle = M_PI / 4.0;
-
-    coord_t furthest_dist_from_origin = std::sqrt(square(mesh.getSettingInMicrons("machine_height")) + square(mesh.getSettingInMicrons("machine_depth") / 2) + square(mesh.getSettingInMicrons("machine_width") / 2));
-    coord_t max_side_length = furthest_dist_from_origin * 2;
-
-    int curr_recursion_depth = 0;
-    const int64_t infill_line_distance = mesh.getSettingInMicrons("infill_line_distance");
-    if (infill_line_distance > 0)
-    {
-        for (int64_t curr_side_length = infill_line_distance * 2; curr_side_length < max_side_length * 2; curr_side_length *= 2)
-        {
-            cube_properties_per_recursion_step.emplace_back();
-            CubeProperties& cube_properties_here = cube_properties_per_recursion_step.back();
-            cube_properties_here.side_length = curr_side_length;
-            cube_properties_here.height = sqrt(3) * curr_side_length;
-            cube_properties_here.square_height = sqrt(2) * curr_side_length;
-            cube_properties_here.max_draw_z_diff = ONE_OVER_SQRT_3 * curr_side_length;
-            cube_properties_here.max_line_offset = ONE_OVER_SQRT_6 * curr_side_length;
-            curr_recursion_depth++;
-        }
-    }
-    Point3 center(0, 0, 0);
-
-    Point3Matrix tilt; // rotation matrix to get from axis aligned cubes to cubes standing on their tip
-    // The Z axis is transformed to go in positive Y direction
-    //
-    //  cross section in a horizontal plane      horizontal plane showing
-    //  looking down at the origin O             positive X and positive Y
-    //                 Z                                                        .
-    //                /:\                              Y                        .
-    //               / : \                             ^                        .
-    //              /  :  \                            |                        .
-    //             /  .O.  \                           |                        .
-    //            /.~'   '~.\                          O---->X                  .
-    //          X """"""""""" Y                                                 .
-    tilt.matrix[0] = -ONE_OVER_SQRT_2;  tilt.matrix[1] = ONE_OVER_SQRT_2; tilt.matrix[2] = 0;
-    tilt.matrix[3] = -ONE_OVER_SQRT_6; tilt.matrix[4] = -ONE_OVER_SQRT_6; tilt.matrix[5] = SQRT_TWO_THIRD ;
-    tilt.matrix[6] = ONE_OVER_SQRT_3;  tilt.matrix[7] = ONE_OVER_SQRT_3;  tilt.matrix[8] = ONE_OVER_SQRT_3;
-
-    infill_rotation_matrix = PointMatrix(infill_angle);
-    Point3Matrix infill_angle_mat(infill_rotation_matrix);
-
-    rotation_matrix = infill_angle_mat.compose(tilt);
-
-    mesh.base_subdiv_cube = new SubDivCube(mesh, center, curr_recursion_depth - 1);
-}
-
-void SubDivCube::generateSubdivisionLines(int64_t z, Polygons& result)
-{
-    if (cube_properties_per_recursion_step.empty()) //Infill is set to 0%.
-    {
-        return;
-    }
-    Polygons directional_line_groups[3];
-
-    generateSubdivisionLines(z, result, directional_line_groups);
-
-    for (int dir_idx = 0; dir_idx < 3; dir_idx++)
-    {
-        Polygons& line_group = directional_line_groups[dir_idx];
-        for (unsigned int line_idx = 0; line_idx < line_group.size(); line_idx++)
-        {
-            result.addLine(line_group[line_idx][0], line_group[line_idx][1]);
-        }
-    }
-}
-
-void SubDivCube::generateSubdivisionLines(int64_t z, Polygons& result, Polygons (&directional_line_groups)[3])
-{
-    CubeProperties cube_properties = cube_properties_per_recursion_step[depth];
-
-    int32_t z_diff = std::abs(z - center.z); //!< the difference between the cube center and the target layer.
-    if (z_diff > cube_properties.height / 2) //!< this cube does not touch the target layer. Early exit.
-    {
-        return;
-    }
-    if (z_diff < cube_properties.max_draw_z_diff) //!< this cube has lines that need to be drawn.
-    {
-        Point relative_a, relative_b; //!< relative coordinates of line endpoints around cube center
-        Point a, b; //!< absolute coordinates of line endpoints
-        relative_a.X = (cube_properties.square_height / 2) * (cube_properties.max_draw_z_diff - z_diff) / cube_properties.max_draw_z_diff;
-        relative_b.X = -relative_a.X;
-        relative_a.Y = cube_properties.max_line_offset - ((z - (center.z - cube_properties.max_draw_z_diff)) * ONE_OVER_SQRT_2);
-        relative_b.Y = relative_a.Y;
-        rotatePointInitial(relative_a);
-        rotatePointInitial(relative_b);
-        for (int dir_idx = 0; dir_idx < 3; dir_idx++)//!< draw the line, then rotate 120 degrees.
-        {
-            a.X = center.x + relative_a.X;
-            a.Y = center.y + relative_a.Y;
-            b.X = center.x + relative_b.X;
-            b.Y = center.y + relative_b.Y;
-            addLineAndCombine(directional_line_groups[dir_idx], a, b);
-            if (dir_idx < 2)
-            {
-                rotatePoint120(relative_a);
-                rotatePoint120(relative_b);
-            }
-        }
-    }
-    for (int idx = 0; idx < 8; idx++) //!< draws the eight children
-    {
-        if (children[idx] != nullptr)
-        {
-            children[idx]->generateSubdivisionLines(z, result, directional_line_groups);
-        }
-    }
-}
-
-SubDivCube::SubDivCube(SliceMeshStorage& mesh, Point3& center, unsigned int depth)
-{
-    this->depth = depth;
-    this->center = center;
-
-    if (depth == 0) // lowest layer, no need for subdivision, exit.
-    {
-        return;
-    }
-    if (depth >= cube_properties_per_recursion_step.size()) //Depth is out of bounds of what we pre-computed.
-    {
-        return;
-    }
-
-    CubeProperties cube_properties = cube_properties_per_recursion_step[depth];
-    Point3 child_center;
-    coord_t radius = double(radius_multiplier * double(cube_properties.height)) / 4.0 + radius_addition;
-
-    int child_nr = 0;
-    std::vector<Point3> rel_child_centers;
-    rel_child_centers.emplace_back(1, 1, 1); // top
-    rel_child_centers.emplace_back(-1, 1, 1); // top three
-    rel_child_centers.emplace_back(1, -1, 1);
-    rel_child_centers.emplace_back(1, 1, -1);
-    rel_child_centers.emplace_back(-1, -1, -1); // bottom
-    rel_child_centers.emplace_back(1, -1, -1); // bottom three
-    rel_child_centers.emplace_back(-1, 1, -1);
-    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 * int32_t(cube_properties.side_length / 4));
-        if (isValidSubdivision(mesh, child_center, radius))
-        {
-            children[child_nr] = new SubDivCube(mesh, child_center, depth - 1);
-            child_nr++;
-        }
-    }
-}
-
-bool SubDivCube::isValidSubdivision(SliceMeshStorage& mesh, Point3& center, int64_t radius)
-{
-    int64_t distance2;
-    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 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));
-        Point loc(center.x, center.y);
-
-        inside = distanceFromPointToMesh(mesh, test_layer, loc, &distance2);
-        if (inside == 1)
-        {
-            inside_somewhere = true;
-        }
-        else
-        {
-            outside_somewhere = true;
-        }
-        if (outside_somewhere && inside_somewhere)
-        {
-            return true;
-        }
-        if ((inside != 2) && distance2 < sphere_slice_radius2)
-        {
-            return true;
-        }
-    }
-    return false;
-}
-
-int SubDivCube::distanceFromPointToMesh(SliceMeshStorage& mesh, int layer_nr, Point& location, int64_t* distance2)
-{
-    if (layer_nr < 0 || (unsigned int)layer_nr >= mesh.layers.size()) //!< this layer is outside of valid range
-    {
-        return 2;
-    }
-    Polygons collide;
-    mesh.layers[layer_nr].getSecondOrInnermostWalls(collide);
-    Point centerpoint = location;
-    bool inside = collide.inside(centerpoint);
-    ClosestPolygonPoint border_point = PolygonUtils::moveInside2(collide, centerpoint);
-    Point diff = border_point.location - location;
-    *distance2 = vSize2(diff);
-    if (inside)
-    {
-        return 1;
-    }
-    return 0;
-}
-
-
-void SubDivCube::rotatePointInitial(Point& target)
-{
-    target = infill_rotation_matrix.apply(target);
-}
-
-void SubDivCube::rotatePoint120(Point& target)
-{
-    constexpr double sqrt_three_fourths = 0.8660254037844386467637231707529361834714026269051903; //!< sqrt(3.0 / 4.0) = sqrt(3) / 2
-    int64_t x;
-    x = (-0.5) * target.X - sqrt_three_fourths * target.Y;
-    target.Y = (-0.5)*target.Y + sqrt_three_fourths * target.X;
-    target.X = x;
-}
-
-void SubDivCube::addLineAndCombine(Polygons& group, Point from, Point to)
-{
-    int epsilon = 10; // the smallest distance of two points which are viewed as coincident (dist > 0 due to rounding errors)
-    for (unsigned int idx = 0; idx < group.size(); idx++)
-    {
-        if (std::abs(from.X - group[idx][1].X) < epsilon && std::abs(from.Y - group[idx][1].Y) < epsilon)
-        {
-            from = group[idx][0];
-            group.remove(idx);
-            idx--;
-            continue;
-        }
-        if (std::abs(to.X - group[idx][0].X) < epsilon && std::abs(to.Y - group[idx][0].Y) < epsilon)
-        {
-            to = group[idx][1];
-            group.remove(idx);
-            idx--;
-            continue;
-        }
-    }
-    group.addLine(from, to);
-}
-
-}//namespace cura

src/infill/SubDivCube.h

@@ -1,98 +0,0 @@
-#ifndef INFILL_SUBDIVCUBE_H
-#define INFILL_SUBDIVCUBE_H
-
-#include "../sliceDataStorage.h"
-
-namespace cura
-{
-
-class Infill;
-
-class SubDivCube
-{
-public:
-    /*!
-     * Constructor for SubDivCube. Recursively calls itself eight times to flesh out the octree.
-     * \param mesh contains infill layer data and settings
-     * \param my_center the center of the cube
-     * \param depth the recursion depth of the cube (0 is most recursed)
-     */
-    SubDivCube(SliceMeshStorage& mesh, Point3& center, unsigned int depth);
-
-    ~SubDivCube(); //!< destructor (also destroys children
-
-    /*!
-     * Precompute the octree of subdivided cubes
-     * \param mesh contains infill layer data and settings
-     */
-    static void precomputeOctree(SliceMeshStorage& mesh);
-    /*!
-     * Generates the lines of subdivision of the specific cube at the specific layer. It recursively calls itself, so it ends up drawing all the subdivision lines of sub-cubes too.
-     * \param z the specified layer height
-     * \param result (output) The resulting lines
-     */
-    void generateSubdivisionLines(int64_t z, Polygons& result);
-private:
-    /*!
-     * Generates the lines of subdivision of the specific cube at the specific layer. It recursively calls itself, so it ends up drawing all the subdivision lines of sub-cubes too.
-     * \param z the specified layer height
-     * \param result (output) The resulting lines
-     * \param directional_line_groups Array of 3 times a polylines. Used to keep track of line segments that are all pointing the same direction for line segment combining
-     */
-    void generateSubdivisionLines(int64_t z, Polygons& result, Polygons (&directional_line_groups)[3]);
-    struct CubeProperties
-    {
-        int64_t side_length; //!< side length of cubes
-        int64_t height; //!< height of cubes based. This is the distance from one point of a cube to its 3d opposite.
-        int64_t square_height; //!< square cut across lengths. This is the diagonal distance across a face of the cube.
-        int64_t max_draw_z_diff; //!< maximum draw z differences. This is the maximum difference in z at which lines need to be drawn.
-        int64_t max_line_offset; //!< maximum line offsets. This is the maximum distance at which subdivision lines should be drawn from the 2d cube center.
-    };
-    /*!
-     * Rotates a point 120 degrees about the origin.
-     * \param target the point to rotate.
-     */
-    static void rotatePoint120(Point& target);
-    /*!
-     * Rotates a point to align it with the orientation of the infill.
-     * \param target the point to rotate.
-     */
-    static void rotatePointInitial(Point& target);
-    /*!
-     * Determines if a described theoretical cube should be subdivided based on if a sphere that encloses the cube touches the infill mesh.
-     * \param mesh contains infill layer data and settings
-     * \param center the center of the described cube
-     * \param radius the radius of the enclosing sphere
-     * \return the described cube should be subdivided
-     */
-    static bool isValidSubdivision(SliceMeshStorage& mesh, Point3& center, int64_t radius);
-    /*!
-     * Finds the distance to the infill border at the specified layer from the specified point.
-     * \param mesh contains infill layer data and settings
-     * \param layer_nr the number of the specified layer
-     * \param location the location of the specified point
-     * \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, 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.
-     * \param[out] group the polygons to add the line to
-     * \param from the first endpoint of the line
-     * \param to the second endpoint of the line
-     */
-    void addLineAndCombine(Polygons& group, Point from, Point to);
-
-    unsigned int depth; //!< the recursion depth of the cube (0 is most recursed)
-    Point3 center; //!< center location of the cube in absolute coordinates
-    SubDivCube* children[8] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; //!< pointers to this cube's eight octree children
-    static std::vector<CubeProperties> cube_properties_per_recursion_step; //!< precomputed array of basic properties of cubes based on recursion depth.
-    static double radius_multiplier; //!< multiplier for the bounding radius when determining if a cube should be subdivided
-    static Point3Matrix rotation_matrix; //!< The rotation matrix to get from axis aligned cubes to cubes standing on a corner point aligned with the infill_angle
-    static PointMatrix infill_rotation_matrix; //!< Horizontal rotation applied to infill
-    static int32_t radius_addition; //!< addition to the bounding radius when determining if a cube should be subdivided
-};
-
-}
-#endif //INFILL_SUBDIVCUBE_H

src/infill/ZigzagConnectorProcessor.h

@@ -109,7 +109,9 @@ protected:
      */
     void addLine(Point from, Point to)
     {
-        result.addLine(rotation_matrix.unapply(from), rotation_matrix.unapply(to));
+        PolygonRef line_poly = result.newPoly();
+        line_poly.add(rotation_matrix.unapply(from));
+        line_poly.add(rotation_matrix.unapply(to));
     }
 
     /*!

src/layerPart.cpp

@@ -44,11 +44,9 @@ void createLayerWithParts(SliceLayer& storageLayer, SlicerLayer* layer, bool uni
 }
 void createLayerParts(SliceMeshStorage& mesh, Slicer* slicer, bool union_layers, bool union_all_remove_holes)
 {
-    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++)
+    for(unsigned int layer_nr = 0; layer_nr < slicer->layers.size(); layer_nr++)
     {
+        mesh.layers.push_back(SliceLayer());
         mesh.layers[layer_nr].sliceZ = slicer->layers[layer_nr].z;
         mesh.layers[layer_nr].printZ = slicer->layers[layer_nr].z;
         createLayerWithParts(mesh.layers[layer_nr], &slicer->layers[layer_nr], union_layers, union_all_remove_holes);

src/main.cpp

@@ -20,39 +20,36 @@
 
 #include "settings/SettingsToGV.h"
 
-#include <omp.h> // omp_get_num_threads
-
 namespace cura
 {
     
 void print_usage()
 {
-    logAlways("\n");
-    logAlways("usage:\n");
-    logAlways("CuraEngine help\n");
-    logAlways("\tShow this help message\n");
-    logAlways("\n");
-    logAlways("CuraEngine connect <host>[:<port>] [-j <settings.def.json>]\n");
-    logAlways("  --connect <host>[:<port>]\n\tConnect to <host> via a command socket, \n\tinstead of passing information via the command line\n");
-    logAlways("  -j<settings.def.json>\n\tLoad settings.json file to register all settings and their defaults\n");
-    logAlways("  -v\n\tIncrease the verbose level (show log messages).\n");
-    logAlways("\n");
-    logAlways("CuraEngine slice [-v] [-p] [-j <settings.json>] [-s <settingkey>=<value>] [-g] [-e<extruder_nr>] [-o <output.gcode>] [-l <model.stl>] [--next]\n");
-    logAlways("  -v\n\tIncrease the verbose level (show log messages).\n");
-    logAlways("  -p\n\tLog progress information.\n");
-    logAlways("  -j\n\tLoad settings.def.json file to register all settings and their defaults.\n");
-    logAlways("  -s <setting>=<value>\n\tSet a setting to a value for the last supplied object, \n\textruder train, or general settings.\n");
-    logAlways("  -l <model_file>\n\tLoad an STL model. \n");
-    logAlways("  -g\n\tSwitch setting focus to the current mesh group only.\n\tUsed for one-at-a-time printing.\n");
-    logAlways("  -e<extruder_nr>\n\tSwitch setting focus to the extruder train with the given number.\n");
-    logAlways("  --next\n\tGenerate gcode for the previously supplied mesh group and append that to \n\tthe gcode of further models for one-at-a-time printing.\n");
-    logAlways("  -o <output_file>\n\tSpecify a file to which to write the generated gcode.\n");
-    logAlways("\n");
-    logAlways("The settings are appended to the last supplied object:\n");
-    logAlways("CuraEngine slice [general settings] \n\t-g [current group settings] \n\t-e0 [extruder train 0 settings] \n\t-l obj_inheriting_from_last_extruder_train.stl [object settings] \n\t--next [next group settings]\n\t... etc.\n");
-    logAlways("\n");
-    logAlways("In order to load machine definitions from custom locations, you need to create the environment variable CURA_ENGINE_SEARCH_PATH, which should contain all search paths delimited by a (semi-)colon.\n");
-    logAlways("\n");
+    cura::logError("\n");
+    cura::logError("usage:\n");
+    cura::logError("CuraEngine help\n");
+    cura::logError("\tShow this help message\n");
+    cura::logError("\n");
+    cura::logError("CuraEngine connect <host>[:<port>] [-j <settings.def.json>]\n");
+    cura::logError("  --connect <host>[:<port>]\n\tConnect to <host> via a command socket, \n\tinstead of passing information via the command line\n");
+    cura::logError("  -j<settings.def.json>\n\tLoad settings.json file to register all settings and their defaults\n");
+    cura::logError("\n");
+    cura::logError("CuraEngine slice [-v] [-p] [-j <settings.json>] [-s <settingkey>=<value>] [-g] [-e<extruder_nr>] [-o <output.gcode>] [-l <model.stl>] [--next]\n");
+    cura::logError("  -v\n\tIncrease the verbose level (show log messages).\n");
+    cura::logError("  -p\n\tLog progress information.\n");
+    cura::logError("  -j\n\tLoad settings.def.json file to register all settings and their defaults.\n");
+    cura::logError("  -s <setting>=<value>\n\tSet a setting to a value for the last supplied object, \n\textruder train, or general settings.\n");
+    cura::logError("  -l <model_file>\n\tLoad an STL model. \n");
+    cura::logError("  -g\n\tSwitch setting focus to the current mesh group only.\n\tUsed for one-at-a-time printing.\n");
+    cura::logError("  -e<extruder_nr>\n\tSwitch setting focus to the extruder train with the given number.\n");
+    cura::logError("  --next\n\tGenerate gcode for the previously supplied mesh group and append that to \n\tthe gcode of further models for one-at-a-time printing.\n");
+    cura::logError("  -o <output_file>\n\tSpecify a file to which to write the generated gcode.\n");
+    cura::logError("\n");
+    cura::logError("The settings are appended to the last supplied object:\n");
+    cura::logError("CuraEngine slice [general settings] \n\t-g [current group settings] \n\t-e0 [extruder train 0 settings] \n\t-l obj_inheriting_from_last_extruder_train.stl [object settings] \n\t--next [next group settings]\n\t... etc.\n");
+    cura::logError("\n");
+    cura::logError("In order to load machine definitions from custom locations, you need to create the environment variable CURA_ENGINE_SEARCH_PATH, which should contain all search paths delimited by a (semi-)colon.\n");
+    cura::logError("\n");
 }
 
 //Signal handler for a "floating point exception", which can also be integer division by zero errors.
@@ -100,8 +97,7 @@ void connect(int argc, char **argv)
                     argn++;
                     if (SettingRegistry::getInstance()->loadJSONsettings(argv[argn], FffProcessor::getInstance()))
                     {
-                        cura::logError("Failed to load json file: %s\n", argv[argn]);
-                        std::exit(1);
+                        cura::logError("ERROR: Failed to load json file: %s\n", argv[argn]);
                     }
                     break;
                 default:
@@ -128,7 +124,7 @@ void slice(int argc, char **argv)
     
     int extruder_train_nr = 0;
 
-    SettingsBase* last_extruder_train = nullptr;
+    SettingsBase* last_extruder_train = meshgroup->createExtruderTrain(0);
     // extruder defaults cannot be loaded yet cause no json has been parsed
     SettingsBase* last_settings_object = FffProcessor::getInstance();
     for(int argn = 2; argn < argc; argn++)
@@ -143,15 +139,14 @@ void slice(int argc, char **argv)
                     try {
                         //Catch all exceptions, this prevents the "something went wrong" dialog on windows to pop up on a thrown exception.
                         // Only ClipperLib currently throws exceptions. And only in case that it makes an internal error.
+                        meshgroup->finalize();
                         log("Loaded from disk in %5.3fs\n", FffProcessor::getInstance()->time_keeper.restart());
                         
                         for (int extruder_nr = 0; extruder_nr < FffProcessor::getInstance()->getSettingAsCount("machine_extruder_count"); extruder_nr++)
                         { // initialize remaining extruder trains and load the defaults
-                            meshgroup->createExtruderTrain(extruder_nr); // create new extruder train objects or use already existing ones
+                            ExtruderTrain* train = meshgroup->createExtruderTrain(extruder_nr); // create new extruder train objects or use already existing ones
+                            SettingRegistry::getInstance()->loadExtruderJSONsettings(extruder_nr, train);
                         }
-
-                        meshgroup->finalize();
-
                         //start slicing
                         FffProcessor::getInstance()->processMeshGroup(meshgroup);
                         
@@ -161,6 +156,7 @@ void slice(int argc, char **argv)
                         meshgroup = new MeshGroup(FffProcessor::getInstance());
                         last_extruder_train = meshgroup->createExtruderTrain(0); 
                         last_settings_object = meshgroup;
+                        SettingRegistry::getInstance()->loadExtruderJSONsettings(0, last_extruder_train);
                         
                     }catch(...){
                         cura::logError("Unknown exception\n");
@@ -184,8 +180,7 @@ void slice(int argc, char **argv)
                         argn++;
                         if (SettingRegistry::getInstance()->loadJSONsettings(argv[argn], last_settings_object))
                         {
-                            cura::logError("Failed to load json file: %s\n", argv[argn]);
-                            std::exit(1);
+                            cura::logError("ERROR: Failed to load json file: %s\n", argv[argn]);
                         }
                         break;
                     case 'e':
@@ -193,22 +188,17 @@ void slice(int argc, char **argv)
                         extruder_train_nr = int(*str - '0'); // TODO: parse int instead (now "-e10"="-e:" , "-e11"="-e;" , "-e12"="-e<" .. etc) 
                         last_settings_object = meshgroup->createExtruderTrain(extruder_train_nr);
                         last_extruder_train = last_settings_object;
+                        SettingRegistry::getInstance()->loadExtruderJSONsettings(extruder_train_nr, last_extruder_train);
                         break;
                     case 'l':
                         argn++;
                         
                         log("Loading %s from disk...\n", argv[argn]);
-
-                        transformation = last_settings_object->getSettingAsPointMatrix("mesh_rotation_matrix"); // the transformation applied to a model when loaded
-
-                        if (!last_extruder_train)
-                        {
-                            last_extruder_train = meshgroup->createExtruderTrain(0); // assume a json has already been provided on the command line
-                        }
+                        // transformation = // TODO: get a transformation from somewhere
+                        
                         if (!loadMeshIntoMeshGroup(meshgroup, argv[argn], transformation, last_extruder_train))
                         {
                             logError("Failed to load model: %s\n", argv[argn]);
-                            std::exit(1);
                         }
                         else 
                         {
@@ -261,7 +251,8 @@ void slice(int argc, char **argv)
     int extruder_count = FffProcessor::getInstance()->getSettingAsCount("machine_extruder_count");
     for (extruder_train_nr = 0; extruder_train_nr < extruder_count; extruder_train_nr++)
     { // initialize remaining extruder trains and load the defaults
-        meshgroup->createExtruderTrain(extruder_train_nr); // create new extruder train objects or use already existing ones
+        ExtruderTrain* train = meshgroup->createExtruderTrain(extruder_train_nr); // create new extruder train objects or use already existing ones
+        SettingRegistry::getInstance()->loadExtruderJSONsettings(extruder_train_nr, train);
     }
     
     
@@ -306,23 +297,23 @@ int main(int argc, char **argv)
 
     Progress::init();
     
-    std::cerr << std::boolalpha;
-    logAlways("\n");
-    logAlways("Cura_SteamEngine version %s\n", VERSION);
-    logAlways("Copyright (C) 2014 David Braam\n");
-    logAlways("\n");
-    logAlways("This program is free software: you can redistribute it and/or modify\n");
-    logAlways("it under the terms of the GNU Affero General Public License as published by\n");
-    logAlways("the Free Software Foundation, either version 3 of the License, or\n");
-    logAlways("(at your option) any later version.\n");
-    logAlways("\n");
-    logAlways("This program is distributed in the hope that it will be useful,\n");
-    logAlways("but WITHOUT ANY WARRANTY; without even the implied warranty of\n");
-    logAlways("MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n");
-    logAlways("GNU Affero General Public License for more details.\n");
-    logAlways("\n");
-    logAlways("You should have received a copy of the GNU Affero General Public License\n");
-    logAlways("along with this program.  If not, see <http://www.gnu.org/licenses/>.\n");
+    
+    logCopyright("\n");
+    logCopyright("Cura_SteamEngine version %s\n", VERSION);
+    logCopyright("Copyright (C) 2014 David Braam\n");
+    logCopyright("\n");
+    logCopyright("This program is free software: you can redistribute it and/or modify\n");
+    logCopyright("it under the terms of the GNU Affero General Public License as published by\n");
+    logCopyright("the Free Software Foundation, either version 3 of the License, or\n");
+    logCopyright("(at your option) any later version.\n");
+    logCopyright("\n");
+    logCopyright("This program is distributed in the hope that it will be useful,\n");
+    logCopyright("but WITHOUT ANY WARRANTY; without even the implied warranty of\n");
+    logCopyright("MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n");
+    logCopyright("GNU Affero General Public License for more details.\n");
+    logCopyright("\n");
+    logCopyright("You should have received a copy of the GNU Affero General Public License\n");
+    logCopyright("along with this program.  If not, see <http://www.gnu.org/licenses/>.\n");
 
 
     if (argc < 2)
@@ -330,19 +321,7 @@ 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);
@@ -369,7 +348,6 @@ int main(int argc, char **argv)
         bool inherit_viz = false;
         bool warning_viz = false;
         bool error_viz = false;
-        bool global_only_viz = false;
         if (argc >= 6)
         {
             char* str = argv[5];
@@ -391,9 +369,6 @@ int main(int argc, char **argv)
                     case 'w':
                         warning_viz = true;
                         break;
-                    case 'g':
-                        global_only_viz = true;
-                        break;
                     default:
                         cura::logError("Unknown option: %c\n", *str);
                         print_call(argc, argv);
@@ -405,26 +380,26 @@ int main(int argc, char **argv)
         }
         else
         {
-            cura::log("\n");
-            cura::log("usage:\n");
-            cura::log("CuraEngine analyse <fdmPrinter.def.json> <output.gv> <engine_settings_list> -[p|i|e|w]\n");
-            cura::log("\tGenerate a grpah to visualize the setting inheritance structure.\n");
-            cura::log("\t<fdmPrinter.def.json>\n\tThe base seting definitions file.\n");
-            cura::log("\t<output.gv>\n\tThe output file.\n");
-            cura::log("\t<engine_settings_list>\n\tA text file with all setting keys used in the engine, separated by newlines.\n");
-            cura::log("\t-[p|i|e|w]\n\tOptions for what to include in the visualization\n");
-            cura::log("\t\tp\tVisualize the parent-child relationship.\n");
-            cura::log("\t\ti\tVisualize inheritance function relationships.\n");
-            cura::log("\t\te\tVisualize (max/min) error function relationships.\n");
-            cura::log("\t\tw\tVisualize (max/min) warning function relationships.\n");
-            cura::log("\n");
+            cura::logError("\n");
+            cura::logError("usage:\n");
+            cura::logError("CuraEngine analyse <fdmPrinter.def.json> <output.gv> <engine_settings_list> -[p|i|e|w]\n");
+            cura::logError("\tGenerate a grpah to visualize the setting inheritance structure.\n");
+            cura::logError("\t<fdmPrinter.def.json>\n\tThe base seting definitions file.\n");
+            cura::logError("\t<output.gv>\n\tThe output file.\n");
+            cura::logError("\t<engine_settings_list>\n\tA text file with all setting keys used in the engine, separated by newlines.\n");
+            cura::logError("\t-[p|i|e|w]\n\tOptions for what to include in the visualization\n");
+            cura::logError("\t\tp\tVisualize the parent-child relationship.\n");
+            cura::logError("\t\ti\tVisualize inheritance function relationships.\n");
+            cura::logError("\t\te\tVisualize (max/min) error function relationships.\n");
+            cura::logError("\t\tw\tVisualize (max/min) warning function relationships.\n");
+            cura::logError("\n");
     
         }
         
-        SettingsToGv gv_out(argv[3], argv[4], parent_child_viz, inherit_viz, error_viz, warning_viz, global_only_viz);
+        SettingsToGv gv_out(argv[3], argv[4], parent_child_viz, inherit_viz, error_viz, warning_viz);
         if (gv_out.generate(std::string(argv[2])))
         {
-            cura::logError("Failed to analyse json file: %s\n", argv[2]);
+            cura::logError("ERROR: Failed to analyse json file: %s\n", argv[2]);
         }
         exit(0);
     }

src/mesh.cpp

@@ -72,13 +72,6 @@ AABB3D Mesh::getAABB() const
 {
     return aabb;
 }
-void Mesh::expandXY(int64_t offset)
-{
-    if (offset)
-    {
-        aabb.expandXY(offset);
-    }
-}
 
 
 int Mesh::findIndexOfVertex(const Point3& v)
@@ -140,7 +133,7 @@ int Mesh::getFaceIdxWithPoints(int idx0, int idx1, int notFaceIdx, int notFaceVe
 
     }
 
-    if (candidateFaces.size() == 0) { cura::logWarning("Couldn't find face connected to face %i.\n", notFaceIdx); return -1; }
+    if (candidateFaces.size() == 0) { cura::logError("Couldn't find face connected to face %i.\n", notFaceIdx); return -1; }
     if (candidateFaces.size() == 1) { return candidateFaces[0]; }
 
 
@@ -178,6 +171,7 @@ int Mesh::getFaceIdxWithPoints(int idx0, int idx1, int notFaceIdx, int notFaceVe
         if (angle == 0)
         {
             cura::log("Warning! Overlapping faces: face %i and face %i.\n", notFaceIdx, candidateFace);
+            std::cerr<< n.vSize() <<"; "<<n1.vSize()<<";"<<n0.vSize() <<std::endl;
         }
         if (angle < smallestAngle)
         {
@@ -185,7 +179,7 @@ int Mesh::getFaceIdxWithPoints(int idx0, int idx1, int notFaceIdx, int notFaceVe
             bestIdx = candidateFace;
         }
     }
-    if (bestIdx < 0) cura::logWarning("Couldn't find face connected to face %i.\n", notFaceIdx);
+    if (bestIdx < 0) cura::logError("Couldn't find face connected to face %i.\n", notFaceIdx);
     return bestIdx;
 }
 

src/mesh.h

@@ -72,7 +72,6 @@ public:
     Point3 min() const; //!< min (in x,y and z) vertex of the bounding box
     Point3 max() const; //!< max (in x,y and z) vertex of the bounding box
     AABB3D getAABB() const; //!< Get the axis aligned bounding box
-    void expandXY(int64_t offset); //!< Register applied horizontal expansion in the AABB
     
     /*!
      * Offset the whole mesh (all vertices and the bounding box).

src/multiVolumes.cpp

@@ -3,26 +3,20 @@
 namespace cura 
 {
  
-void carveMultipleVolumes(std::vector<Slicer*> &volumes, bool alternate_carve_order)
+void carveMultipleVolumes(std::vector<Slicer*> &volumes)
 {
     //Go trough all the volumes, and remove the previous volume outlines from our own outline, so we never have overlapped areas.
-    for (unsigned int volume_1_idx = 1; volume_1_idx < volumes.size(); volume_1_idx++)
+    for (unsigned int volume_1_idx = 0; volume_1_idx < volumes.size(); volume_1_idx++)
     {
         Slicer& volume_1 = *volumes[volume_1_idx];
-        if (volume_1.mesh->getSettingBoolean("infill_mesh") 
-            || volume_1.mesh->getSettingBoolean("anti_overhang_mesh")
-            || volume_1.mesh->getSettingBoolean("support_mesh")
-            )
+        if (volume_1.mesh->getSettingBoolean("infill_mesh"))
         {
             continue;
         }
         for (unsigned int volume_2_idx = 0; volume_2_idx < volume_1_idx; volume_2_idx++)
         {
             Slicer& volume_2 = *volumes[volume_2_idx];
-            if (volume_2.mesh->getSettingBoolean("infill_mesh")
-                || volume_2.mesh->getSettingBoolean("anti_overhang_mesh")
-                || volume_2.mesh->getSettingBoolean("support_mesh")
-                )
+            if (volume_2.mesh->getSettingBoolean("infill_mesh"))
             {
                 continue;
             }
@@ -34,14 +28,7 @@ void carveMultipleVolumes(std::vector<Slicer*> &volumes, bool alternate_carve_or
             {
                 SlicerLayer& layer1 = volume_1.layers[layerNr];
                 SlicerLayer& layer2 = volume_2.layers[layerNr];
-                if (alternate_carve_order && layerNr % 2 == 0)
-                {
-                    layer2.polygons = layer2.polygons.difference(layer1.polygons);
-                }
-                else
-                {
-                    layer1.polygons = layer1.polygons.difference(layer2.polygons);
-                }
+                layer1.polygons = layer1.polygons.difference(layer2.polygons);
             }
         }
     }
@@ -61,8 +48,6 @@ void generateMultipleVolumesOverlap(std::vector<Slicer*> &volumes)
     {
         int overlap = volume->mesh->getSettingInMicrons("multiple_mesh_overlap");
         if (volume->mesh->getSettingBoolean("infill_mesh")
-            || volume->mesh->getSettingBoolean("anti_overhang_mesh")
-            || volume->mesh->getSettingBoolean("support_mesh")
             || overlap == 0)
         {
             continue;
@@ -75,10 +60,7 @@ void generateMultipleVolumesOverlap(std::vector<Slicer*> &volumes)
             for (Slicer* other_volume : volumes)
             {
                 if (other_volume->mesh->getSettingBoolean("infill_mesh")
-                    || other_volume->mesh->getSettingBoolean("anti_overhang_mesh")
-                    || other_volume->mesh->getSettingBoolean("support_mesh")
                     || !other_volume->mesh->getAABB().hit(aabb)
-                    || other_volume == volume
                 )
                 {
                     continue;
@@ -86,9 +68,10 @@ void generateMultipleVolumesOverlap(std::vector<Slicer*> &volumes)
                 SlicerLayer& other_volume_layer = other_volume->layers[layer_nr];
                 all_other_volumes = all_other_volumes.unionPolygons(other_volume_layer.polygons.offset(offset_to_merge_other_merged_volumes));
             }
+            all_other_volumes = all_other_volumes.offset(-offset_to_merge_other_merged_volumes);
 
             SlicerLayer& volume_layer = volume->layers[layer_nr];
-            volume_layer.polygons = volume_layer.polygons.unionPolygons(all_other_volumes.intersection(volume_layer.polygons.offset(overlap / 2)));
+            volume_layer.polygons.unionPolygons(all_other_volumes.intersection(volume_layer.polygons.offset(overlap / 2)));
         }
     }
 }

src/multiVolumes.h

@@ -7,11 +7,7 @@
 /* This file contains code to help fixing up and changing layers that are build from multiple volumes. */
 namespace cura {
 
-/*!
- * 
- * \param alternate_carve_order Whether to switch which model carves out of which with every layer
- */
-void carveMultipleVolumes(std::vector<Slicer*> &meshes, bool alternate_carve_order);
+void carveMultipleVolumes(std::vector<Slicer*> &meshes);
 
 /*!
  * Expand each layer a bit and then keep the extra overlapping parts that overlap with other volumes.

src/pathOrderOptimizer.cpp

@@ -1,7 +1,7 @@
 /** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
 #include "pathOrderOptimizer.h"
 #include "utils/logoutput.h"
-#include "utils/SparsePointGridInclusive.h"
+#include "utils/BucketGrid2D.h"
 #include "utils/linearAlg2D.h"
 
 #define INLINE static inline
@@ -16,7 +16,7 @@ void PathOrderOptimizer::optimize()
     bool picked[polygons.size()];
     memset(picked, false, sizeof(bool) * polygons.size());/// initialized as falses
     
-    for (ConstPolygonRef poly : polygons) /// find closest point to initial starting point within each polygon +initialize picked
+    for (PolygonRef poly : polygons) /// find closest point to initial starting point within each polygon +initialize picked
     {
         int best = -1;
         float bestDist = std::numeric_limits<float>::infinity();
@@ -92,7 +92,7 @@ int PathOrderOptimizer::getPolyStart(Point prev_point, int poly_idx)
 {
     switch (type)
     {
-        case EZSeamType::BACK:      return getClosestPointInPolygon(z_seam_pos, poly_idx); 
+        case EZSeamType::BACK:      return getFarthestPointInPolygon(poly_idx); 
         case EZSeamType::RANDOM:    return getRandomPointInPolygon(poly_idx); 
         case EZSeamType::SHORTEST:  return getClosestPointInPolygon(prev_point, poly_idx);
         default:                    return getClosestPointInPolygon(prev_point, poly_idx);
@@ -102,15 +102,15 @@ int PathOrderOptimizer::getPolyStart(Point prev_point, int poly_idx)
 
 int PathOrderOptimizer::getClosestPointInPolygon(Point prev_point, int poly_idx)
 {
-    ConstPolygonRef poly = polygons[poly_idx];
+    PolygonRef poly = polygons[poly_idx];
 
     int best_point_idx = -1;
     float best_point_score = std::numeric_limits<float>::infinity();
     Point p0 = poly.back();
     for (unsigned int point_idx = 0; point_idx < poly.size(); point_idx++)
     {
-        const Point& p1 = poly[point_idx];
-        const Point& p2 = poly[(point_idx + 1) % poly.size()];
+        Point& p1 = poly[point_idx];
+        Point& p2 = poly[(point_idx + 1) % poly.size()];
         int64_t dist = vSize2(p1 - prev_point);
         float is_on_inside_corner_score = -LinearAlg2D::getAngleLeft(p0, p1, p2) / M_PI * 5000 * 5000; // prefer inside corners
         // this score is in the order of 5 mm
@@ -129,13 +129,31 @@ int PathOrderOptimizer::getRandomPointInPolygon(int poly_idx)
     return rand() % polygons[poly_idx].size();
 }
 
+
+int PathOrderOptimizer::getFarthestPointInPolygon(int poly_idx)
+{
+    PolygonRef poly = polygons[poly_idx];
+    int best_point_idx = -1;
+    float best_y = std::numeric_limits<float>::min();
+    for(unsigned int point_idx=0 ; point_idx<poly.size() ; point_idx++)
+    {
+        if (poly[point_idx].Y > best_y)
+        {
+            best_point_idx = point_idx;
+            best_y = poly[point_idx].Y;
+        }
+    }
+    return best_point_idx;
+}
+
+
 /**
 *
 */
 void LineOrderOptimizer::optimize()
 {
     int gridSize = 5000; // the size of the cells in the hash grid. TODO
-    SparsePointGridInclusive<unsigned int> line_bucket_grid(gridSize);
+    BucketGrid2D<unsigned int> line_bucket_grid(gridSize);
     bool picked[polygons.size()];
     memset(picked, false, sizeof(bool) * polygons.size());/// initialized as falses
     
@@ -143,7 +161,7 @@ void LineOrderOptimizer::optimize()
     {
         int best_point_idx = -1;
         float best_point_dist = std::numeric_limits<float>::infinity();
-        ConstPolygonRef poly = polygons[poly_idx];
+        PolygonRef poly = polygons[poly_idx];
         for (unsigned int point_idx = 0; point_idx < poly.size(); point_idx++) /// get closest point from polygon
         {
             float dist = vSize2f(poly[point_idx] - startPoint);
@@ -170,16 +188,14 @@ void LineOrderOptimizer::optimize()
         int best_line_idx = -1;
         float best_score = std::numeric_limits<float>::infinity(); // distance score for the best next line
 
-        /// check if single-line-polygon is close to last point
-        for(unsigned int close_line_idx :
-                line_bucket_grid.getNearbyVals(prev_point, gridSize))
+        for(unsigned int close_line_poly_idx :  line_bucket_grid.findNearbyObjects(prev_point)) /// check if single-line-polygon is close to last point
         {
-            if (picked[close_line_idx] || polygons[close_line_idx].size() < 1)
+            if (picked[close_line_poly_idx] || polygons[close_line_poly_idx].size() < 1)
             {
                 continue;
             }
 
-            updateBestLine(close_line_idx, best_line_idx, best_score, prev_point, incoming_perpundicular_normal);
+            updateBestLine(close_line_poly_idx, best_line_idx, best_score, prev_point, incoming_perpundicular_normal);
         }
 
         if (best_line_idx == -1) /// if single-line-polygon hasn't been found yet
@@ -199,13 +215,13 @@ void LineOrderOptimizer::optimize()
 
         if (best_line_idx > -1) /// should always be true; we should have been able to identify the best next polygon
         {
-            ConstPolygonRef best_line = polygons[best_line_idx];
+            PolygonRef best_line = polygons[best_line_idx];
             assert(best_line.size() == 2);
 
             int line_start_point_idx = polyStart[best_line_idx];
             int line_end_point_idx = line_start_point_idx * -1 + 1; /// 1 -> 0 , 0 -> 1
-            const Point& line_start = best_line[line_start_point_idx];
-            const Point& line_end = best_line[line_end_point_idx];
+            Point& line_start = best_line[line_start_point_idx];
+            Point& line_end = best_line[line_end_point_idx];
             prev_point = line_end;
             incoming_perpundicular_normal = turn90CCW(normal(line_end - line_start, 1000));
 
@@ -221,8 +237,8 @@ void LineOrderOptimizer::optimize()
 
 inline void LineOrderOptimizer::updateBestLine(unsigned int poly_idx, int& best, float& best_score, Point prev_point, Point incoming_perpundicular_normal)
 {
-    const Point& p0 = polygons[poly_idx][0];
-    const Point& p1 = polygons[poly_idx][1];
+    Point& p0 = polygons[poly_idx][0];
+    Point& p1 = polygons[poly_idx][1];
     float dot_score = getAngleScore(incoming_perpundicular_normal, p0, p1);
     { /// check distance to first point on line (0)
         float score = vSize2f(p0 - prev_point) + dot_score; // prefer 90 degree corners

src/pathOrderOptimizer.h

@@ -18,30 +18,23 @@ class PathOrderOptimizer
 {
 public:
     EZSeamType type;
-    Point startPoint; //!< A location near the prefered start location
-    Point z_seam_pos; //!< The position near where to create the z_seam (if \ref PathOrderOptimizer::type == 'back')
-    std::vector<ConstPolygonRef> polygons; //!< the parts of the layer (in arbitrary order)
+    Point startPoint; //!< The location of the nozzle before starting to print the current layer
+    std::vector<PolygonRef> polygons; //!< the parts of the layer (in arbitrary order)
     std::vector<int> polyStart; //!< polygons[i][polyStart[i]] = point of polygon i which is to be the starting point in printing the polygon
     std::vector<int> polyOrder; //!< the optimized order as indices in #polygons
 
-    PathOrderOptimizer(Point startPoint, Point z_seam_pos = Point(0, 0), EZSeamType type = EZSeamType::SHORTEST)
+    PathOrderOptimizer(Point startPoint, EZSeamType type = EZSeamType::SHORTEST)
     : type(type)
     , startPoint(startPoint)
-    , z_seam_pos(z_seam_pos)
     {
     }
 
     void addPolygon(PolygonRef polygon)
     {
-        this->polygons.emplace_back(polygon);
+        this->polygons.push_back(polygon);
     }
 
-    void addPolygon(ConstPolygonRef polygon)
-    {
-        this->polygons.emplace_back(polygon);
-    }
-
-    void addPolygons(const Polygons& polygons)
+    void addPolygons(Polygons& polygons)
     {
         for(unsigned int i=0;i<polygons.size(); i++)
             this->polygons.push_back(polygons[i]);
@@ -50,15 +43,9 @@ public:
     void optimize(); //!< sets #polyStart and #polyOrder
 
 private:
-    /*!
-     * Get the starting vertex of a polygon, depending on the \ref PathOrderOptimizer::type
-     * \param prev_point The previous planned location
-     * \param poly_idx The index of the polygon in \ref PathOrderOptimizer::polygons
-     * \return the index of the starting vertex in \ref PathOrderOptimizer::polygons[\p poly_idx]
-     */
     int getPolyStart(Point prev_point, int poly_idx);
-
     int getClosestPointInPolygon(Point prev, int i_polygon); //!< returns the index of the closest point
+    int getFarthestPointInPolygon(int poly_idx); //!< return the index to the point farthest from the front (highest y)
     int getRandomPointInPolygon(int poly_idx);
 
 
@@ -71,7 +58,7 @@ class LineOrderOptimizer
 {
 public:
     Point startPoint; //!< The location of the nozzle before starting to print the current layer
-    std::vector<ConstPolygonRef> polygons; //!< the parts of the layer (in arbitrary order)
+    std::vector<PolygonRef> polygons; //!< the parts of the layer (in arbitrary order)
     std::vector<int> polyStart; //!< polygons[i][polyStart[i]] = point of polygon i which is to be the starting point in printing the polygon
     std::vector<int> polyOrder; //!< the optimized order as indices in #polygons
 
@@ -85,11 +72,6 @@ public:
         this->polygons.push_back(polygon);
     }
 
-    void addPolygon(ConstPolygonRef polygon)
-    {
-        this->polygons.push_back(polygon);
-    }
-
     void addPolygons(Polygons& polygons)
     {
         for(unsigned int i=0;i<polygons.size(); i++)

src/pathPlanning/Comb.cpp

@@ -2,28 +2,37 @@
 #include "Comb.h"
 
 #include <algorithm>
-#include <functional> // function
-#include <unordered_set>
 
 #include "../utils/polygonUtils.h"
-#include "../utils/linearAlg2D.h"
-#include "../utils/PolygonsPointIndex.h"
 #include "../sliceDataStorage.h"
 #include "../utils/SVG.h"
 
 namespace cura {
 
-LocToLineGrid& Comb::getOutsideLocToLine()
+
+// boundary_outside is only computed when it's needed!
+Polygons& Comb::getBoundaryOutside()
 {
+    if (!boundary_outside)
+    {
+        boundary_outside = new Polygons();
+        *boundary_outside = storage.getLayerOutlines(layer_nr, false).offset(offset_from_outlines_outside); 
+    }
+    return *boundary_outside;
+}
+
+BucketGrid2D<PolygonsPointIndex>& Comb::getOutsideLocToLine()
+{
+    Polygons& outside = getBoundaryOutside();
+    if (!outside_loc_to_line)
+    {
+        outside_loc_to_line = PolygonUtils::createLocToLineGrid(outside, offset_from_inside_to_outside * 3 / 2);
+    }
     return *outside_loc_to_line;
 }
 
-Polygons& Comb::getBoundaryOutside()
-{
-    return *boundary_outside;
-}
   
-Comb::Comb(const SliceDataStorage& storage, int layer_nr, const Polygons& comb_boundary_inside, int64_t comb_boundary_offset, bool travel_avoid_other_parts, int64_t travel_avoid_distance)
+Comb::Comb(SliceDataStorage& storage, int layer_nr, Polygons& comb_boundary_inside, int64_t comb_boundary_offset, bool travel_avoid_other_parts, int64_t travel_avoid_distance)
 : storage(storage)
 , layer_nr(layer_nr)
 , offset_from_outlines(comb_boundary_offset) // between second wall and infill / other walls
@@ -32,31 +41,23 @@ Comb::Comb(const SliceDataStorage& storage, int layer_nr, const Polygons& comb_b
 , offset_from_inside_to_outside(offset_from_outlines + offset_from_outlines_outside)
 , max_crossing_dist2(offset_from_inside_to_outside * offset_from_inside_to_outside * 2) // so max_crossing_dist = offset_from_inside_to_outside * sqrt(2) =approx 1.5 to allow for slightly diagonal crossings and slightly inaccurate crossing computation
 , avoid_other_parts(travel_avoid_other_parts)
-, boundary_inside( comb_boundary_inside ) // copy the boundary, because the partsView_inside will reorder the polygons
-, partsView_inside( boundary_inside.splitIntoPartsView() ) // WARNING !! changes the order of boundary_inside !!
-, inside_loc_to_line(PolygonUtils::createLocToLineGrid(boundary_inside, comb_boundary_offset))
-, boundary_outside(
-        [&storage, layer_nr, travel_avoid_distance]()
-        {
-            return storage.getLayerOutlines(layer_nr, false).offset(travel_avoid_distance);
-        }
-    )
-, outside_loc_to_line(
-        [](Comb* comber, const int64_t offset_from_inside_to_outside)
-        {
-            return PolygonUtils::createLocToLineGrid(comber->getBoundaryOutside(), offset_from_inside_to_outside * 3 / 2);
-        }
-        , this
-        , offset_from_inside_to_outside
-    )
+// , boundary_inside( boundary.offset(-offset_from_outlines) ) // TODO: make inside boundary configurable?
+, boundary_inside( comb_boundary_inside )
+, boundary_outside(nullptr)
+, outside_loc_to_line(nullptr)
+, partsView_inside( boundary_inside.splitIntoPartsView() ) // !! changes the order of boundary_inside !!
 {
 }
 
 Comb::~Comb()
 {
-    if (inside_loc_to_line)
+    if (boundary_outside)
     {
-        delete inside_loc_to_line;
+        delete boundary_outside;
+    }
+    if (outside_loc_to_line)
+    {
+        delete outside_loc_to_line;
     }
 }
 
@@ -83,7 +84,7 @@ bool Comb::calc(Point startPoint, Point endPoint, CombPaths& combPaths, bool _st
     { // normal combing within part
         PolygonsPart part = partsView_inside.assemblePart(start_part_idx);
         combPaths.emplace_back();
-        return LinePolygonsCrossings::comb(part, *inside_loc_to_line, startPoint, endPoint, combPaths.back(), -offset_dist_to_get_from_on_the_polygon_to_outside, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
+        return LinePolygonsCrossings::comb(part, startPoint, endPoint, combPaths.back(), -offset_dist_to_get_from_on_the_polygon_to_outside, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
     }
     else 
     { // comb inside part to edge (if needed) >> move through air avoiding other parts >> comb inside end part upto the endpoint (if needed) 
@@ -98,31 +99,31 @@ bool Comb::calc(Point startPoint, Point endPoint, CombPaths& combPaths, bool _st
             return false;
         }
 
-        Crossing start_crossing(startPoint, startInside, start_part_idx, start_part_boundary_poly_idx, boundary_inside, inside_loc_to_line);
-        Crossing end_crossing(endPoint, endInside, end_part_idx, end_part_boundary_poly_idx, boundary_inside, inside_loc_to_line);
+        Crossing start_crossing(startPoint, startInside, start_part_idx, start_part_boundary_poly_idx, boundary_inside);
+        Crossing end_crossing(endPoint, endInside, end_part_idx, end_part_boundary_poly_idx, boundary_inside);
 
         { // find crossing over the in-between area between inside and outside
             start_crossing.findCrossingInOrMid(partsView_inside, endPoint);
             end_crossing.findCrossingInOrMid(partsView_inside, start_crossing.in_or_mid);
         }
 
-        bool skip_avoid_other_parts_path = false;
-        if (skip_avoid_other_parts_path && vSize2(start_crossing.in_or_mid - end_crossing.in_or_mid) < offset_from_inside_to_outside * offset_from_inside_to_outside * 4)
+        bool avoid_other_parts_now = avoid_other_parts;
+        if (avoid_other_parts_now && vSize2(start_crossing.in_or_mid - end_crossing.in_or_mid) < offset_from_inside_to_outside * offset_from_inside_to_outside * 4)
         { // parts are next to eachother, i.e. the direct crossing will always be smaller than two crossings via outside
-            skip_avoid_other_parts_path = true;
+            avoid_other_parts_now = false;
         }
 
-        if (avoid_other_parts && !skip_avoid_other_parts_path)
+        if (avoid_other_parts_now)
         { // compute the crossing points when moving through air
-            // comb through all air, since generally the outside consists of a single part
+            Polygons& outside = getBoundaryOutside(); // comb through all air, since generally the outside consists of a single part
 
-            bool success = start_crossing.findOutside(*boundary_outside, end_crossing.in_or_mid, fail_on_unavoidable_obstacles, *this);
+            bool success = start_crossing.findOutside(outside, end_crossing.in_or_mid, fail_on_unavoidable_obstacles, *this);
             if (!success)
             {
                 return false;
             }
 
-            success = end_crossing.findOutside(*boundary_outside, start_crossing.out, fail_on_unavoidable_obstacles, *this);
+            success = end_crossing.findOutside(outside, start_crossing.out, fail_on_unavoidable_obstacles, *this);
             if (!success)
             {
                 return false;
@@ -135,7 +136,7 @@ bool Comb::calc(Point startPoint, Point endPoint, CombPaths& combPaths, bool _st
             // start to boundary
             assert(start_crossing.dest_part.size() > 0 && "The part we start inside when combing should have been computed already!");
             combPaths.emplace_back();
-            bool combing_succeeded = LinePolygonsCrossings::comb(start_crossing.dest_part, *inside_loc_to_line, startPoint, start_crossing.in_or_mid, combPaths.back(), -offset_dist_to_get_from_on_the_polygon_to_outside, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
+            bool combing_succeeded = LinePolygonsCrossings::comb(start_crossing.dest_part, startPoint, start_crossing.in_or_mid, combPaths.back(), -offset_dist_to_get_from_on_the_polygon_to_outside, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
             if (!combing_succeeded)
             { // Couldn't comb between start point and computed crossing from the start part! Happens for very thin parts when the offset_to_get_off_boundary moves points to outside the polygon
                 return false;
@@ -143,7 +144,7 @@ bool Comb::calc(Point startPoint, Point endPoint, CombPaths& combPaths, bool _st
         }
         
         // throught air from boundary to boundary
-        if (avoid_other_parts && !skip_avoid_other_parts_path)
+        if (avoid_other_parts_now)
         {
             combPaths.emplace_back();
             combPaths.throughAir = true;
@@ -154,7 +155,7 @@ bool Comb::calc(Point startPoint, Point endPoint, CombPaths& combPaths, bool _st
             }
             else
             {
-                bool combing_succeeded = LinePolygonsCrossings::comb(*boundary_outside, *outside_loc_to_line, start_crossing.out, end_crossing.out, combPaths.back(), offset_dist_to_get_from_on_the_polygon_to_outside, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
+                bool combing_succeeded = LinePolygonsCrossings::comb(getBoundaryOutside(), start_crossing.out, end_crossing.out, combPaths.back(), offset_dist_to_get_from_on_the_polygon_to_outside, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
                 if (!combing_succeeded)
                 {
                     return false;
@@ -165,28 +166,10 @@ bool Comb::calc(Point startPoint, Point endPoint, CombPaths& combPaths, bool _st
         { // directly through air (not avoiding other parts)
             combPaths.emplace_back();
             combPaths.throughAir = true;
-            combPaths.back().cross_boundary = true; // note: we don't actually know whether this is cross boundary, but it might very well be
+            combPaths.back().cross_boundary = true; // TODO: calculate whether we cross a boundary!
             combPaths.back().push_back(start_crossing.in_or_mid);
             combPaths.back().push_back(end_crossing.in_or_mid);
         }
-        if (skip_avoid_other_parts_path)
-        {
-            if (startInside == endInside && start_part_idx == end_part_idx)
-            {
-                if (startInside)
-                { // both start and end are inside
-                    combPaths.back().cross_boundary = PolygonUtils::polygonCollidesWithLineSegment(startPoint, endPoint, *inside_loc_to_line);
-                }
-                else
-                { // both start and end are outside
-                    combPaths.back().cross_boundary = PolygonUtils::polygonCollidesWithLineSegment(startPoint, endPoint, *outside_loc_to_line);
-                }
-            }
-            else
-            {
-                combPaths.back().cross_boundary = true;
-            }
-        }
         
         if (endInside)
         {
@@ -194,7 +177,7 @@ bool Comb::calc(Point startPoint, Point endPoint, CombPaths& combPaths, bool _st
             assert(end_crossing.dest_part.size() > 0 && "The part we end up inside when combing should have been computed already!");
             combPaths.emplace_back();
             
-            bool combing_succeeded = LinePolygonsCrossings::comb(end_crossing.dest_part, *inside_loc_to_line, end_crossing.in_or_mid, endPoint, combPaths.back(), -offset_dist_to_get_from_on_the_polygon_to_outside, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
+            bool combing_succeeded = LinePolygonsCrossings::comb(end_crossing.dest_part, end_crossing.in_or_mid, endPoint, combPaths.back(), -offset_dist_to_get_from_on_the_polygon_to_outside, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
             if (!combing_succeeded)
             { // Couldn't comb between end point and computed crossing to the end part! Happens for very thin parts when the offset_to_get_off_boundary moves points to outside the polygon
                 return false;
@@ -205,25 +188,21 @@ bool Comb::calc(Point startPoint, Point endPoint, CombPaths& combPaths, bool _st
     }
 }
 
-Comb::Crossing::Crossing(const Point& dest_point, const bool dest_is_inside, const unsigned int dest_part_idx, const unsigned int dest_part_boundary_crossing_poly_idx, const Polygons& boundary_inside, const LocToLineGrid* inside_loc_to_line)
+Comb::Crossing::Crossing(const Point& dest_point, const bool dest_is_inside, const unsigned int dest_part_idx, const unsigned int dest_part_boundary_crossing_poly_idx, const Polygons& boundary_inside)
 : dest_is_inside(dest_is_inside)
-, boundary_inside(boundary_inside)
-, inside_loc_to_line(inside_loc_to_line)
+, dest_crossing_poly(boundary_inside[dest_part_boundary_crossing_poly_idx]) // initialize with most obvious poly, cause mostly a combing move will move outside the part, rather than inside a hole in the part
 , dest_point(dest_point)
 , dest_part_idx(dest_part_idx)
 {
-    if (dest_is_inside)
-    {
-        dest_crossing_poly.emplace(boundary_inside[dest_part_boundary_crossing_poly_idx]); // initialize with most obvious poly, cause mostly a combing move will move outside the part, rather than inside a hole in the part
-    }
+
 }
 
 bool Comb::moveInside(bool is_inside, Point& dest_point, unsigned int& inside_poly)
 {
     if (is_inside)
     {
-        ClosestPolygonPoint cpp = PolygonUtils::ensureInsideOrOutside(boundary_inside, dest_point, offset_extra_start_end, max_moveInside_distance2, &boundary_inside, inside_loc_to_line);
-        if (!cpp.isValid())
+        ClosestPolygonPoint cpp = PolygonUtils::ensureInsideOrOutside(boundary_inside, dest_point, offset_extra_start_end, max_moveInside_distance2);
+        if (cpp.point_idx == NO_INDEX)
         {
             return false;
         }
@@ -244,43 +223,10 @@ void Comb::Crossing::findCrossingInOrMid(const PartsView& partsView_inside, cons
         Point _dest_point(dest_point); // copy to local variable for lambda capture
         std::function<int(Point)> close_towards_start_penalty_function([_dest_point](Point candidate){ return vSize2((candidate - _dest_point) / 10); });
         dest_part = partsView_inside.assemblePart(dest_part_idx);
-
-        ClosestPolygonPoint boundary_crossing_point;
-        { // set [result] to a point on the destination part closest to close_to (but also a bit close to _dest_point)
-            std::unordered_set<unsigned int> dest_part_poly_indices;
-            for (unsigned int poly_idx : partsView_inside[dest_part_idx])
-            {
-                dest_part_poly_indices.emplace(poly_idx);
-            }
-            coord_t dist2_score = std::numeric_limits<coord_t>::max();
-            std::function<bool (const PolygonsPointIndex&)> line_processor
-                = [close_to, _dest_point, &boundary_crossing_point, &dist2_score, &dest_part_poly_indices](const PolygonsPointIndex& boundary_segment)
-                {
-                    if (dest_part_poly_indices.find(boundary_segment.poly_idx) == dest_part_poly_indices.end())
-                    { // we're not looking at a polygon from the dest_part
-                        return true; // a.k.a. continue;
-                    }
-                    Point closest_here = LinearAlg2D::getClosestOnLineSegment(close_to, boundary_segment.p(), boundary_segment.next().p());
-                    coord_t dist2_score_here = vSize2(close_to - closest_here) + vSize2(_dest_point - closest_here) / 10;
-                    if (dist2_score_here < dist2_score)
-                    {
-                        dist2_score = dist2_score_here;
-                        boundary_crossing_point = ClosestPolygonPoint(closest_here, boundary_segment.point_idx, boundary_segment.getPolygon(), boundary_segment.poly_idx);
-                    }
-                    return true;
-                };
-            inside_loc_to_line->processLine(std::make_pair(dest_point, close_to), line_processor);
-        }
-
-        Point result(boundary_crossing_point.p()); // the inside point of the crossing
-        if (!boundary_crossing_point.isValid())
-        { // no point has been found in the sparse grid
-            result = dest_point;
-        }
-
+        Point result(close_to);
         int64_t max_dist2 = std::numeric_limits<int64_t>::max();
-        ClosestPolygonPoint crossing_1_in_cp = PolygonUtils::ensureInsideOrOutside(dest_part, result, boundary_crossing_point, offset_dist_to_get_from_on_the_polygon_to_outside, max_dist2, &boundary_inside, inside_loc_to_line, close_towards_start_penalty_function);
-        if (crossing_1_in_cp.isValid())
+        ClosestPolygonPoint crossing_1_in_cp = PolygonUtils::ensureInsideOrOutside(dest_part, result, offset_dist_to_get_from_on_the_polygon_to_outside, max_dist2, close_towards_start_penalty_function);
+        if (crossing_1_in_cp.point_idx != NO_INDEX)
         {
             dest_crossing_poly = crossing_1_in_cp.poly;
             in_or_mid = result;
@@ -317,8 +263,7 @@ bool Comb::Crossing::findOutside(const Polygons& outside, const Point close_to,
     if (dest_is_inside && in_out_dist2_1 > comber.max_crossing_dist2) // moveInside moved too far
     { // if move is too far over in_between
         // find crossing closer by
-        assert(dest_crossing_poly && "destination crossing poly should have been instantiated!");
-        std::shared_ptr<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>> best = findBestCrossing(outside, *dest_crossing_poly, dest_point, close_to, comber);
+        std::shared_ptr<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>> best = findBestCrossing(outside, dest_crossing_poly, dest_point, close_to, comber);
         if (best)
         {
             in_or_mid = PolygonUtils::moveInside(best->first, comber.offset_dist_to_get_from_on_the_polygon_to_outside);
@@ -333,7 +278,7 @@ bool Comb::Crossing::findOutside(const Polygons& outside, const Point close_to,
 }
 
 
-std::shared_ptr<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>> Comb::Crossing::findBestCrossing(const Polygons& outside, ConstPolygonRef from, const Point estimated_start, const Point estimated_end, Comb& comber)
+std::shared_ptr<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>> Comb::Crossing::findBestCrossing(const Polygons& outside, const PolygonRef from, const Point estimated_start, const Point estimated_end, Comb& comber)
 {
     ClosestPolygonPoint* best_in = nullptr;
     ClosestPolygonPoint* best_out = nullptr;

src/pathPlanning/Comb.h

@@ -4,11 +4,9 @@
 
 #include <memory> // shared_ptr
 
-#include "../utils/optional.h"
 #include "../utils/polygon.h"
-#include "../utils/SparsePointGridInclusive.h"
+#include "../utils/BucketGrid2D.h"
 #include "../utils/polygonUtils.h"
-#include "../utils/LazyInitialization.h"
 
 #include "LinePolygonsCrossings.h"
 #include "CombPath.h"
@@ -32,7 +30,7 @@ class SliceDataStorage;
  * As an optimization, the combing paths inside are calculated on specifically those PolygonsParts within which to comb, while the coundary_outside isn't split into outside parts, 
  * because generally there is only one outside part; encapsulated holes occur less often.
  */
-class Comb
+class Comb 
 {
     friend class LinePolygonsCrossings;
 private:
@@ -48,9 +46,7 @@ private:
         Point in_or_mid; //!< The point on the inside boundary, or in between the inside and outside boundary if the start/end point isn't inside the inside boudary
         Point out; //!< The point on the outside boundary
         PolygonsPart dest_part; //!< The assembled inside-boundary PolygonsPart in which the dest_point lies. (will only be initialized when Crossing::dest_is_inside holds)
-        std::optional<ConstPolygonRef> dest_crossing_poly; //!< The polygon of the part in which dest_point lies, which will be crossed (often will be the outside polygon)
-        const Polygons& boundary_inside; //!< The inside boundary as in \ref Comb::boundary_inside
-        const LocToLineGrid* inside_loc_to_line; //!< The loc to line grid \ref Comb::inside_loc_to_line
+        PolygonRef dest_crossing_poly; //!< The polygon of the part in which dest_point lies, which will be crossed (often will be the outside polygon)
 
         /*!
          * Simple constructor
@@ -61,7 +57,7 @@ private:
          * \param dest_part_boundary_crossing_poly_idx The index in \p boundary_inside of the polygon of the part in which dest_point lies, which will be crossed (often will be the outside polygon).
          * \param boundary_inside The boundary within which to comb.
          */
-        Crossing(const Point& dest_point, const bool dest_is_inside, const unsigned int dest_part_idx, const unsigned int dest_part_boundary_crossing_poly_idx, const Polygons& boundary_inside, const LocToLineGrid* inside_loc_to_line);
+        Crossing(const Point& dest_point, const bool dest_is_inside, const unsigned int dest_part_idx, const unsigned int dest_part_boundary_crossing_poly_idx, const Polygons& boundary_inside);
 
         /*!
          * Find the not-outside location (Combing::in_or_mid) of the crossing between to the outside boundary
@@ -97,11 +93,11 @@ private:
          * \param comber[in] The combing calculator which has references to the offsets and boundaries to use in combing.
          * \return A pair of which the first is the crossing point on the inside boundary and the second the crossing point on the outside boundary
          */
-        std::shared_ptr<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>> findBestCrossing(const Polygons& outside, ConstPolygonRef from, Point estimated_start, Point estimated_end, Comb& comber);
+        std::shared_ptr<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>> findBestCrossing(const Polygons& outside, const PolygonRef from, Point estimated_start, Point estimated_end, Comb& comber);
     };
 
 
-    const SliceDataStorage& storage; //!< The storage from which to compute the outside boundary, when needed.
+    SliceDataStorage& storage; //!< The storage from which to compute the outside boundary, when needed.
     const int layer_nr; //!< The layer number for the layer for which to compute the outside boundary, when needed.
     
     const int64_t offset_from_outlines; //!< Offset from the boundary of a part to the comb path. (nozzle width / 2)
@@ -115,21 +111,20 @@ private:
 
     const bool avoid_other_parts; //!< Whether to perform inverse combing a.k.a. avoid parts.
     
-    Polygons boundary_inside; //!< The boundary within which to comb. (Will be reordered by the partsView_inside)
-    const PartsView partsView_inside; //!< Structured indices onto boundary_inside which shows which polygons belong to which part. 
-    LocToLineGrid* inside_loc_to_line; //!< The SparsePointGridInclusive mapping locations to line segments of the inner boundary.
-    LazyInitialization<Polygons> boundary_outside; //!< The boundary outside of which to stay to avoid collision with other layer parts. This is a pointer cause we only compute it when we move outside the boundary (so not when there is only a single part in the layer)
-    LazyInitialization<LocToLineGrid, Comb*, const int64_t> outside_loc_to_line; //!< The SparsePointGridInclusive mapping locations to line segments of the outside boundary.
+    Polygons& boundary_inside; //!< The boundary within which to comb.
+    Polygons* boundary_outside; //!< The boundary outside of which to stay to avoid collision with other layer parts. This is a pointer cause we only compute it when we move outside the boundary (so not when there is only a single part in the layer)
+    BucketGrid2D<PolygonsPointIndex>* outside_loc_to_line; //!< The BucketGrid mapping locations to line segments of the outside boundary.
+    PartsView partsView_inside; //!< Structured indices onto boundary_inside which shows which polygons belong to which part. 
 
     /*!
-     * Get the SparsePointGridInclusive mapping locations to line segments of the outside boundary. Calculate it when it hasn't been calculated yet.
+     * Get the boundary_outside, which is an offset from the outlines of all meshes in the layer. Calculate it when it hasn't been calculated yet.
      */
-    LocToLineGrid& getOutsideLocToLine();
-
-     /*!
-      * Get the boundary_outside, which is an offset from the outlines of all meshes in the layer. Calculate it when it hasn't been calculated yet.
-      */
     Polygons& getBoundaryOutside();
+    
+    /*!
+     * Get the BucketGrid mapping locations to line segments of the outside boundary. Calculate it when it hasn't been calculated yet.
+     */
+    BucketGrid2D<PolygonsPointIndex>& getOutsideLocToLine();
 
     /*!
      * Move the startPoint or endPoint inside when it should be inside
@@ -143,9 +138,6 @@ private:
 public:
     /*!
      * Initializes the combing areas for every mesh in the layer (not support)
-     * 
-     * \warning \ref Comb::calc changes the order of polygons in \p Comb::comb_boundary_inside
-     * 
      * \param storage Where the layer polygon data is stored
      * \param layer_nr The number of the layer for which to generate the combing areas.
      * \param comb_boundary_inside The comb boundary within which to comb within layer parts.
@@ -153,15 +145,13 @@ public:
      * \param travel_avoid_other_parts Whether to avoid other layer parts when traveling through air.
      * \param travel_avoid_distance The distance by which to avoid other layer parts when traveling through air.
      */
-    Comb(const SliceDataStorage& storage, int layer_nr, const Polygons& comb_boundary_inside, int64_t offset_from_outlines, bool travel_avoid_other_parts, int64_t travel_avoid_distance);
-
+    Comb(SliceDataStorage& storage, int layer_nr, Polygons& comb_boundary_inside, int64_t offset_from_outlines, bool travel_avoid_other_parts, int64_t travel_avoid_distance);
+    
     ~Comb();
 
     /*!
      * Calculate the comb paths (if any) - one for each polygon combed alternated with travel paths
      * 
-     * \warning Changes the order of polygons in \ref Comb::comb_boundary_inside
-     * 
      * \param startPoint Where to start moving from
      * \param endPoint Where to move to
      * \param combPoints Output parameter: The points along the combing path, excluding the \p startPoint (?) and \p endPoint
@@ -170,7 +160,7 @@ public:
      * \param via_outside_makes_combing_fail When going through air is inavoidable, stop calculation early and return false.
      * \param fail_on_unavoidable_obstacles When moving over other parts is inavoidable, stop calculation early and return false.
      * \return Whether combing has succeeded; otherwise a retraction is needed.
-     */
+     */    
     bool calc(Point startPoint, Point endPoint, CombPaths& combPaths, bool startInside, bool endInside, int64_t max_comb_distance_ignored, bool via_outside_makes_combing_fail, bool fail_on_unavoidable_obstacles);
 };
 

src/pathPlanning/GCodePath.cpp

@@ -1,24 +0,0 @@
-//Copyright (C) 2016 Ultimaker
-//Released under terms of the AGPLv3 License
-
-#include "GCodePath.h"
-
-namespace cura
-{
-
-bool GCodePath::isTravelPath()
-{
-    return config->isTravelPath();
-}
-
-double GCodePath::getExtrusionMM3perMM()
-{
-    return flow * config->getExtrusionMM3perMM();
-}
-
-int GCodePath::getLineWidth()
-{
-    return flow * config->getLineWidth() * config->getFlowPercentage() / 100.0;
-}
-
-}

src/pathPlanning/GCodePath.h

@@ -1,64 +0,0 @@
-/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
-#ifndef PATH_PLANNING_G_CODE_PATH_H
-#define PATH_PLANNING_G_CODE_PATH_H
-
-#include "../SpaceFillType.h"
-#include "../GCodePathConfig.h"
-
-#include "TimeMaterialEstimates.h"
-
-namespace cura 
-{
-
-/*!
- * A class for representing a planned path.
- * 
- * A path consists of several segments of the same type of movement: retracted travel, infill extrusion, etc.
- * 
- * This is a compact premature representation in which are line segments have the same config, i.e. the config of this path.
- * 
- * In the final representation (gcode) each line segment may have different properties, 
- * which are added when the generated GCodePaths are processed.
- */
-class GCodePath
-{
-public:
-    const GCodePathConfig* config; //!< The configuration settings of the path.
-    SpaceFillType space_fill_type; //!< The type of space filling of which this path is a part
-    float flow; //!< A type-independent flow configuration (used for wall overlap compensation)
-    bool retract; //!< Whether the path is a move path preceded by a retraction move; whether the path is a retracted move path. 
-    bool perform_z_hop; //!< Whether to perform a z_hop in this path, which is assumed to be a travel path.
-    bool perform_prime; //!< Whether this path is preceded by a prime (poop)
-    std::vector<Point> points; //!< The points constituting this path.
-    bool done;//!< Path is finished, no more moves should be added, and a new path should be started instead of any appending done to this one.
-
-    bool spiralize; //!< Whether to gradually increment the z position during the printing of this path. A sequence of spiralized paths should start at the given layer height and end in one layer higher.
-
-    TimeMaterialEstimates estimates; //!< Naive time and material estimates
-
-    /*!
-     * Whether this config is the config of a travel path.
-     * 
-     * \return Whether this config is the config of a travel path.
-     */
-    bool isTravelPath();
-
-    /*!
-     * Get the material flow in mm^3 per mm traversed.
-     * 
-     * \warning Can only be called after the layer height has been set (which is done while writing the gcode!)
-     * 
-     * \return The flow
-     */
-    double getExtrusionMM3perMM();
-
-    /*!
-     * Get the actual line width (modulated by the flow)
-     * \return the actual line width as shown in layer view
-     */
-    int getLineWidth();
-};
-
-}//namespace cura
-
-#endif//PATH_PLANNING_G_CODE_PATH_H

src/pathPlanning/LinePolygonsCrossings.cpp

@@ -85,19 +85,12 @@ bool LinePolygonsCrossings::lineSegmentCollidesWithBoundary()
         for(Point p1_ : poly)
         {
             Point p1 = transformation_matrix.apply(p1_);
-            // when the boundary just touches the line don't disambiguate between the boundary moving on to actually cross the line
-            // and the boundary bouncing back, resulting in not a real collision - to keep the algorithm simple.
-            //
-            // disregard overlapping line segments; probably the next or previous line segment is not overlapping, but will give a collision
-            // when the boundary line segment fully overlaps with the line segment this edge case is not viewed as a collision
-            if (p1.Y != p0.Y && ((p0.Y >= transformed_startPoint.Y && p1.Y <= transformed_startPoint.Y) || (p1.Y >= transformed_startPoint.Y && p0.Y <= transformed_startPoint.Y)))
+            if ((p0.Y > transformed_startPoint.Y && p1.Y < transformed_startPoint.Y) || (p1.Y > transformed_startPoint.Y && p0.Y < transformed_startPoint.Y))
             {
                 int64_t x = p0.X + (p1.X - p0.X) * (transformed_startPoint.Y - p0.Y) / (p1.Y - p0.Y);
-
+                
                 if (x > transformed_startPoint.X && x < transformed_endPoint.X)
-                {
                     return true;
-                }
             }
             p0 = p1;
         }
@@ -145,7 +138,7 @@ void LinePolygonsCrossings::getBasicCombingPath(CombPath& combPath)
 void LinePolygonsCrossings::getBasicCombingPath(PolyCrossings& polyCrossings, CombPath& combPath) 
 {
     PolygonRef poly = boundary[polyCrossings.poly_idx];
-    combPath.push_back(transformation_matrix.unapply(Point(polyCrossings.min.x - std::abs(dist_to_move_boundary_point_outside), transformed_startPoint.Y)));
+    combPath.push_back(transformation_matrix.unapply(Point(polyCrossings.min.x - dist_to_move_boundary_point_outside, transformed_startPoint.Y)));
     if ( ( polyCrossings.max.point_idx - polyCrossings.min.point_idx + poly.size() ) % poly.size() 
         < poly.size() / 2 )
     { // follow the path in the same direction as the winding order of the boundary polygon
@@ -166,7 +159,7 @@ void LinePolygonsCrossings::getBasicCombingPath(PolyCrossings& polyCrossings, Co
             combPath.push_back(PolygonUtils::getBoundaryPointWithOffset(poly, point_idx, dist_to_move_boundary_point_outside));
         }
     }
-    combPath.push_back(transformation_matrix.unapply(Point(polyCrossings.max.x + std::abs(dist_to_move_boundary_point_outside), transformed_startPoint.Y)));
+    combPath.push_back(transformation_matrix.unapply(Point(polyCrossings.max.x + dist_to_move_boundary_point_outside, transformed_startPoint.Y))); 
 }
 
 
@@ -194,9 +187,9 @@ bool LinePolygonsCrossings::optimizePath(CombPath& comb_path, CombPath& optimize
             continue;
         }
         Point& current_point = optimized_comb_path.back();
-        if (PolygonUtils::polygonCollidesWithLineSegment(current_point, comb_path[point_idx], loc_to_line_grid))
+        if (PolygonUtils::polygonCollidesWithlineSegment(boundary, current_point, comb_path[point_idx]))
         {
-            if (PolygonUtils::polygonCollidesWithLineSegment(current_point, comb_path[point_idx - 1], loc_to_line_grid))
+            if (PolygonUtils::polygonCollidesWithlineSegment(boundary, current_point, comb_path[point_idx - 1]))
             {
                 comb_path.cross_boundary = true;
             }
@@ -209,7 +202,7 @@ bool LinePolygonsCrossings::optimizePath(CombPath& comb_path, CombPath& optimize
             // TODO: add the below extra optimization? (+/- 7% extra computation time, +/- 2% faster print for Dual_extrusion_support_generation.stl)
             while (optimized_comb_path.size() > 1)
             {
-                if (PolygonUtils::polygonCollidesWithLineSegment(optimized_comb_path[optimized_comb_path.size() - 2], comb_path[point_idx], loc_to_line_grid))
+                if (PolygonUtils::polygonCollidesWithlineSegment(boundary, optimized_comb_path[optimized_comb_path.size() - 2], comb_path[point_idx]))
                 {
                     break;
                 }

src/pathPlanning/LinePolygonsCrossings.h

@@ -3,8 +3,6 @@
 #define PATH_PLANNING_LINE_POLYGONS_CROSSINGS_H
 
 #include "../utils/polygon.h"
-#include "../utils/polygonUtils.h"
-#include "../utils/SparseLineGrid.h"
 
 #include "CombPath.h"
 
@@ -82,7 +80,6 @@ private:
     unsigned int max_crossing_idx; //!< The index into LinePolygonsCrossings::crossings to the crossing with the maximal PolyCrossings::max crossing of all PolyCrossings's.
     
     Polygons& boundary; //!< The boundary not to cross during combing.
-    LocToLineGrid& loc_to_line_grid; //!< Mapping from locations to line segments of \ref LinePolygonsCrossings::boundary
     Point startPoint; //!< The start point of the scanline.
     Point endPoint; //!< The end point of the scanline.
     
@@ -166,12 +163,8 @@ private:
      * \param end the end point
      * \param dist_to_move_boundary_point_outside Distance used to move a point from a boundary so that it doesn't intersect with it anymore. (Precision issue)
      */
-    LinePolygonsCrossings(Polygons& boundary, LocToLineGrid& loc_to_line_grid, Point& start, Point& end, int64_t dist_to_move_boundary_point_outside)
-    : boundary(boundary)
-    , loc_to_line_grid(loc_to_line_grid)
-    , startPoint(start)
-    , endPoint(end)
-    , dist_to_move_boundary_point_outside(dist_to_move_boundary_point_outside)
+    LinePolygonsCrossings(Polygons& boundary, Point& start, Point& end, int64_t dist_to_move_boundary_point_outside)
+    : boundary(boundary), startPoint(start), endPoint(end), dist_to_move_boundary_point_outside(dist_to_move_boundary_point_outside)
     {
     }
     
@@ -180,16 +173,15 @@ public:
     /*!
      * The main function of this class: calculate one combing path within the boundary.
      * \param boundary The polygons to follow when calculating the basic combing path
-     * \param loc_to_line_grid A sparse grid mapping cells to all line segments of (at least) \p boundary in those cells
      * \param startPoint From where to start the combing move.
      * \param endPoint Where to end the combing move.
      * \param combPath Output parameter: the combing path generated.
      * \param fail_on_unavoidable_obstacles When moving over other parts is inavoidable, stop calculation early and return false.
      * \return Whether combing succeeded, i.e. we didn't cross any gaps/other parts
      */
-    static bool comb(Polygons& boundary, LocToLineGrid& loc_to_line_grid, Point startPoint, Point endPoint, CombPath& combPath, int64_t dist_to_move_boundary_point_outside, int64_t max_comb_distance_ignored, bool fail_on_unavoidable_obstacles)
+    static bool comb(Polygons& boundary, Point startPoint, Point endPoint, CombPath& combPath, int64_t dist_to_move_boundary_point_outside, int64_t max_comb_distance_ignored, bool fail_on_unavoidable_obstacles)
     {
-        LinePolygonsCrossings linePolygonsCrossings(boundary, loc_to_line_grid, startPoint, endPoint, dist_to_move_boundary_point_outside);
+        LinePolygonsCrossings linePolygonsCrossings(boundary, startPoint, endPoint, dist_to_move_boundary_point_outside);
         return linePolygonsCrossings.getCombingPath(combPath, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
     };
 };

src/pathPlanning/NozzleTempInsert.cpp

@@ -1,24 +0,0 @@
-//Copyright (C) 2016 Ultimaker
-//Released under terms of the AGPLv3 License
-
-#include "NozzleTempInsert.h"
-
-namespace cura
-{
-
-NozzleTempInsert::NozzleTempInsert(unsigned int path_idx, int extruder, double temperature, bool wait, double time_after_path_start)
-: path_idx(path_idx)
-, time_after_path_start(time_after_path_start)
-, extruder(extruder)
-, temperature(temperature)
-, wait(wait)
-{
-    assert(temperature != 0 && temperature != -1 && "Temperature command must be set!");
-}
-
-void NozzleTempInsert::write(GCodeExport& gcode)
-{
-    gcode.writeTemperatureCommand(extruder, temperature, wait);
-}
-
-}

src/pathPlanning/NozzleTempInsert.h

@@ -1,32 +0,0 @@
-/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
-#ifndef PATH_PLANNING_NOZZLE_TEMP_INSERT_H
-#define PATH_PLANNING_NOZZLE_TEMP_INSERT_H
-
-#include "../gcodeExport.h"
-
-namespace cura 
-{
-
-/*!
- * A gcode command to insert before a specific path.
- * 
- * Currently only used for preheat commands
- */
-struct NozzleTempInsert
-{
-    const unsigned int path_idx; //!< The path before which to insert this command
-    double time_after_path_start; //!< The time after the start of the path, before which to insert the command // TODO: use this to insert command in between moves in a path!
-    int extruder; //!< The extruder for which to set the temp
-    double temperature; //!< The temperature of the temperature command to insert
-    bool wait; //!< Whether to wait for the temperature to be reached
-    NozzleTempInsert(unsigned int path_idx, int extruder, double temperature, bool wait, double time_after_path_start = 0.0);
-
-    /*!
-     * Write the temperature command at the current position in the gcode.
-     * \param gcode The actual gcode writer
-     */
-    void write(GCodeExport& gcode);
-};
-}//namespace cura
-
-#endif//PATH_PLANNING_NOZZLE_TEMP_INSERT_H

src/pathPlanning/TimeMaterialEstimates.cpp

@@ -1,84 +0,0 @@
-/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
-#include "TimeMaterialEstimates.h"
-
-namespace cura
-{
-
-TimeMaterialEstimates::TimeMaterialEstimates(double extrude_time, double unretracted_travel_time, double retracted_travel_time, double material)
-: extrude_time(extrude_time)
-, unretracted_travel_time(unretracted_travel_time)
-, retracted_travel_time(retracted_travel_time)
-, material(material)
-{
-}
-
-TimeMaterialEstimates::TimeMaterialEstimates()
-: extrude_time(0.0)
-, unretracted_travel_time(0.0)
-, retracted_travel_time(0.0)
-, material(0.0)
-{
-}
-
-TimeMaterialEstimates TimeMaterialEstimates::operator-(const TimeMaterialEstimates& other)
-{
-    return TimeMaterialEstimates(extrude_time - other.extrude_time,unretracted_travel_time - other.unretracted_travel_time,retracted_travel_time - other.retracted_travel_time,material - other.material);
-}
-
-TimeMaterialEstimates& TimeMaterialEstimates::operator-=(const TimeMaterialEstimates& other)
-{
-    extrude_time -= other.extrude_time;
-    unretracted_travel_time -= other.unretracted_travel_time;
-    retracted_travel_time -= other.retracted_travel_time;
-    material -= other.material;
-    return *this;
-}
-
-TimeMaterialEstimates TimeMaterialEstimates::operator+(const TimeMaterialEstimates& other)
-{
-    return TimeMaterialEstimates(extrude_time+other.extrude_time, unretracted_travel_time+other.unretracted_travel_time, retracted_travel_time+other.retracted_travel_time, material+other.material);
-}
-
-TimeMaterialEstimates& TimeMaterialEstimates::operator+=(const TimeMaterialEstimates& other)
-{
-    extrude_time += other.extrude_time;
-    unretracted_travel_time += other.unretracted_travel_time;
-    retracted_travel_time += other.retracted_travel_time;
-    material += other.material;
-    return *this;
-}
-
-double TimeMaterialEstimates::getExtrudeTime() const
-{
-    return extrude_time;
-}
-
-double TimeMaterialEstimates::getMaterial() const
-{
-    return material;
-}
-
-double TimeMaterialEstimates::getTotalTime() const
-{
-    return extrude_time + unretracted_travel_time + retracted_travel_time;
-}
-
-double TimeMaterialEstimates::getTotalUnretractedTime() const
-{
-    return extrude_time + unretracted_travel_time;
-}
-
-double TimeMaterialEstimates::getTravelTime() const
-{
-    return retracted_travel_time + unretracted_travel_time;
-}
-
-void TimeMaterialEstimates::reset()
-{
-    extrude_time = 0.0;
-    unretracted_travel_time = 0.0;
-    retracted_travel_time = 0.0;
-    material = 0.0;
-}
-
-}//namespace cura

src/pathPlanning/TimeMaterialEstimates.h

@@ -1,124 +0,0 @@
-/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
-#ifndef PATH_PLANNING_TIME_MATERIAL_ESTIMATES_H
-#define PATH_PLANNING_TIME_MATERIAL_ESTIMATES_H
-
-#include "../gcodeExport.h"
-
-namespace cura 
-{
-
-class ExtruderPlan; // forward declaration so that TimeMaterialEstimates can be a friend
-
-/*!
- * Time and material estimates for a portion of paths, e.g. layer, extruder plan, path.
- */
-class TimeMaterialEstimates
-{
-    friend class ExtruderPlan; // cause there the naive estimates are calculated
-private:
-    double extrude_time; //!< Time in seconds occupied by extrusion
-    double unretracted_travel_time; //!< Time in seconds occupied by non-retracted travel (non-extrusion)
-    double retracted_travel_time; //!< Time in seconds occupied by retracted travel (non-extrusion)
-    double material; //!< Material used (in mm^3)
-public:
-    /*!
-     * Basic contructor
-     * 
-     * \param extrude_time Time in seconds occupied by extrusion
-     * \param unretracted_travel_time Time in seconds occupied by non-retracted travel (non-extrusion)
-     * \param retracted_travel_time Time in seconds occupied by retracted travel (non-extrusion)
-     * \param material Material used (in mm^3)
-     */
-    TimeMaterialEstimates(double extrude_time, double unretracted_travel_time, double retracted_travel_time, double material);
-
-    /*!
-     * Basic constructor initializing all estimates to zero.
-     */
-    TimeMaterialEstimates();
-
-    /*!
-     * Set all estimates to zero.
-     */
-    void reset();
-
-    /*!
-     * Pointwise addition of estimate stats
-     * 
-     * \param other The estimates to add to these estimates.
-     * \return The resulting estimates
-     */
-    TimeMaterialEstimates operator+(const TimeMaterialEstimates& other);
-
-    /*!
-     * In place pointwise addition of estimate stats
-     * 
-     * \param other The estimates to add to these estimates.
-     * \return These estimates
-     */
-    TimeMaterialEstimates& operator+=(const TimeMaterialEstimates& other);
-
-    /*!
-     * \brief Subtracts the specified estimates from these estimates and returns
-     * the result.
-     * 
-     * Each of the estimates in this class are individually subtracted.
-     * 
-     * \param other The estimates to subtract from these estimates.
-     * \return These estimates with the specified estimates subtracted.
-     */
-    TimeMaterialEstimates operator-(const TimeMaterialEstimates& other);
-
-    /*!
-     * \brief Subtracts the specified elements from these estimates.
-     * 
-     * This causes the estimates in this instance to change. Each of the
-     * estimates in this class are individually subtracted.
-     * 
-     * \param other The estimates to subtract from these estimates.
-     * \return A reference to this instance.
-     */
-    TimeMaterialEstimates& operator-=(const TimeMaterialEstimates& other);
-
-    /*!
-     * Get total time estimate. The different time estimate member values added together.
-     * 
-     * \return the total of all different time estimate values 
-     */
-    double getTotalTime() const;
-
-    /*!
-     * Get the total time during which the head is not retracted.
-     * 
-     * This includes extrusion time and non-retracted travel time
-     * 
-     * \return the total time during which the head is not retracted.
-     */
-    double getTotalUnretractedTime() const;
-
-    /*!
-     * Get the total travel time.
-     * 
-     * This includes the retracted travel time as well as the unretracted travel time.
-     * 
-     * \return the total travel time.
-     */
-    double getTravelTime() const;
-
-    /*!
-     * Get the extrusion time.
-     * 
-     * \return extrusion time.
-     */
-    double getExtrudeTime() const;
-
-    /*!
-     * Get the amount of material used in mm^3.
-     * 
-     * \return amount of material
-     */
-    double getMaterial() const;
-};
-
-}//namespace cura
-
-#endif//PATH_PLANNING_TIME_MATERIAL_ESTIMATES_H

src/raft.cpp

@@ -1,86 +1,25 @@
 /** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
 #include <clipper/clipper.hpp>
 
-#include "utils/math.h"
 #include "raft.h"
 #include "support.h"
 
 namespace cura {
 
-void Raft::generate(SliceDataStorage& storage, int distance)
+void generateRaft(SliceDataStorage& storage, int distance)
 {
-    assert(storage.raftOutline.size() == 0 && "Raft polygon isn't generated yet, so should be empty!");
-    storage.raftOutline = storage.getLayerOutlines(0, true).offset(distance, ClipperLib::jtRound);
-    const int shield_line_width = storage.meshgroup->getExtruderTrain(storage.getSettingAsIndex("adhesion_extruder_nr"))->getSettingInMicrons("skirt_brim_line_width");
     if (storage.draft_protection_shield.size() > 0)
     {
-        Polygons draft_shield_raft = storage.draft_protection_shield.offset(shield_line_width) // start half a line width outside shield
-                                        .difference(storage.draft_protection_shield.offset(-distance - shield_line_width / 2, ClipperLib::jtRound)); // end distance inside shield
-        storage.raftOutline = storage.raftOutline.unionPolygons(draft_shield_raft);
+        storage.raftOutline = storage.raftOutline.unionPolygons(storage.draft_protection_shield.offset(distance, ClipperLib::jtRound));
     }
-    if (storage.oozeShield.size() > 0 && storage.oozeShield[0].size() > 0)
+    else if (storage.oozeShield.size() > 0 && storage.oozeShield[0].size() > 0)
     {
-        const Polygons& ooze_shield = storage.oozeShield[0];
-        Polygons ooze_shield_raft = ooze_shield.offset(shield_line_width) // start half a line width outside shield
-                                        .difference(ooze_shield.offset(-distance - shield_line_width / 2, ClipperLib::jtRound)); // end distance inside shield
-        storage.raftOutline = storage.raftOutline.unionPolygons(ooze_shield_raft);
+        storage.raftOutline = storage.raftOutline.unionPolygons(storage.oozeShield[0].offset(distance, ClipperLib::jtRound));
     }
-    storage.raftOutline = storage.raftOutline.offset(1000).offset(-1000); // remove small holes
-}
-
-int Raft::getTotalThickness(const SliceDataStorage& storage)
-{
-    const ExtruderTrain& train = *storage.meshgroup->getExtruderTrain(storage.getSettingAsIndex("adhesion_extruder_nr"));
-    return train.getSettingInMicrons("raft_base_thickness")
-        + train.getSettingInMicrons("raft_interface_thickness")
-        + train.getSettingAsCount("raft_surface_layers") * train.getSettingInMicrons("raft_surface_thickness");
-}
-
-int Raft::getZdiffBetweenRaftAndLayer1(const SliceDataStorage& storage)
-{
-    const ExtruderTrain& train = *storage.meshgroup->getExtruderTrain(storage.getSettingAsIndex("adhesion_extruder_nr"));
-    if (storage.getSettingAsPlatformAdhesion("adhesion_type") != EPlatformAdhesion::RAFT)
+    else 
     {
-        return 0;
+        storage.raftOutline = storage.getLayerOutlines(0, true).offset(distance, ClipperLib::jtRound);
     }
-    const int64_t airgap = std::max((coord_t)0, train.getSettingInMicrons("raft_airgap"));
-    const int64_t layer_0_overlap = storage.getSettingInMicrons("layer_0_z_overlap");
-
-    const int64_t layer_height_0 = storage.getSettingInMicrons("layer_height_0");
-
-    const int64_t z_diff_raft_to_bottom_of_layer_1 = std::max(int64_t(0), airgap + layer_height_0 - layer_0_overlap);
-    return z_diff_raft_to_bottom_of_layer_1;
 }
 
-
-int Raft::getFillerLayerCount(const SliceDataStorage& storage)
-{
-    const int64_t normal_layer_height = storage.getSettingInMicrons("layer_height");
-    const unsigned int filler_layer_count = round_divide(getZdiffBetweenRaftAndLayer1(storage), normal_layer_height);
-    return filler_layer_count;
-}
-
-int Raft::getFillerLayerHeight(const SliceDataStorage& storage)
-{
-    if (storage.getSettingAsPlatformAdhesion("adhesion_type") != EPlatformAdhesion::RAFT)
-    {
-        const int64_t normal_layer_height = storage.getSettingInMicrons("layer_height");
-        return normal_layer_height;
-    }
-    const unsigned int filler_layer_height = round_divide(getZdiffBetweenRaftAndLayer1(storage), getFillerLayerCount(storage));
-    return filler_layer_height;
-}
-
-
-int Raft::getTotalExtraLayers(const SliceDataStorage& storage)
-{
-    const ExtruderTrain& train = *storage.meshgroup->getExtruderTrain(storage.getSettingAsIndex("adhesion_extruder_nr"));
-    if (train.getSettingAsPlatformAdhesion("adhesion_type") != EPlatformAdhesion::RAFT)
-    {
-        return 0;
-    }
-    return 2 + train.getSettingAsCount("raft_surface_layers") + getFillerLayerCount(storage);
-}
-
-
 }//namespace cura

src/raft.h

@@ -6,43 +6,7 @@
 
 namespace cura {
 
-class Raft
-{
-public:
-    static void generate(SliceDataStorage& storage, int distance);
-
-    /*!
-     * Get the height difference between the raft and the bottom of layer 1.
-     * 
-     * This is used for the filler layers because they don't use the layer_0_z_overlap
-     */
-    static int getZdiffBetweenRaftAndLayer1(const SliceDataStorage& storage);
-
-    /*!
-     * Get the amount of layers to fill the airgap and initial layer with helper parts (support, prime tower, etc.)
-     * 
-     * The initial layer gets a separate filler layer because we don't want to apply the layer_0_z_overlap to it.
-     */
-    static int getFillerLayerCount(const SliceDataStorage& storage);
-
-    /*!
-     * Get the layer height of the filler layers in between the raft and layer 1
-     */
-    static int getFillerLayerHeight(const SliceDataStorage& storage);
-
-    /*!
-     * Get the total thickness of the raft (without airgap)
-     */
-    static int getTotalThickness(const SliceDataStorage& storage);
-
-    /*!
-     * Get the total amount of extra layers below zero because there is a raft.
-     * 
-     * This includes the filler layers which are introduced in the air gap.
-     */
-    static int getTotalExtraLayers(const SliceDataStorage& storage);
-
-};
+void generateRaft(SliceDataStorage& storage, int distance);
 
 }//namespace cura
 

src/settings/PathConfigStorage.cpp

@@ -1,235 +0,0 @@
-/** Copyright (C) 2017 Ultimaker - Released under terms of the AGPLv3 License */
-#include "PathConfigStorage.h"
-
-#include "settings.h" // MAX_INFILL_COMBINE
-#include "../sliceDataStorage.h" // SliceDataStorage
-
-
-namespace cura
-{
-
-GCodePathConfig getPerimeterGapConfig(const SliceMeshStorage& mesh, int layer_thickness)
-{
-    // 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;
-    }
-    return GCodePathConfig(
-            PrintFeatureType::Skin
-            , perimeter_gaps_line_width
-            , layer_thickness
-            , mesh.getSettingInPercentage("material_flow")
-            , GCodePathConfig::SpeedDerivatives{perimeter_gaps_speed, mesh.getSettingInMillimetersPerSecond("acceleration_topbottom"), mesh.getSettingInMillimetersPerSecond("jerk_topbottom")}
-        );
-}
-
-PathConfigStorage::MeshPathConfigs::MeshPathConfigs(const SliceMeshStorage& mesh, int layer_thickness)
-: inset0_config(
-    PrintFeatureType::OuterWall
-    , mesh.getSettingInMicrons("wall_line_width_0")
-    , layer_thickness
-    , mesh.getSettingInPercentage("material_flow")
-    , GCodePathConfig::SpeedDerivatives{mesh.getSettingInMillimetersPerSecond("speed_wall_0"), mesh.getSettingInMillimetersPerSecond("acceleration_wall_0"), mesh.getSettingInMillimetersPerSecond("jerk_wall_0")}
-)
-, insetX_config(
-    PrintFeatureType::InnerWall
-    , mesh.getSettingInMicrons("wall_line_width_x")
-    , layer_thickness
-    , mesh.getSettingInPercentage("material_flow")
-    , GCodePathConfig::SpeedDerivatives{mesh.getSettingInMillimetersPerSecond("speed_wall_x"), mesh.getSettingInMillimetersPerSecond("acceleration_wall_x"), mesh.getSettingInMillimetersPerSecond("jerk_wall_x")}
-)
-, skin_config(
-    PrintFeatureType::Skin
-    , mesh.getSettingInMicrons("skin_line_width")
-    , layer_thickness
-    , mesh.getSettingInPercentage("material_flow")
-    , GCodePathConfig::SpeedDerivatives{mesh.getSettingInMillimetersPerSecond("speed_topbottom"), mesh.getSettingInMillimetersPerSecond("acceleration_topbottom"), mesh.getSettingInMillimetersPerSecond("jerk_topbottom")}
-)
-
-, perimeter_gap_config(getPerimeterGapConfig(mesh, layer_thickness))
-{
-    infill_config.reserve(MAX_INFILL_COMBINE);
-    for (int combine_idx = 0; combine_idx < MAX_INFILL_COMBINE; combine_idx++)
-    {
-        infill_config.emplace_back(
-                PrintFeatureType::Infill
-                , mesh.getSettingInMicrons("infill_line_width") * (combine_idx + 1)
-                , layer_thickness
-                , mesh.getSettingInPercentage("material_flow")
-                , GCodePathConfig::SpeedDerivatives{mesh.getSettingInMillimetersPerSecond("speed_infill"), mesh.getSettingInMillimetersPerSecond("acceleration_infill"), mesh.getSettingInMillimetersPerSecond("jerk_infill")}
-            );
-    }
-}
-
-PathConfigStorage::PathConfigStorage(const SliceDataStorage& storage, int layer_nr, int layer_thickness)
-: adhesion_extruder_train(storage.meshgroup->getExtruderTrain(storage.getSettingAsIndex("adhesion_extruder_nr")))
-, support_infill_train(storage.meshgroup->getExtruderTrain(storage.getSettingAsIndex("support_infill_extruder_nr")))
-, support_interface_train(storage.meshgroup->getExtruderTrain(storage.getSettingAsIndex("support_interface_extruder_nr")))
-, raft_base_config(
-            PrintFeatureType::SupportInterface
-            , adhesion_extruder_train->getSettingInMicrons("raft_base_line_width")
-            , adhesion_extruder_train->getSettingInMicrons("raft_base_thickness")
-            , adhesion_extruder_train->getSettingInPercentage("material_flow")
-            , GCodePathConfig::SpeedDerivatives{adhesion_extruder_train->getSettingInMillimetersPerSecond("raft_base_speed"), adhesion_extruder_train->getSettingInMillimetersPerSecond("raft_base_acceleration"), adhesion_extruder_train->getSettingInMillimetersPerSecond("raft_base_jerk")}
-        )
-, raft_interface_config(
-            PrintFeatureType::Support
-            , adhesion_extruder_train->getSettingInMicrons("raft_interface_line_width")
-            , adhesion_extruder_train->getSettingInMicrons("raft_interface_thickness")
-            , adhesion_extruder_train->getSettingInPercentage("material_flow")
-            , GCodePathConfig::SpeedDerivatives{adhesion_extruder_train->getSettingInMillimetersPerSecond("raft_interface_speed"), adhesion_extruder_train->getSettingInMillimetersPerSecond("raft_interface_acceleration"), adhesion_extruder_train->getSettingInMillimetersPerSecond("raft_interface_jerk")}
-        )
-, raft_surface_config(
-            PrintFeatureType::SupportInterface
-            , adhesion_extruder_train->getSettingInMicrons("raft_surface_line_width")
-            , adhesion_extruder_train->getSettingInMicrons("raft_surface_thickness")
-            , adhesion_extruder_train->getSettingInPercentage("material_flow")
-            , GCodePathConfig::SpeedDerivatives{adhesion_extruder_train->getSettingInMillimetersPerSecond("raft_surface_speed"), adhesion_extruder_train->getSettingInMillimetersPerSecond("raft_surface_acceleration"), adhesion_extruder_train->getSettingInMillimetersPerSecond("raft_surface_jerk")}
-        )
-, support_infill_config(
-            PrintFeatureType::Support
-            , support_infill_train->getSettingInMicrons("support_line_width")
-            , layer_thickness
-            , support_infill_train->getSettingInPercentage("material_flow")
-            , GCodePathConfig::SpeedDerivatives{support_infill_train->getSettingInMillimetersPerSecond("speed_support_infill"), support_infill_train->getSettingInMillimetersPerSecond("acceleration_support_infill"), support_infill_train->getSettingInMillimetersPerSecond("jerk_support_infill")}
-        )
-, support_interface_config(
-            PrintFeatureType::SupportInterface
-            , support_interface_train->getSettingInMicrons("support_interface_line_width")
-            , layer_thickness
-            , support_interface_train->getSettingInPercentage("material_flow")
-            , GCodePathConfig::SpeedDerivatives{support_interface_train->getSettingInMillimetersPerSecond("speed_support_interface"), support_interface_train->getSettingInMillimetersPerSecond("acceleration_support_interface"), support_interface_train->getSettingInMillimetersPerSecond("jerk_support_interface")}
-        )
-{
-    int extruder_count = storage.meshgroup->getExtruderCount();
-    travel_config_per_extruder.reserve(extruder_count);
-    skirt_brim_config.reserve(extruder_count);
-    prime_tower_config_per_extruder.reserve(extruder_count);
-    for (int extruder_nr = 0; extruder_nr < extruder_count; extruder_nr++)
-    {
-        const ExtruderTrain* train = storage.meshgroup->getExtruderTrain(extruder_nr);
-        travel_config_per_extruder.emplace_back(
-                PrintFeatureType::MoveCombing
-                , 0
-                , 0
-                , 0.0
-                , GCodePathConfig::SpeedDerivatives{train->getSettingInMillimetersPerSecond("speed_travel"), train->getSettingInMillimetersPerSecond("acceleration_travel"), train->getSettingInMillimetersPerSecond("jerk_travel")}
-            );
-        skirt_brim_config.emplace_back(
-                PrintFeatureType::SkirtBrim
-                , train->getSettingInMicrons("skirt_brim_line_width")
-                , layer_thickness
-                , train->getSettingInPercentage("material_flow")
-                , GCodePathConfig::SpeedDerivatives{train->getSettingInMillimetersPerSecond("skirt_brim_speed"), train->getSettingInMillimetersPerSecond("acceleration_skirt_brim"), train->getSettingInMillimetersPerSecond("jerk_skirt_brim")}
-            );
-        prime_tower_config_per_extruder.emplace_back(
-                PrintFeatureType::SupportInfill
-                , train->getSettingInMicrons("prime_tower_line_width")
-                , layer_thickness
-                , train->getSettingInPercentage("prime_tower_flow")
-                , GCodePathConfig::SpeedDerivatives{train->getSettingInMillimetersPerSecond("speed_prime_tower"), train->getSettingInMillimetersPerSecond("acceleration_prime_tower"), train->getSettingInMillimetersPerSecond("jerk_prime_tower")}
-            );
-    }
-
-    mesh_configs.reserve(storage.meshes.size());
-    for (const SliceMeshStorage& mesh_storage : storage.meshes)
-    {
-        mesh_configs.emplace_back(mesh_storage, layer_thickness);
-    }
-
-    int initial_speedup_layer_count = storage.getSettingAsCount("speed_slowdown_layers");
-    if (layer_nr < initial_speedup_layer_count)
-    {
-        handleInitialLayerSpeedup(storage, layer_nr, initial_speedup_layer_count);
-    }
-}
-
-void cura::PathConfigStorage::handleInitialLayerSpeedup(const SliceDataStorage& storage, int layer_nr, int initial_speedup_layer_count)
-{
-    std::vector<GCodePathConfig::SpeedDerivatives> global_first_layer_config_per_extruder;
-    global_first_layer_config_per_extruder.reserve(storage.meshgroup->getExtruderCount());
-    for (int extruder_nr = 0; extruder_nr < storage.meshgroup->getExtruderCount(); extruder_nr++)
-    {
-        const ExtruderTrain* extruder = storage.meshgroup->getExtruderTrain(extruder_nr);
-        global_first_layer_config_per_extruder.emplace_back(
-            GCodePathConfig::SpeedDerivatives{
-                extruder->getSettingInMillimetersPerSecond("speed_print_layer_0")
-                , extruder->getSettingInMillimetersPerSecond("acceleration_print_layer_0")
-                , extruder->getSettingInMillimetersPerSecond("jerk_print_layer_0")
-            });
-    }
-
-    { // support
-        if (layer_nr < initial_speedup_layer_count)
-        {
-            int extruder_nr_support_infill = storage.getSettingAsIndex((layer_nr <= 0)? "support_extruder_nr_layer_0" : "support_infill_extruder_nr");
-            GCodePathConfig::SpeedDerivatives& first_layer_config_infill = global_first_layer_config_per_extruder[extruder_nr_support_infill];
-            support_infill_config.smoothSpeed(first_layer_config_infill, std::max(0, layer_nr), initial_speedup_layer_count);
-
-            int extruder_nr_support_interface = storage.getSettingAsIndex("support_interface_extruder_nr");
-            GCodePathConfig::SpeedDerivatives& first_layer_config_interface = global_first_layer_config_per_extruder[extruder_nr_support_interface];
-            support_interface_config.smoothSpeed(first_layer_config_interface, std::max(0, layer_nr), initial_speedup_layer_count);
-        }
-    }
-
-    { // extruder configs: travel, skirt/brim (= shield)
-        for (int extruder_nr = 0; extruder_nr < storage.meshgroup->getExtruderCount(); ++extruder_nr)
-        {
-            const ExtruderTrain* train = storage.meshgroup->getExtruderTrain(extruder_nr);
-            GCodePathConfig::SpeedDerivatives initial_layer_speed_config{
-                    train->getSettingInMillimetersPerSecond("speed_travel_layer_0")
-                    , train->getSettingInMillimetersPerSecond("acceleration_travel_layer_0")
-                    , train->getSettingInMillimetersPerSecond("jerk_travel_layer_0")
-            };
-            GCodePathConfig& travel = travel_config_per_extruder[extruder_nr];
-
-            travel.smoothSpeed(initial_layer_speed_config, std::max(0, layer_nr), initial_speedup_layer_count);
-
-            // don't smooth speed for the skirt/brim!
-            // NOTE: not smoothing skirt/brim means the speeds are also not smoothed for the draft/ooze shield
-
-            GCodePathConfig& prime_tower = prime_tower_config_per_extruder[extruder_nr];
-
-            prime_tower.smoothSpeed(initial_layer_speed_config, std::max(0, layer_nr), initial_speedup_layer_count);
-        }
-
-    }
-
-    { // meshes
-        for (unsigned int mesh_idx = 0; mesh_idx < storage.meshes.size(); mesh_idx++)
-        {
-            const SliceMeshStorage& mesh = storage.meshes[mesh_idx];
-
-
-            GCodePathConfig::SpeedDerivatives initial_layer_speed_config{
-                    mesh.getSettingInMillimetersPerSecond("speed_print_layer_0")
-                    , mesh.getSettingInMillimetersPerSecond("acceleration_print_layer_0")
-                    , mesh.getSettingInMillimetersPerSecond("jerk_print_layer_0")
-            };
-
-            MeshPathConfigs& mesh_config = mesh_configs[mesh_idx];
-            //Outer wall speed (per mesh).
-            mesh_config.inset0_config.smoothSpeed(initial_layer_speed_config, layer_nr, initial_speedup_layer_count);
-
-            //Inner wall speed (per mesh).
-            mesh_config.insetX_config.smoothSpeed(initial_layer_speed_config, layer_nr, initial_speedup_layer_count);
-
-            //Skin speed (per mesh).
-            mesh_config.skin_config.smoothSpeed(initial_layer_speed_config, layer_nr, initial_speedup_layer_count);
-            mesh_config.perimeter_gap_config.smoothSpeed(initial_layer_speed_config, layer_nr, initial_speedup_layer_count);
-
-            for (unsigned int idx = 0; idx < MAX_INFILL_COMBINE; idx++)
-            {
-                //Infill speed (per combine part per mesh).
-                mesh_config.infill_config[idx].smoothSpeed(initial_layer_speed_config, layer_nr, initial_speedup_layer_count);
-            }
-        }
-    }
-}
-
-
-}//namespace cura

src/settings/PathConfigStorage.h

@@ -1,63 +0,0 @@
-/** Copyright (C) 2017 Ultimaker - Released under terms of the AGPLv3 License */
-#ifndef SETTINGS_PATH_CONFIGS_H
-#define SETTINGS_PATH_CONFIGS_H
-
-#include <vector>
-
-#include "../utils/intpoint.h" // coord_t
-#include "../GCodePathConfig.h"
-
-namespace cura
-{
-
-class SliceDataStorage; // forward decl for SliceDataStorage
-class SliceMeshStorage; // forward decl for SliceDataStorage
-class ExtruderTrain; // forward decl for SliceDataStorage
-
-/*!
- * A class to represent all configurations for all features types of printed lines in a meshgroup.
- */
-class PathConfigStorage
-{
-private:
-    const ExtruderTrain* adhesion_extruder_train;
-    const ExtruderTrain* support_infill_train;
-    const ExtruderTrain* support_interface_train;
-public:
-    class MeshPathConfigs
-    {
-    public:
-        GCodePathConfig inset0_config;
-        GCodePathConfig insetX_config;
-        GCodePathConfig skin_config;
-        GCodePathConfig perimeter_gap_config;
-        std::vector<GCodePathConfig> infill_config;
-
-        MeshPathConfigs(const SliceMeshStorage& mesh, int layer_thickness);
-    };
-    
-    GCodePathConfig raft_base_config;
-    GCodePathConfig raft_interface_config;
-    GCodePathConfig raft_surface_config;
-
-    std::vector<GCodePathConfig> travel_config_per_extruder; //!< The config used for travel moves (only speed is set!)
-    std::vector<GCodePathConfig> skirt_brim_config; //!< Configuration for skirt and brim per extruder.
-    std::vector<GCodePathConfig> prime_tower_config_per_extruder; //!< Configuration for the prime tower per extruder.
-
-    GCodePathConfig support_infill_config; //!< The config used to print the normal support, rather than the support interface
-    GCodePathConfig support_interface_config; //!< The config to use to print the dense roofs and bottoms of support
-
-    std::vector<MeshPathConfigs> mesh_configs; //!< For each meash the config for all its feature types
-    
-    /*!
-     * \warning Note that the layer_nr might be below zero for raft (filler) layers
-     */
-    PathConfigStorage(const SliceDataStorage& storage, int layer_nr, int layer_thickness);
-
-private:
-    void handleInitialLayerSpeedup(const SliceDataStorage& storage, int layer_nr, int initial_speedup_layer_count);
-};
-
-}; // namespace cura
-
-#endif // SETTINGS_PATH_CONFIGS_H

src/settings/SettingRegistry.cpp

@@ -125,21 +125,15 @@ 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())
-    {
-        logError("Couldn't find any extruder trains!\n");
-        return -1;
-    }
     if (extruder_nr >= extruder_train_ids.size())
     {
-        logWarning("Couldn't load extruder.def.json file for extruder %i. Index out of bounds.\n Loading first extruder definition instead.\n", extruder_nr);
-        extruder_nr = 0;
+        return -1;
     }
+    
     std::string definition_file;
     bool found = getDefinitionFile(extruder_train_ids[extruder_nr], definition_file);
     if (!found)
     {
-        logError("Couldn't find extruder.def.json file for extruder %i.\n", extruder_nr);
         return -1;
     }
     bool warn_base_file_duplicates = false;
@@ -223,9 +217,26 @@ int SettingRegistry::loadJSONsettingsFromDoc(rapidjson::Document& json_document,
         return 3;
     }
 
+    { // handle machine name
+        std::string machine_name = "Unknown";
+        if (json_document.HasMember("name"))
+        {
+            const rapidjson::Value& machine_name_field = json_document["name"];
+            if (machine_name_field.IsString())
+            {
+                machine_name = machine_name_field.GetString();
+            }
+        }
+        SettingConfig& machine_name_setting = addSetting("machine_name", "Machine Name");
+        machine_name_setting.setDefault(machine_name);
+        machine_name_setting.setType("string");
+        settings_base->_setSetting(machine_name_setting.getKey(), machine_name_setting.getDefaultValue());
+    }
+
     if (json_document.HasMember("settings"))
     {
-        handleChildren(json_document["settings"], settings_base, warn_duplicates);
+        std::list<std::string> path;
+        handleChildren(json_document["settings"], path, settings_base, warn_duplicates);
     }
     
     if (json_document.HasMember("overrides"))
@@ -247,19 +258,21 @@ int SettingRegistry::loadJSONsettingsFromDoc(rapidjson::Document& json_document,
     return 0;
 }
 
-void SettingRegistry::handleChildren(const rapidjson::Value& settings_list, SettingsBase* settings_base, bool warn_duplicates)
+void SettingRegistry::handleChildren(const rapidjson::Value& settings_list, std::list<std::string>& path, SettingsBase* settings_base, bool warn_duplicates)
 {
     if (!settings_list.IsObject())
     {
-        logError("json settings list is not an object!\n");
+        logError("ERROR: json settings list is not an object!\n");
         return;
     }
     for (rapidjson::Value::ConstMemberIterator setting_iterator = settings_list.MemberBegin(); setting_iterator != settings_list.MemberEnd(); ++setting_iterator)
     {
-        handleSetting(setting_iterator, settings_base, warn_duplicates);
+        handleSetting(setting_iterator, path, settings_base, warn_duplicates);
         if (setting_iterator->value.HasMember("children"))
         {
-            handleChildren(setting_iterator->value["children"], settings_base, warn_duplicates);
+            std::list<std::string> path_here = path;
+            path_here.push_back(setting_iterator->name.GetString());
+            handleChildren(setting_iterator->value["children"], path_here, settings_base, warn_duplicates);
         }
     }
 }
@@ -277,12 +290,12 @@ bool SettingRegistry::settingIsUsedByEngine(const rapidjson::Value& setting)
 }
 
 
-void SettingRegistry::handleSetting(const rapidjson::Value::ConstMemberIterator& json_setting_it, SettingsBase* settings_base, bool warn_duplicates)
+void SettingRegistry::handleSetting(const rapidjson::Value::ConstMemberIterator& json_setting_it, std::list<std::string>& path, SettingsBase* settings_base, bool warn_duplicates)
 {
     const rapidjson::Value& json_setting = json_setting_it->value;
     if (!json_setting.IsObject())
     {
-        logError("json setting is not an object!\n");
+        logError("ERROR: json setting is not an object!\n");
         return;
     }
     std::string name = json_setting_it->name.GetString();
@@ -295,7 +308,7 @@ void SettingRegistry::handleSetting(const rapidjson::Value::ConstMemberIterator&
     {
         if (!json_setting.HasMember("label") || !json_setting["label"].IsString())
         {
-            logError("json setting \"%s\" has no label!\n", name.c_str());
+            logError("ERROR: json setting \"%s\" has no label!\n", name.c_str());
             return;
         }
         std::string label = json_setting["label"].GetString();
@@ -303,7 +316,7 @@ void SettingRegistry::handleSetting(const rapidjson::Value::ConstMemberIterator&
         SettingConfig* setting = getSettingConfig(name);
         if (warn_duplicates && setting)
         {
-            cura::logWarning("Duplicate definition of setting: %s a.k.a. \"%s\" was already claimed by \"%s\"\n", name.c_str(), label.c_str(), getSettingConfig(name)->getLabel().c_str());
+            cura::logError("Duplicate definition of setting: %s a.k.a. \"%s\" was already claimed by \"%s\"\n", name.c_str(), label.c_str(), getSettingConfig(name)->getLabel().c_str());
         }
         if (!setting)
         {

src/settings/SettingRegistry.h

@@ -174,16 +174,17 @@ private:
      * \param settings_base The settings base where to store the default values.
      * \param warn_duplicates whether to warn for duplicate setting definitions
      */
-    void handleChildren(const rapidjson::Value& settings_list, SettingsBase* settings_base, bool warn_duplicates);
+    void handleChildren(const rapidjson::Value& settings_list, std::list<std::string>& path, SettingsBase* settings_base, bool warn_duplicates);
     
     /*!
      * Handle a json object for a setting.
      * 
      * \param json_setting_it Iterator for the setting which contains the key (setting name) and attributes info
+     * \param path The path of (internal) setting names traversed to get to this object
      * \param settings_base The settings base where to store the default values.
      * \param warn_duplicates whether to warn for duplicate setting definitions
      */
-    void handleSetting(const rapidjson::Value::ConstMemberIterator& json_setting_it, SettingsBase* settings_base, bool warn_duplicates);
+    void handleSetting(const rapidjson::Value::ConstMemberIterator& json_setting_it, std::list<std::string>& path, SettingsBase* settings_base, bool warn_duplicates);
 };
 
 }//namespace cura

src/settings/SettingsToGV.h

@@ -13,7 +13,6 @@
 #include <cassert>
 #include <fstream>
 #include <set>
-#include <unordered_map>
 
 #include "rapidjson/rapidjson.h"
 #include "rapidjson/document.h"
@@ -37,16 +36,13 @@ class SettingsToGv
     
     FILE* out;
     std::set<std::string> engine_settings;
-    
-    std::unordered_map<std::string, std::string> setting_to_color;
-    bool parent_child_viz, inherit_viz, error_viz, warning_viz, global_only_viz;
+    bool parent_child_viz, inherit_viz, error_viz, warning_viz;
 public: 
-    SettingsToGv(std::string output_filename, std::string engine_settings_filename, bool parent_child_viz, bool inherit_viz, bool error_viz, bool warning_viz, bool global_only_viz)
+    SettingsToGv(std::string output_filename, std::string engine_settings_filename, bool parent_child_viz, bool inherit_viz, bool error_viz, bool warning_viz)
     : parent_child_viz(parent_child_viz)
     , inherit_viz(inherit_viz)
     , error_viz(error_viz)
     , warning_viz(warning_viz)
-    , global_only_viz(global_only_viz)
     {
         out = fopen(output_filename.c_str(), "w");
         fprintf(out, "digraph G {\n");
@@ -64,31 +60,14 @@ public:
 private:
     void generateEdge(const std::string& parent, const std::string& child, RelationType relation_type)
     {
-        if (global_only_viz)
+        if (engine_settings.find(parent) != engine_settings.end())
         {
-            auto parent_it = setting_to_color.find(parent);
-            if (parent_it != setting_to_color.end())
-            {
-                fprintf(out, "%s [color=%s];\n", parent_it->first.c_str(), parent_it->second.c_str());
-            }
-            auto child_it = setting_to_color.find(child);
-            if (child_it != setting_to_color.end())
-            {
-                fprintf(out, "%s [color=%s];\n", child_it->first.c_str(), child_it->second.c_str());
-            }
+            fprintf(out, "%s [color=green];\n", parent.c_str());
         }
-        else
+        if (engine_settings.find(child) != engine_settings.end())
         {
-            if (engine_settings.find(parent) != engine_settings.end())
-            {
-                fprintf(out, "%s [color=green];\n", parent.c_str());
-            }
-            if (engine_settings.find(child) != engine_settings.end())
-            {
-                fprintf(out, "%s [color=green];\n", child.c_str());
-            }
+            fprintf(out, "%s [color=green];\n", child.c_str());
         }
-
         std::string color;
         switch (relation_type)
         {
@@ -147,10 +126,7 @@ private:
                     inherited_setting_string != "if" && inherited_setting_string != "else" && inherited_setting_string != "and" 
                     && inherited_setting_string != "or" && inherited_setting_string != "math" && inherited_setting_string != "ceil" 
                     && inherited_setting_string != "int" && inherited_setting_string != "round" && inherited_setting_string != "max" // exclude operators and functions
-                    && inherited_setting_string != "log" // exclude functions
                     && inherited_setting_string != "grid" && inherited_setting_string != "triangles" // exclude enum values
-                    && inherited_setting_string != "cubic" && inherited_setting_string != "tetrahedral" // exclude enum values
-                    && inherited_setting_string != "raft" // exclude enum values
                     && function.c_str()[regex_match.position() + regex_match.length()] != '\'') // exclude enum terms
                 {
                     if (inherited_setting_string == parent)
@@ -181,41 +157,12 @@ private:
         
         if (data.HasMember("type") && data["type"].IsString() && data["type"].GetString() != std::string("category"))
         {
-            if (global_only_viz)
-            {
-                std::string color;
-                if (!data.HasMember("settable_per_mesh") || data["settable_per_mesh"].GetBool() == true)
-                {
-                    color = "green";
-                }
-                else if (data.HasMember("settable_per_mesh") && data["settable_per_mesh"].GetBool() == false)
-                {
-                    if (!data.HasMember("settable_per_extruder") || data["settable_per_extruder"].GetBool() == true)
-                    {
-                        color = "yellow";
-                    }
-                    else if (data.HasMember("settable_per_extruder") && data["settable_per_extruder"].GetBool() == false)
-                    {
-                        if (!data.HasMember("settable_per_meshgroup") || data["settable_per_meshgroup"].GetBool() == true)
-                        {
-                            color = "orange";
-                        }
-                        else if (data.HasMember("settable_per_meshgroup") && data["settable_per_meshgroup"].GetBool() == false)
-                        {
-                            color = "red";
-                        }
-                    }
-                }
-                setting_to_color.emplace(name, color);
-//                 fprintf(out, "%s [color=%s];\n", name.c_str(), color.c_str());
-            }
             
-            
-            bool generated_edge_inherit = createFunctionEdges(data, "value", parent, name, RelationType::INHERIT_FUNCTION);
-            bool generated_edge_max = createFunctionEdges(data, "maximum_value", parent, name, RelationType::ERROR_FUNCTION);
-            bool generated_edge_min = createFunctionEdges(data, "minimum_value", parent, name, RelationType::ERROR_FUNCTION);
-            bool generated_edge_max_warn = createFunctionEdges(data, "maximum_value_warning", parent, name, RelationType::WARNING_FUNCTION);
-            bool generated_edge_min_warn = createFunctionEdges(data, "minimum_value_warning", parent, name, RelationType::WARNING_FUNCTION);
+            bool generated_edge_inherit = createFunctionEdges(data, "inherit_function", parent, name, RelationType::INHERIT_FUNCTION);
+            bool generated_edge_max = createFunctionEdges(data, "max_value", parent, name, RelationType::ERROR_FUNCTION);
+            bool generated_edge_min = createFunctionEdges(data, "min_value", parent, name, RelationType::ERROR_FUNCTION);
+            bool generated_edge_max_warn = createFunctionEdges(data, "max_value_warning", parent, name, RelationType::WARNING_FUNCTION);
+            bool generated_edge_min_warn = createFunctionEdges(data, "min_value_warning", parent, name, RelationType::WARNING_FUNCTION);
             if (generated_edge_inherit || generated_edge_max_warn || generated_edge_min_warn || generated_edge_max || generated_edge_min)
             {
                 generated_edge = true;

src/settings/settings.cpp

@@ -33,8 +33,6 @@ std::string toString(EGCodeFlavor flavor)
             return "RepRap(Volumetric)";
         case EGCodeFlavor::GRIFFIN:
             return "Griffin";
-        case EGCodeFlavor::REPETIER:
-            return "Repetier";
         case EGCodeFlavor::REPRAP:
         default:
             return "RepRap";
@@ -42,7 +40,7 @@ std::string toString(EGCodeFlavor flavor)
 }
 
 SettingsBaseVirtual::SettingsBaseVirtual()
-: parent(nullptr)
+: parent(NULL)
 {
 }
 
@@ -52,7 +50,7 @@ SettingsBaseVirtual::SettingsBaseVirtual(SettingsBaseVirtual* parent)
 }
 
 SettingsBase::SettingsBase()
-: SettingsBaseVirtual(nullptr)
+: SettingsBaseVirtual(NULL)
 {
 }
 
@@ -80,36 +78,24 @@ void SettingsBase::setSetting(std::string key, std::string value)
     }
     else
     {
-        cura::logWarning("Setting an unregistered setting %s to %s\n", key.c_str(), value.c_str());
+        cura::logError("Warning: setting an unregistered setting %s to %s\n", key.c_str(), value.c_str());
         _setSetting(key, value); // Handy when programmers are in the process of introducing a new setting
     }
 }
 
-void SettingsBase::setSettingInheritBase(std::string key, const SettingsBaseVirtual& parent)
-{
-    setting_inherit_base.emplace(key, &parent);
-}
-
-
 std::string SettingsBase::getSettingString(std::string key) const
 {
-    auto value_it = setting_values.find(key);
-    if (value_it != setting_values.end())
+    if (setting_values.find(key) != setting_values.end())
     {
-        return value_it->second;
-    }
-    auto inherit_override_it = setting_inherit_base.find(key);
-    if (inherit_override_it != setting_inherit_base.end())
-    {
-        return inherit_override_it->second->getSettingString(key);
+        return setting_values.at(key);
     }
     if (parent)
     {
         return parent->getSettingString(key);
     }
 
-    cura::logError("Trying to retrieve unregistered setting with no value given: '%s'\n", key.c_str());
-    std::exit(-1);
+    const_cast<SettingsBase&>(*this).setting_values[key] = "";
+    cura::logError("Unregistered setting %s\n", key.c_str());
     return "";
 }
 
@@ -118,12 +104,6 @@ void SettingsMessenger::setSetting(std::string key, std::string value)
     parent->setSetting(key, value);
 }
 
-void SettingsMessenger::setSettingInheritBase(std::string key, const SettingsBaseVirtual& new_parent)
-{
-    parent->setSettingInheritBase(key, new_parent);
-}
-
-
 std::string SettingsMessenger::getSettingString(std::string key) const
 {
     return parent->getSettingString(key);
@@ -141,34 +121,17 @@ int SettingsBaseVirtual::getSettingAsCount(std::string key) const
     return atoi(value.c_str());
 }
 
-unsigned int SettingsBaseVirtual::getSettingAsLayerNumber(std::string key) const
-{
-    const unsigned int indicated_layer_number = stoul(getSettingString(key));
-    if (indicated_layer_number < 1) //Input checking: Layer 0 is not allowed.
-    {
-        cura::logWarning("Invalid layer number %i for setting %s.", indicated_layer_number, key.c_str());
-        return 0; //Assume layer 1.
-    }
-    return indicated_layer_number - 1; //Input starts counting at layer 1, but engine code starts counting at layer 0.
-}
-
 double SettingsBaseVirtual::getSettingInMillimeters(std::string key) const
 {
     std::string value = getSettingString(key);
     return atof(value.c_str());
 }
 
-coord_t SettingsBaseVirtual::getSettingInMicrons(std::string key) const
+int SettingsBaseVirtual::getSettingInMicrons(std::string key) const
 {
     return getSettingInMillimeters(key) * 1000.0;
 }
 
-double SettingsBaseVirtual::getSettingInAngleDegrees(std::string key) const
-{
-    std::string value = getSettingString(key);
-    return atof(value.c_str());
-}
-
 double SettingsBaseVirtual::getSettingInAngleRadians(std::string key) const
 {
     std::string value = getSettingString(key);
@@ -197,7 +160,7 @@ double SettingsBaseVirtual::getSettingInDegreeCelsius(std::string key) const
 double SettingsBaseVirtual::getSettingInMillimetersPerSecond(std::string key) const
 {
     std::string value = getSettingString(key);
-    return std::max(0.0, atof(value.c_str()));
+    return std::max(1.0, atof(value.c_str()));
 }
 
 double SettingsBaseVirtual::getSettingInCubicMillimeters(std::string key) const
@@ -212,32 +175,12 @@ double SettingsBaseVirtual::getSettingInPercentage(std::string key) const
     return std::max(0.0, atof(value.c_str()));
 }
 
-double SettingsBaseVirtual::getSettingAsRatio(std::string key) const
-{
-    std::string value = getSettingString(key);
-    return atof(value.c_str()) / 100.0;
-}
-
 double SettingsBaseVirtual::getSettingInSeconds(std::string key) const
 {
     std::string value = getSettingString(key);
     return std::max(0.0, atof(value.c_str()));
 }
 
-DraftShieldHeightLimitation SettingsBaseVirtual::getSettingAsDraftShieldHeightLimitation(const std::string key) const
-{
-    const std::string value = getSettingString(key);
-    if (value == "full")
-    {
-        return DraftShieldHeightLimitation::FULL;
-    }
-    else if (value == "limited")
-    {
-        return DraftShieldHeightLimitation::LIMITED;
-    }
-    return DraftShieldHeightLimitation::FULL; //Default.
-}
-
 FlowTempGraph SettingsBaseVirtual::getSettingAsFlowTempGraph(std::string key) const
 {
     FlowTempGraph ret;
@@ -282,47 +225,6 @@ FlowTempGraph SettingsBaseVirtual::getSettingAsFlowTempGraph(std::string key) co
     return ret;
 }
 
-FMatrix3x3 SettingsBaseVirtual::getSettingAsPointMatrix(std::string key) const
-{
-    FMatrix3x3 ret;
-
-    std::string value_string = getSettingString(key);
-    if (value_string.empty())
-    {
-        return ret; // standard matrix ([1,0,0],[0,1,0],[0,0,1])
-    }
-
-    std::string num("([^,\\] ]*)"); // match with anything but the next ',' ']' or space  and capture the match
-    std::ostringstream row; // match with "[num,num,num]" and ignore whitespace
-    row << "\\s*\\[\\s*" << num << "\\s*,\\s*" << num << "\\s*,\\s*" << num << "\\s*\\]\\s*";
-
-    std::ostringstream matrix; // match with "[row,row,row]" and ignore whitespace
-    matrix << "\\s*\\[" << row.str() << "\\s*,\\s*" << row.str() << "\\s*,\\s*" << row.str() << "\\]\\s*";
-
-    std::regex point_matrix_regex(matrix.str());
-    std::cmatch sub_matches;    // same as std::match_results<const char*> cm;
-    std::regex_match(value_string.c_str(), sub_matches, point_matrix_regex);
-
-    if (sub_matches.size() != 10) // one match for the whole string
-    {
-        logWarning("Mesh transformation matrix could not be parsed!\n\tFormat should be [[f,f,f],[f,f,f],[f,f,f]] allowing whitespace anywhere in between.\n\tWhile what was given was \"%s\".\n", value_string.c_str());
-        return ret; // standard matrix ([1,0,0],[0,1,0],[0,0,1])
-    }
-
-    unsigned int sub_match_idx = 1; // skip the first because the first submatch is the whole string
-    for (unsigned int x = 0; x < 3; x++)
-    {
-        for (unsigned int y = 0; y < 3; y++)
-        {
-            std::sub_match<const char*> sub_match = sub_matches[sub_match_idx];
-            ret.m[y][x] = strtod(std::string(sub_match.str()).c_str(), nullptr);
-            sub_match_idx++;
-        }
-    }
-
-    return ret;
-}
-
 
 EGCodeFlavor SettingsBaseVirtual::getSettingAsGCodeFlavor(std::string key) const
 {
@@ -339,8 +241,6 @@ EGCodeFlavor SettingsBaseVirtual::getSettingAsGCodeFlavor(std::string key) const
         return EGCodeFlavor::MACH3;
     else if (value == "RepRap (Volumatric)")
         return EGCodeFlavor::REPRAP_VOLUMATRIC;
-    else if (value == "Repetier")
-        return EGCodeFlavor::REPETIER;
     return EGCodeFlavor::REPRAP;
 }
 
@@ -353,16 +253,12 @@ EFillMethod SettingsBaseVirtual::getSettingAsFillMethod(std::string key) const
         return EFillMethod::GRID;
     if (value == "cubic")
         return EFillMethod::CUBIC;
-    if (value == "cubicsubdiv")
-        return EFillMethod::CUBICSUBDIV;
     if (value == "tetrahedral")
         return EFillMethod::TETRAHEDRAL;
     if (value == "triangles")
         return EFillMethod::TRIANGLES;
     if (value == "concentric")
         return EFillMethod::CONCENTRIC;
-    if (value == "concentric_3d")
-        return EFillMethod::CONCENTRIC_3D;
     if (value == "zigzag")
         return EFillMethod::ZIG_ZAG;
     return EFillMethod::NONE;
@@ -375,8 +271,6 @@ EPlatformAdhesion SettingsBaseVirtual::getSettingAsPlatformAdhesion(std::string
         return EPlatformAdhesion::BRIM;
     if (value == "raft")
         return EPlatformAdhesion::RAFT;
-    if (value == "none")
-        return EPlatformAdhesion::NONE;
     return EPlatformAdhesion::SKIRT;
 }
 
@@ -414,21 +308,7 @@ ESurfaceMode SettingsBaseVirtual::getSettingAsSurfaceMode(std::string key) const
     return ESurfaceMode::NORMAL;
 }
 
-FillPerimeterGapMode SettingsBaseVirtual::getSettingAsFillPerimeterGapMode(std::string key) const
-{
-    std::string value = getSettingString(key);
-    if (value == "nowhere")
-    {
-        return FillPerimeterGapMode::NOWHERE;
-    }
-    if (value == "everywhere")
-    {
-        return FillPerimeterGapMode::EVERYWHERE;
-    }
-    return FillPerimeterGapMode::NOWHERE;
-}
-
-CombingMode SettingsBaseVirtual::getSettingAsCombingMode(std::string key) const
+CombingMode SettingsBaseVirtual::getSettingAsCombingMode(std::string key)
 {
     std::string value = getSettingString(key);
     if (value == "off")
@@ -446,7 +326,7 @@ CombingMode SettingsBaseVirtual::getSettingAsCombingMode(std::string key) const
     return CombingMode::ALL;
 }
 
-SupportDistPriority SettingsBaseVirtual::getSettingAsSupportDistPriority(std::string key) const
+SupportDistPriority SettingsBaseVirtual::getSettingAsSupportDistPriority(std::string key)
 {
     std::string value = getSettingString(key);
     if (value == "xy_overrides_z")

src/settings/settings.h

@@ -86,8 +86,6 @@ enum class EGCodeFlavor
  *  M227 is used to initialize a single extrusion train.
  **/
     GRIFFIN = 6,
-
-    REPETIER = 7,
 };
 
 /*!
@@ -105,24 +103,21 @@ enum class EFillMethod
     LINES,
     GRID,
     CUBIC,
-    CUBICSUBDIV,
     TETRAHEDRAL,
     TRIANGLES,
     CONCENTRIC,
-    CONCENTRIC_3D,
     ZIG_ZAG,
     NONE
 };
 
 /*!
- * Type of platform adhesion.
+ * Type of platform adheasion
  */
 enum class EPlatformAdhesion
 {
     SKIRT,
     BRIM,
-    RAFT,
-    NONE
+    RAFT
 };
 
 /*!
@@ -149,12 +144,6 @@ enum class ESurfaceMode
     BOTH
 };
 
-enum class FillPerimeterGapMode
-{
-    NOWHERE,
-    EVERYWHERE
-};
-
 enum class CombingMode
 {
     OFF,
@@ -162,15 +151,6 @@ enum class CombingMode
     NO_SKIN
 };
 
-/*!
- * How the draft shield height is limited.
- */
-enum class DraftShieldHeightLimitation
-{
-    FULL, //Draft shield takes full height of the print.
-    LIMITED //Draft shield is limited by draft_shield_height setting.
-};
-
 enum class SupportDistPriority
 {
     XY_OVERRIDES_Z,
@@ -197,16 +177,7 @@ public:
     virtual std::string getSettingString(std::string key) const = 0;
     
     virtual void setSetting(std::string key, std::string value) = 0;
-
-    /*!
-     * Set the parent settings base for inheriting a setting to a specific setting base.
-     * This overrides the use of \ref SettingsBaseVirtual::parent.
-     * 
-     * \param key The setting for which to override the inheritance
-     * \param parent The setting base from which to obtain the setting instead.
-     */
-    virtual void setSettingInheritBase(std::string key, const SettingsBaseVirtual& parent) = 0;
-
+    
     virtual ~SettingsBaseVirtual() {}
     
     SettingsBaseVirtual(); //!< SettingsBaseVirtual without a parent settings object
@@ -217,42 +188,27 @@ public:
     
     int getSettingAsIndex(std::string key) const;
     int getSettingAsCount(std::string key) const;
-
-    /*!
-     * \brief Interprets a setting as a layer number.
-     *
-     * The input of the layer number is one-based. This translates it to
-     * zero-based numbering.
-     *
-     * \return Zero-based numbering of a layer number setting.
-     */
-    unsigned int getSettingAsLayerNumber(std::string key) const;
-
-    double getSettingInAngleDegrees(std::string key) const;
+    
     double getSettingInAngleRadians(std::string key) const;
     double getSettingInMillimeters(std::string key) const;
-    coord_t getSettingInMicrons(std::string key) const;
+    int getSettingInMicrons(std::string key) const;
     bool getSettingBoolean(std::string key) const;
     double getSettingInDegreeCelsius(std::string key) const;
     double getSettingInMillimetersPerSecond(std::string key) const;
     double getSettingInCubicMillimeters(std::string key) const;
     double getSettingInPercentage(std::string key) const;
-    double getSettingAsRatio(std::string key) const; //!< For settings which are provided in percentage
     double getSettingInSeconds(std::string key) const;
-
+    
     FlowTempGraph getSettingAsFlowTempGraph(std::string key) const;
-    FMatrix3x3 getSettingAsPointMatrix(std::string key) const;
-
-    DraftShieldHeightLimitation getSettingAsDraftShieldHeightLimitation(const std::string key) const;
+    
     EGCodeFlavor getSettingAsGCodeFlavor(std::string key) const;
     EFillMethod getSettingAsFillMethod(std::string key) const;
     EPlatformAdhesion getSettingAsPlatformAdhesion(std::string key) const;
     ESupportType getSettingAsSupportType(std::string key) const;
     EZSeamType getSettingAsZSeamType(std::string key) const;
     ESurfaceMode getSettingAsSurfaceMode(std::string key) const;
-    FillPerimeterGapMode getSettingAsFillPerimeterGapMode(std::string key) const;
-    CombingMode getSettingAsCombingMode(std::string key) const;
-    SupportDistPriority getSettingAsSupportDistPriority(std::string key) const;
+    CombingMode getSettingAsCombingMode(std::string key);
+    SupportDistPriority getSettingAsSupportDistPriority(std::string key);
 };
 
 class SettingRegistry;
@@ -268,11 +224,6 @@ class SettingsBase : public SettingsBaseVirtual
     friend class SettingRegistry;
 private:
     std::unordered_map<std::string, std::string> setting_values;
-
-    /*!
-     * Mapping for each setting which must inherit from a different setting base than \ref SettingsBaseVirtual::parent
-     */
-    std::unordered_map<std::string, const SettingsBaseVirtual*> setting_inherit_base;
 public:
     SettingsBase(); //!< SettingsBase without a parent settings object
     SettingsBase(SettingsBaseVirtual* parent); //!< construct a SettingsBase with a parent settings object
@@ -283,7 +234,6 @@ public:
      * \param value the value
      */
     void setSetting(std::string key, std::string value);
-    void setSettingInheritBase(std::string key, const SettingsBaseVirtual& parent); //!< See \ref SettingsBaseVirtual::setSettingInheritBase
     std::string getSettingString(std::string key) const; //!< Get a setting from this SettingsBase (or any ancestral SettingsBase)
     
     std::string getAllLocalSettingsString() const
@@ -324,7 +274,6 @@ public:
     SettingsMessenger(SettingsBaseVirtual* parent); //!< construct a SettingsMessenger with a parent settings object
     
     void setSetting(std::string key, std::string value); //!< Set a setting of the parent SettingsBase to a given value
-    void setSettingInheritBase(std::string key, const SettingsBaseVirtual& parent); //!< See \ref SettingsBaseVirtual::setSettingInheritBase
     std::string getSettingString(std::string key) const; //!< Get a setting from the parent SettingsBase (or any further ancestral SettingsBase)
 };
 

src/skin.cpp

@@ -1,8 +1,6 @@
 /** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
 #include <cmath> // std::ceil
-
 #include "skin.h"
-#include "utils/math.h"
 #include "utils/polygonUtils.h"
 
 #define MIN_AREA_SIZE (0.4 * 0.4) 
@@ -10,35 +8,20 @@
 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)
+        
+void generateSkins(int layerNr, SliceMeshStorage& mesh, int extrusionWidth, int downSkinCount, int upSkinCount, int wall_line_count, int innermost_wall_extrusion_width, int insetCount, bool no_small_gaps_heuristic)
 {
-    generateSkinAreas(layerNr, mesh, innermost_wall_line_width, downSkinCount, upSkinCount, wall_line_count, no_small_gaps_heuristic);
+    generateSkinAreas(layerNr, mesh, innermost_wall_extrusion_width, downSkinCount, upSkinCount, wall_line_count, no_small_gaps_heuristic);
 
     SliceLayer* layer = &mesh.layers[layerNr];
     for(unsigned int partNr=0; partNr<layer->parts.size(); partNr++)
     {
         SliceLayerPart* part = &layer->parts[partNr];
-        generateSkinInsets(part, innermost_wall_line_width, insetCount);
+        generateSkinInsets(part, extrusionWidth, insetCount);
     }
 }
 
-/*
- * 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)
+void generateSkinAreas(int layer_nr, SliceMeshStorage& mesh, int innermost_wall_extrusion_width, int downSkinCount, int upSkinCount, int wall_line_count, bool no_small_gaps_heuristic)
 {
     SliceLayer& layer = mesh.layers[layer_nr];
     
@@ -46,7 +29,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];
@@ -56,8 +39,8 @@ void generateSkinAreas(int layer_nr, SliceMeshStorage& mesh, const int innermost
             continue; // the last wall is not present, the part should only get inter perimeter gaps, but no skin.
         }
 
-        Polygons upskin = part.insets.back().offset(-innermost_wall_line_width / 2);
-        Polygons downskin = (downSkinCount == 0) ? Polygons() : upskin;
+        Polygons upskin = part.insets.back().offset(-innermost_wall_extrusion_width/2);
+        Polygons downskin = (downSkinCount == 0)? Polygons() : upskin;
         if (upSkinCount == 0) upskin = Polygons();
 
         auto getInsidePolygons = [&part, wall_line_count](SliceLayer& layer2)
@@ -78,22 +61,12 @@ void generateSkinAreas(int layer_nr, SliceMeshStorage& mesh, const int innermost
         {
             if (static_cast<int>(layer_nr - downSkinCount) >= 0)
             {
-                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
+                downskin = downskin.difference(getInsidePolygons(mesh.layers[layer_nr - downSkinCount])); // skin overlaps with the walls
             }
             
             if (static_cast<int>(layer_nr + upSkinCount) < static_cast<int>(mesh.layers.size()))
             {
-                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
+                upskin = upskin.difference(getInsidePolygons(mesh.layers[layer_nr + upSkinCount])); // skin overlaps with the walls
             }
         }
         else 
@@ -105,24 +78,16 @@ 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
             }
             
-            if (layer_nr < static_cast<int>(mesh.layers.size()) - 1 - upSkinCount && upSkinCount > 0)
+            if (layer_nr < static_cast<int>(mesh.layers.size()) - 1 && upSkinCount > 0)
             {
                 Polygons not_air = getInsidePolygons(mesh.layers[layer_nr + 1]);
                 for (int upskin_layer_nr = layer_nr + 2; upskin_layer_nr < layer_nr + upSkinCount + 1; upskin_layer_nr++)
                 {
                     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
             }
         }
@@ -139,13 +104,8 @@ 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)
+
+void generateSkinInsets(SliceLayerPart* part, int extrusionWidth, int insetCount)
 {
     if (insetCount == 0)
     {
@@ -159,11 +119,10 @@ void generateSkinInsets(SliceLayerPart* part, const int wall_line_width, int ins
             skin_part.insets.push_back(Polygons());
             if (i == 0)
             {
-                skin_part.insets[0] = skin_part.outline.offset(-wall_line_width / 2);
-            }
-            else
+                skin_part.insets[0] = skin_part.outline.offset(- extrusionWidth/2);
+            } else
             {
-                skin_part.insets[i] = skin_part.insets[i - 1].offset(-wall_line_width);
+                skin_part.insets[i] = skin_part.insets[i - 1].offset(-extrusionWidth);
             }
             
             // optimize polygons: remove unnecessary verts
@@ -177,33 +136,17 @@ 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)
+void generateInfill(int layerNr, SliceMeshStorage& mesh, int innermost_wall_extrusion_width, int infill_skin_overlap, int wall_line_count)
 {
     SliceLayer& layer = mesh.layers[layerNr];
 
-    int extra_offset = 0;
-    EFillMethod fill_pattern = mesh.getSettingAsFillMethod("infill_pattern");
-    if ((fill_pattern == EFillMethod::CONCENTRIC || fill_pattern == EFillMethod::CONCENTRIC_3D)
-        && mesh.getSettingBoolean("alternate_extra_perimeter")
-        && layerNr % 2 == 0
-        && mesh.getSettingInMicrons("infill_line_distance") > mesh.getSettingInMicrons("infill_line_width") * 2)
-    {
-        extra_offset = -innermost_wall_line_width;
-    }
-
     for(SliceLayerPart& part : layer.parts)
     {
         if (int(part.insets.size()) < wall_line_count)
         {
             continue; // the last wall is not present, the part should only get inter preimeter gaps, but no infill.
         }
-        Polygons infill = part.insets.back().offset(extra_offset - innermost_wall_line_width / 2 - infill_skin_overlap);
+        Polygons infill = part.insets.back().offset(-innermost_wall_extrusion_width / 2 - infill_skin_overlap);
 
         for(SliceLayerPart& part2 : layer.parts)
         {
@@ -216,17 +159,8 @@ void generateInfill(int layerNr, SliceMeshStorage& mesh, const int innermost_wal
             }
         }
         infill.removeSmallAreas(MIN_AREA_SIZE);
-
-        Polygons final_infill = infill.offset(infill_skin_overlap);
-
-        if (mesh.getSettingBoolean("infill_hollow"))
-        {
-            part.print_outline = part.print_outline.difference(final_infill);
-        }
-        else
-        {
-            part.infill_area = final_infill;
-        }
+        
+        part.infill_area = infill.offset(infill_skin_overlap);
     }
 }
 
@@ -238,7 +172,7 @@ void SkinInfillAreaComputation::generateGradualInfill(SliceMeshStorage& mesh, un
     {
         layer_skip_count = 1;
     }
-    unsigned int gradual_infill_step_layer_count = round_divide(gradual_infill_step_height, mesh.getSettingInMicrons("layer_height")); // The difference in layer count between consecutive density infill areas
+    unsigned int gradual_infill_step_layer_count = gradual_infill_step_height / mesh.getSettingInMicrons("layer_height"); // The difference in layer count between consecutive density infill areas
 
     // make gradual_infill_step_height divisable by layer_skip_count
     float n_skip_steps_per_gradual_step = std::max(1.0f, std::ceil(gradual_infill_step_layer_count / layer_skip_count)); // only decrease layer_skip_count to make it a divisor of gradual_infill_step_layer_count

src/skin.h

@@ -11,43 +11,38 @@ namespace cura
  * 
  * \param layerNr The index of the layer for which to generate the skins.
  * \param mesh The storage where the layer outline information (input) is stored and where the skin insets and fill areas (output) are stored.
+ * \param extrusionWidth extrusionWidth
  * \param downSkinCount The number of layers of bottom skin
  * \param upSkinCount The number of layers of top skin
  * \param wall_line_count The number of walls, i.e. the number of the wall from which to offset.
- * \param innermost_wall_line_width The line width of the inner most wall
+ * \param innermost_wall_extrusion_width The line width of the inner most wall
  * \param insetCount The number of perimeters to surround the skin
  * \param no_small_gaps_heuristic A heuristic which assumes there will be no small gaps between bottom and top skin with a z size smaller than the skin size itself
  */
-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);
+void generateSkins(int layerNr, SliceMeshStorage& mesh, int extrusionWidth, int downSkinCount, int upSkinCount, int wall_line_count, int innermost_wall_extrusion_width, int insetCount, bool no_small_gaps_heuristic);
 
 /*!
  * Generate the skin areas (outlines)
  * 
  * \param layerNr The index of the layer for which to generate the skins.
- * \param mesh The storage where the layer outline information (input) is stored
- * and where the skin outline (output) is stored.
- * \param innermost_wall_line_width The line width of the walls around the skin, by which
- * we must inset for each wall.
- * \param downSkinCount The number of layers of bottom skin.
- * \param upSkinCount The number of layers of top skin.
- * \param wall_line_count The number of walls, i.e. the number of the wall from
- * which to offset.
- * \param no_small_gaps_heuristic A heuristic which assumes there will be no
- * small gaps between bottom and top skin with a z size smaller than the skin
- * size itself.
+ * \param mesh The storage where the layer outline information (input) is stored and where the skin outline (output) is stored.
+ * \param extrusionWidth extrusionWidth
+ * \param downSkinCount The number of layers of bottom skin
+ * \param upSkinCount The number of layers of top skin
+ * \param wall_line_count The number of walls, i.e. the number of the wall from which to offset.
+ * \param no_small_gaps_heuristic A heuristic which assumes there will be no small gaps between bottom and top skin with a z size smaller than the skin size itself
  */
-void generateSkinAreas(int layerNr, SliceMeshStorage& mesh, const int innermost_wall_line_width, int downSkinCount, int upSkinCount, int wall_line_count, bool no_small_gaps_heuristic);
+void generateSkinAreas(int layerNr, SliceMeshStorage& mesh, int extrusionWidth, int downSkinCount, int upSkinCount, int wall_line_count, bool no_small_gaps_heuristic);
 
 /*!
  * Generate the skin insets.
  * 
  * \param layerNr The index of the layer for which to generate the skins.
- * \param part The part where the skin outline information (input) is stored and
- * where the skin insets (output) are stored.
- * \param wall_line_width The width of the perimeters around the skin.
- * \param insetCount The number of perimeters to surround the skin.
+ * \param part The part where the skin outline information (input) is stored and where the skin insets (output) are stored.
+ * \param extrusionWidth extrusionWidth
+ * \param insetCount The number of perimeters to surround the skin
  */
-void generateSkinInsets(SliceLayerPart* part, const int wall_line_width, int insetCount);
+void generateSkinInsets(SliceLayerPart* part, int extrusionWidth, int insetCount);
 
 /*!
  * Generate Infill by offsetting from the last wall.
@@ -59,11 +54,11 @@ void generateSkinInsets(SliceLayerPart* part, const int wall_line_width, int ins
  * \param layerNr The index of the layer for which to generate the infill
  * \param mesh The storage where the layer outline information (input) is stored and where the skin outline (output) is stored.
  * \param part The part where the insets (input) are stored and where the infill (output) is stored.
- * \param innermost_wall_line_width width of the innermost wall lines
+ * \param innermost_wall_extrusion_width width of the innermost wall lines
  * \param infill_skin_overlap overlap distance between infill and skin
  * \param wall_line_count The number of walls, i.e. the number of the wall from which to offset.
  */
-void generateInfill(int layerNr, SliceMeshStorage& mesh, const int innermost_wall_line_width, int infill_skin_overlap, int wall_line_count);
+void generateInfill(int layerNr, SliceMeshStorage& mesh, int innermost_wall_extrusion_width, int infill_skin_overlap, int wall_line_count);
 
 /*!
  * \brief Combines the infill of multiple layers for a specified mesh.

src/skirt.cpp

@@ -0,0 +1,89 @@
+/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
+#include "skirt.h"
+#include "support.h"
+
+#include <queue> 
+
+namespace cura 
+{
+
+void generateSkirt(SliceDataStorage& storage, int distance, int count, int minLength)
+{
+    if (count == 0) return;
+    
+    bool externalOnly = (distance > 0); // whether to include holes or not
+
+    int primary_extruder = storage.getSettingAsIndex("adhesion_extruder_nr");
+    int primary_extrusion_width = storage.meshgroup->getExtruderTrain(primary_extruder)->getSettingInMicrons("skirt_line_width");
+
+    Polygons& skirt_primary_extruder = storage.skirt[primary_extruder];
+    
+    bool get_convex_hull = count == 1 && distance > 0;
+    
+    Polygons first_layer_outline = storage.getLayerOutlines(0, true, externalOnly);
+    
+    std::vector<Polygons> skirts;
+    for(int skirtNr=0; skirtNr<count;skirtNr++)
+    {
+        int offsetDistance = distance + primary_extrusion_width * skirtNr + primary_extrusion_width / 2;
+
+        skirts.emplace_back(first_layer_outline.offset(offsetDistance, ClipperLib::jtRound));
+        Polygons& skirt_polygons = skirts.back();
+        
+        //Remove small inner skirt holes. Holes have a negative area, remove anything smaller then 100x extrusion "area"
+        for(unsigned int n=0; n<skirt_polygons.size(); n++)
+        {
+            double area = skirt_polygons[n].area();
+            if (area < 0 && area > -primary_extrusion_width * primary_extrusion_width * 100)
+                skirt_polygons.remove(n--);
+        }
+    
+        if (get_convex_hull)
+        {
+            skirt_polygons = skirt_polygons.approxConvexHull();
+        } 
+
+        skirt_primary_extruder.add(skirt_polygons);
+
+        int length = skirt_primary_extruder.polygonLength();
+        if (skirtNr + 1 >= count && length > 0 && length < minLength) // make brim have more lines when total length is too small
+            count++;
+    }
+
+
+    if (false) // the code below is for the old prime tower
+    { //Add a skirt UNDER the prime tower to make it stick better.
+        Polygons prime_tower = storage.primeTower.ground_poly.offset(-primary_extrusion_width / 2);
+        std::queue<Polygons> prime_tower_insets;
+        while(prime_tower.size() > 0)
+        {
+            prime_tower_insets.emplace(prime_tower);
+            prime_tower = prime_tower.offset(-primary_extrusion_width);
+        }
+        while (!prime_tower_insets.empty())
+        {
+            Polygons& inset = prime_tower_insets.back();
+            skirt_primary_extruder.add(inset);
+            prime_tower_insets.pop();
+        }
+    }
+    
+    { // process other extruders' brim/skirt (as one brim line around the old brim)
+        int offset_distance = 0;
+        int last_width = primary_extrusion_width;
+        for (int extruder = 0; extruder < storage.meshgroup->getExtruderCount(); extruder++)
+        {
+            if (extruder == primary_extruder) { continue; }
+            int width = storage.meshgroup->getExtruderTrain(extruder)->getSettingInMicrons("skirt_line_width");
+            offset_distance += last_width / 2 + width/2;
+            last_width = width;
+            while (storage.skirt[extruder].polygonLength() < minLength)
+            {
+                storage.skirt[extruder].add(skirts.back().offset(offset_distance, ClipperLib::jtRound));
+                offset_distance += width;
+            }
+        }
+    }
+}
+
+}//namespace cura

src/skirt.h

@@ -0,0 +1,22 @@
+/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
+#ifndef SKIRT_H
+#define SKIRT_H
+
+#include "sliceDataStorage.h"
+
+namespace cura 
+{
+
+/*!
+ * Generate skirt or brim (depending on parameters); when \p distance > 0 and \p count == 1 the skirt is generated, which has slighly different configuration.
+ * 
+ * \param storage Storage containing the parts at the first layer
+ * \param distance The distance of the first outset from the parts at the first layer
+ * \param count Number of outsets / brim lines
+ * \param minLength The minimum length the skirt should have (enforced by taking more outsets)
+ */
+void generateSkirt(SliceDataStorage& storage, int distance, int count, int minLength);
+
+}//namespace cura
+
+#endif//SKIRT_H

src/sliceDataStorage.cpp

@@ -1,11 +1,6 @@
-//Copyright (c) 2016 Ultimaker B.V.
-//CuraEngine is released under the terms of the AGPLv3 or higher.
-
 #include "sliceDataStorage.h"
 
 #include "FffProcessor.h" //To create a mesh group with if none is provided.
-#include "infill/SubDivCube.h" // For the destructor
-
 
 namespace cura
 {
@@ -35,7 +30,7 @@ void SliceLayer::getOutlines(Polygons& result, bool external_polys_only) const
     {
         if (external_polys_only)
         {
-            result.add(part.outline.outerPolygon());
+            result.add(const_cast<SliceLayerPart&>(part).outline.outerPolygon()); // TODO: make a const version of outerPolygon()
         }
         else 
         {
@@ -57,12 +52,12 @@ void SliceLayer::getSecondOrInnermostWalls(Polygons& layer_walls) const
     {
         // we want the 2nd inner walls
         if (part.insets.size() >= 2) {
-            layer_walls.add(part.insets[1]);
+            layer_walls.add(const_cast<SliceLayerPart&>(part).insets[1]); // TODO const cast!
             continue;
         }
         // but we'll also take the inner wall if the 2nd doesn't exist
         if (part.insets.size() == 1) {
-            layer_walls.add(part.insets[0]);
+            layer_walls.add(const_cast<SliceLayerPart&>(part).insets[0]); // TODO const cast!
             continue;
         }
         // offset_from_outlines was so large that it completely destroyed our isle,
@@ -72,13 +67,6 @@ void SliceLayer::getSecondOrInnermostWalls(Polygons& layer_walls) const
     }
 }
 
-SliceMeshStorage::~SliceMeshStorage()
-{
-    if (base_subdiv_cube)
-    {
-        delete base_subdiv_cube;
-    }
-}
 
 std::vector<RetractionConfig> SliceDataStorage::initializeRetractionConfigs()
 {
@@ -86,20 +74,42 @@ std::vector<RetractionConfig> SliceDataStorage::initializeRetractionConfigs()
     ret.resize(meshgroup->getExtruderCount()); // initializes with constructor RetractionConfig()
     return ret;
 }
-
+std::vector<GCodePathConfig> SliceDataStorage::initializeTravelConfigs()
+{
+    std::vector<GCodePathConfig> ret;
+    for (int extruder = 0; extruder < meshgroup->getExtruderCount(); extruder++)
+    {
+        travel_config_per_extruder.emplace_back(PrintFeatureType::MoveCombing);
+    }
+    return ret;
+}
+std::vector<GCodePathConfig> SliceDataStorage::initializeSkirtConfigs()
+{
+    std::vector<GCodePathConfig> ret;
+    for (int extruder = 0; extruder < meshgroup->getExtruderCount(); extruder++)
+    {
+        skirt_config.emplace_back(PrintFeatureType::Skirt);
+    }
+    return ret;
+}
 SliceDataStorage::SliceDataStorage(MeshGroup* meshgroup) : SettingsMessenger(meshgroup),
     meshgroup(meshgroup != nullptr ? meshgroup : new MeshGroup(FffProcessor::getInstance())), //If no mesh group is provided, we roll our own.
-    print_layer_count(0),
     retraction_config_per_extruder(initializeRetractionConfigs()),
     extruder_switch_retraction_config_per_extruder(initializeRetractionConfigs()),
-    max_print_height_second_to_last_extruder(-1),
-    primeTower(*this)
+    travel_config_per_extruder(initializeTravelConfigs()),
+    skirt_config(initializeSkirtConfigs()),
+    raft_base_config(PrintFeatureType::Support),
+    raft_interface_config(PrintFeatureType::Support),
+    raft_surface_config(PrintFeatureType::Support),
+    support_config(PrintFeatureType::Support),
+    support_roof_config(PrintFeatureType::Skin),
+    max_object_height_second_to_last_extruder(-1)
 {
 }
 
 Polygons SliceDataStorage::getLayerOutlines(int layer_nr, bool include_helper_parts, bool external_polys_only) const
 {
-    if (layer_nr < 0 && layer_nr < -Raft::getFillerLayerCount(*this))
+    if (layer_nr < 0)
     { // when processing raft
         if (include_helper_parts)
         {
@@ -126,33 +136,27 @@ Polygons SliceDataStorage::getLayerOutlines(int layer_nr, bool include_helper_pa
     else 
     {
         Polygons total;
-        if (layer_nr >= 0)
+        for (const SliceMeshStorage& mesh : meshes)
         {
-            for (const SliceMeshStorage& mesh : meshes)
+            if (mesh.getSettingBoolean("infill_mesh"))
             {
-                if (mesh.getSettingBoolean("infill_mesh") || mesh.getSettingBoolean("anti_overhang_mesh"))
-                {
-                    continue;
-                }
-                const SliceLayer& layer = mesh.layers[layer_nr];
-                layer.getOutlines(total, external_polys_only);
-                if (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") != ESurfaceMode::NORMAL)
-                {
-                    total = total.unionPolygons(layer.openPolyLines.offsetPolyLine(100));
-                }
+                continue;
+            }
+            const SliceLayer& layer = mesh.layers[layer_nr];
+            layer.getOutlines(total, external_polys_only);
+            if (const_cast<SliceMeshStorage&>(mesh).getSettingAsSurfaceMode("magic_mesh_surface_mode") != ESurfaceMode::NORMAL) // TODO: make all getSetting functions const??
+            {
+                total = total.unionPolygons(layer.openPolyLines.offsetPolyLine(100));
             }
         }
         if (include_helper_parts)
         {
             if (support.generated) 
             {
-                total.add(support.supportLayers[std::max(0, layer_nr)].supportAreas);
-                total.add(support.supportLayers[std::max(0, layer_nr)].skin);
-            }
-            if (primeTower.enabled)
-            {
-                total.add(primeTower.ground_poly);
+                total.add(support.supportLayers[layer_nr].supportAreas);
+                total.add(support.supportLayers[layer_nr].roofs);
             }
+            total.add(primeTower.ground_poly);
         }
         return total;
     }
@@ -160,7 +164,7 @@ Polygons SliceDataStorage::getLayerOutlines(int layer_nr, bool include_helper_pa
 
 Polygons SliceDataStorage::getLayerSecondOrInnermostWalls(int layer_nr, bool include_helper_parts) const
 {
-    if (layer_nr < 0 && layer_nr < -Raft::getFillerLayerCount(*this))
+    if (layer_nr < 0)
     { // when processing raft
         if (include_helper_parts)
         {
@@ -174,52 +178,43 @@ Polygons SliceDataStorage::getLayerSecondOrInnermostWalls(int layer_nr, bool inc
     else 
     {
         Polygons total;
-        if (layer_nr >= 0)
+        for (const SliceMeshStorage& mesh : meshes)
         {
-            for (const SliceMeshStorage& mesh : meshes)
+            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??
             {
-                const SliceLayer& layer = mesh.layers[layer_nr];
-                layer.getSecondOrInnermostWalls(total);
-                if (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") != ESurfaceMode::NORMAL)
-                {
-                    total = total.unionPolygons(layer.openPolyLines.offsetPolyLine(100));
-                }
+                total = total.unionPolygons(layer.openPolyLines.offsetPolyLine(100));
             }
         }
         if (include_helper_parts)
         {
             if (support.generated) 
             {
-                total.add(support.supportLayers[std::max(0, layer_nr)].supportAreas);
-                total.add(support.supportLayers[std::max(0, layer_nr)].skin);
-            }
-            if (primeTower.enabled)
-            {
-                total.add(primeTower.ground_poly);
+                total.add(support.supportLayers[layer_nr].supportAreas);
+                total.add(support.supportLayers[layer_nr].roofs);
             }
+            total.add(primeTower.ground_poly);
         }
         return total;
     }
 
 }
 
-std::vector<bool> SliceDataStorage::getExtrudersUsed() const
+std::vector< bool > SliceDataStorage::getExtrudersUsed()
 {
 
     std::vector<bool> ret;
     ret.resize(meshgroup->getExtruderCount(), false);
 
-    if (getSettingAsPlatformAdhesion("adhesion_type") != EPlatformAdhesion::NONE)
-    {
-        ret[getSettingAsIndex("adhesion_extruder_nr")] = true;
-        { // process brim/skirt
-            for (int extr_nr = 0; extr_nr < meshgroup->getExtruderCount(); extr_nr++)
+    ret[getSettingAsIndex("adhesion_extruder_nr")] = true; 
+    { // process brim/skirt
+        for (int extr_nr = 0; extr_nr < meshgroup->getExtruderCount(); extr_nr++)
+        {
+            if (skirt[extr_nr].size() > 0)
             {
-                if (skirt_brim[extr_nr].size() > 0)
-                {
-                    ret[extr_nr] = true;
-                    continue;
-                }
+                ret[extr_nr] = true;
+                continue;
             }
         }
     }
@@ -230,106 +225,12 @@ std::vector<bool> SliceDataStorage::getExtrudersUsed() const
     // support is presupposed to be present...
     ret[getSettingAsIndex("support_extruder_nr_layer_0")] = true;
     ret[getSettingAsIndex("support_infill_extruder_nr")] = true;
-    ret[getSettingAsIndex("support_interface_extruder_nr")] = true;
+    ret[getSettingAsIndex("support_roof_extruder_nr")] = true;
 
     // all meshes are presupposed to actually have content
-    for (const SliceMeshStorage& mesh : meshes)
+    for (SliceMeshStorage& mesh : meshes)
     {
-        if (!mesh.getSettingBoolean("anti_overhang_mesh")
-            && !mesh.getSettingBoolean("support_mesh")
-        )
-        {
-            ret[mesh.getSettingAsIndex("extruder_nr")] = true;
-        }
-    }
-    return ret;
-}
-
-std::vector<bool> SliceDataStorage::getExtrudersUsed(int layer_nr) const
-{
-
-    std::vector<bool> ret;
-    ret.resize(meshgroup->getExtruderCount(), false);
-
-    bool include_adhesion = true;
-    bool include_helper_parts = true;
-    bool include_models = true;
-    if (layer_nr < 0)
-    {
-        include_models = false;
-        if (layer_nr < -Raft::getFillerLayerCount(*this))
-        {
-            include_helper_parts = false;
-        }
-        else
-        {
-            layer_nr = 0; // because the helper parts are copied from the initial layer in the filler layer
-            include_adhesion = false;
-        }
-    }
-    else if (layer_nr > 0 || getSettingAsPlatformAdhesion("adhesion_type") == EPlatformAdhesion::RAFT)
-    { // only include adhesion only for layers where platform adhesion actually occurs
-        // i.e. layers < 0 are for raft, layer 0 is for brim/skirt
-        include_adhesion = false;
-    }
-    if (include_adhesion)
-    {
-        ret[getSettingAsIndex("adhesion_extruder_nr")] = true;
-        { // process brim/skirt
-            for (int extr_nr = 0; extr_nr < meshgroup->getExtruderCount(); extr_nr++)
-            {
-                if (skirt_brim[extr_nr].size() > 0)
-                {
-                    ret[extr_nr] = true;
-                    continue;
-                }
-            }
-        }
-    }
-
-    // TODO: ooze shield, draft shield ..?
-
-    if (include_helper_parts)
-    {
-        // support
-        if (layer_nr < int(support.supportLayers.size()))
-        {
-            const SupportLayer& support_layer = support.supportLayers[layer_nr];
-            if (layer_nr == 0)
-            {
-                if (support_layer.supportAreas.size() > 0)
-                {
-                    ret[getSettingAsIndex("support_extruder_nr_layer_0")] = true;
-                }
-            }
-            else
-            {
-                if (support_layer.supportAreas.size() > 0)
-                {
-                    ret[getSettingAsIndex("support_infill_extruder_nr")] = true;
-                }
-            }
-            if (support_layer.skin.size() > 0)
-            {
-                ret[getSettingAsIndex("support_interface_extruder_nr")] = true;
-            }
-        }
-    }
-
-    if (include_models)
-    {
-        for (const SliceMeshStorage& mesh : meshes)
-        {
-            if (layer_nr >= int(mesh.layers.size()))
-            {
-                continue;
-            }
-            const SliceLayer& layer = mesh.layers[layer_nr];
-            if (layer.parts.size() > 0)
-            {
-                ret[mesh.getSettingAsIndex("extruder_nr")] = true;
-            }
-        }
+        ret[mesh.getSettingAsIndex("extruder_nr")] = true;
     }
     return ret;
 }

src/sliceDataStorage.h

@@ -8,9 +8,10 @@
 #include "utils/NoCopy.h"
 #include "utils/AABB.h"
 #include "mesh.h"
+#include "gcodePlanner.h"
 #include "MeshGroup.h"
 #include "PrimeTower.h"
-#include "gcodeExport.h" // CoastingConfig
+#include "GCodePathConfig.h"
 
 namespace cura 
 {
@@ -123,9 +124,7 @@ class SupportLayer
 {
 public:
     Polygons supportAreas; //!< normal support areas
-    Polygons skin; //!< the support areas which are to be printed as denser roofs and/or bottoms. Note that the roof/bottom areas and support areas should be mutually exclusive.
-    Polygons support_mesh; //!< Areas from support meshes
-    Polygons anti_overhang; //!< Areas where no overhang should be detected.
+    Polygons roofs; //!< the support areas which are to be printed as denser roofs. Note that the roof areas and support areas are mutually exclusive.
 };
 
 class SupportStorage
@@ -137,17 +136,11 @@ public:
 
     std::vector<SupportLayer> supportLayers;
 
-    SupportStorage()
-    : generated(false)
-    , layer_nr_max_filled_layer(-1)
-    {
-    }
+    SupportStorage() : generated(false), layer_nr_max_filled_layer(-1) { }
     ~SupportStorage(){ supportLayers.clear(); }
 };
 /******************/
 
-class SubDivCube; // forward declaration to prevent dependency loop
-
 class SliceMeshStorage : public SettingsMessenger // passes on settings from a Mesh object
 {
 public:
@@ -155,17 +148,23 @@ public:
 
     int layer_nr_max_filled_layer; //!< the layer number of the uppermost layer with content (modified while infill meshes are processed)
 
-    SubDivCube* base_subdiv_cube;
+    GCodePathConfig inset0_config;
+    GCodePathConfig insetX_config;
+    GCodePathConfig skin_config;
+    std::vector<GCodePathConfig> infill_config;
 
     SliceMeshStorage(SettingsBaseVirtual* settings, unsigned int slice_layer_count)
     : SettingsMessenger(settings)
     , layer_nr_max_filled_layer(0)
-    , base_subdiv_cube(nullptr)
+    , inset0_config(PrintFeatureType::OuterWall)
+    , insetX_config(PrintFeatureType::InnerWall)
+    , skin_config(PrintFeatureType::Skin)
     {
-        layers.resize(slice_layer_count);
+        layers.reserve(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();
 };
 
 class SliceDataStorage : public SettingsMessenger, NoCopy
@@ -173,29 +172,48 @@ class SliceDataStorage : public SettingsMessenger, NoCopy
 public:
     MeshGroup* meshgroup; // needed to pass on the per extruder settings.. (TODO: put this somewhere else? Put the per object settings here directly, or a pointer only to the per object settings.)
 
-    unsigned int print_layer_count; //!< The total number of layers (except the raft and filler layers)
-
     Point3 model_size, model_min, model_max;
     std::vector<SliceMeshStorage> meshes;
 
     std::vector<RetractionConfig> retraction_config_per_extruder; //!< Retraction config per extruder.
     std::vector<RetractionConfig> extruder_switch_retraction_config_per_extruder; //!< Retraction config per extruder for when performing an extruder switch
 
+    std::vector<GCodePathConfig> travel_config_per_extruder; //!< The config used for travel moves (only speed is set!)
+
+    std::vector<GCodePathConfig> skirt_config; //!< config for skirt per extruder
     std::vector<CoastingConfig> coasting_config; //!< coasting config per extruder
 
+    GCodePathConfig raft_base_config;
+    GCodePathConfig raft_interface_config;
+    GCodePathConfig raft_surface_config;
+
+    GCodePathConfig support_config;
+    GCodePathConfig support_roof_config;
+
     SupportStorage support;
 
-    Polygons skirt_brim[MAX_EXTRUDERS]; //!< Skirt and brim polygons per extruder, ordered from inner to outer polygons.
+    Polygons skirt[MAX_EXTRUDERS]; //!< Skirt polygons per extruder, ordered from inner to outer polygons
     Polygons raftOutline;               //Storage for the outline of the raft. Will be filled with lines when the GCode is generated.
 
-    int max_print_height_second_to_last_extruder; //!< Used in multi-extrusion: the layer number beyond which all models are printed with the same extruder
-    std::vector<int> max_print_height_per_extruder; //!< For each extruder the highest layer number at which it is used.
-    std::vector<size_t> max_print_height_order; //!< Ordered indices into max_print_height_per_extruder: back() will return the extruder number with the highest print height.
-
+    int max_object_height_second_to_last_extruder; //!< Used in multi-extrusion: the layer number beyond which all models are printed with the same extruder
     PrimeTower primeTower;
 
     std::vector<Polygons> oozeShield;        //oozeShield per layer
     Polygons draft_protection_shield; //!< The polygons for a heightened skirt which protects from warping by gusts of wind and acts as a heated chamber.
+    Point wipePoint;
+
+    /*!
+     * Construct the initial retraction_config_per_extruder
+     */
+    std::vector<RetractionConfig> initializeRetractionConfigs();
+    /*!
+     * Construct the initial travel_config_per_extruder
+     */
+    std::vector<GCodePathConfig> initializeTravelConfigs();
+    /*!
+     * Construct the initial skirt_config s for each extruder
+     */
+    std::vector<GCodePathConfig> initializeSkirtConfigs();
 
     /*!
      * \brief Creates a new slice data storage that stores the slice data of the
@@ -237,21 +255,7 @@ public:
      * 
      * \return a vector of bools indicating whether the extruder with corresponding index is used in this layer.
      */
-    std::vector<bool> getExtrudersUsed() const;
-
-    /*!
-     * Get the extruders used on a particular layer.
-     * 
-     * \param layer_nr the layer for which to check
-     * \return a vector of bools indicating whether the extruder with corresponding index is used in this layer.
-     */
-    std::vector<bool> getExtrudersUsed(int layer_nr) const;
-
-private:
-    /*!
-     * Construct the retraction_config_per_extruder
-     */
-    std::vector<RetractionConfig> initializeRetractionConfigs();
+    std::vector<bool> getExtrudersUsed();
 };
 
 }//namespace cura

src/slicer.cpp

@@ -5,13 +5,13 @@
 
 #include "utils/gettime.h"
 #include "utils/logoutput.h"
-#include "utils/SparsePointGridInclusive.h"
 
 #include "slicer.h"
+#include "debug.h" // TODO remove
 
 
 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
@@ -31,17 +31,17 @@ void SlicerLayer::makeBasicPolygonLoops(const Mesh* mesh, Polygons& open_polylin
 
 void SlicerLayer::makeBasicPolygonLoop(const Mesh* mesh, Polygons& open_polylines, unsigned int start_segment_idx)
 {
-
+    
     Polygon poly;
     poly.add(segments[start_segment_idx].start);
-
+    
     for (int segment_idx = start_segment_idx; segment_idx != -1; )
     {
         SlicerSegment& segment = segments[segment_idx];
         poly.add(segment.end);
         segment.addedToPolygon = true;
         segment_idx = getNextSegmentIdx(mesh, segment, start_segment_idx);
-        if (segment_idx == static_cast<int>(start_segment_idx))
+        if (segment_idx == static_cast<int>(start_segment_idx)) 
         { // polyon is closed
             polygons.add(poly);
             return;
@@ -51,488 +51,153 @@ void SlicerLayer::makeBasicPolygonLoop(const Mesh* mesh, Polygons& open_polyline
     open_polylines.add(poly);
 }
 
-int SlicerLayer::tryFaceNextSegmentIdx(const Mesh* mesh, const SlicerSegment& segment, int face_idx, unsigned int start_segment_idx) const
-{
-    decltype(face_idx_to_segment_idx.begin()) it;
-    auto it_end = face_idx_to_segment_idx.end();
-    it = face_idx_to_segment_idx.find(face_idx);
-    if (it != it_end)
-    {
-        int segment_idx = (*it).second;
-        Point p1 = segments[segment_idx].start;
-        Point diff = segment.end - p1;
-        if (shorterThen(diff, largest_neglected_gap_first_phase))
-        {
-            if (segment_idx == static_cast<int>(start_segment_idx))
-            {
-                return start_segment_idx;
-            }
-            if (segments[segment_idx].addedToPolygon)
-            {
-                return -1;
-            }
-            return segment_idx;
-        }
-    }
-
-    return -1;
-}
-
 int SlicerLayer::getNextSegmentIdx(const Mesh* mesh, const SlicerSegment& segment, unsigned int start_segment_idx)
 {
     int next_segment_idx = -1;
-
-    bool segment_ended_at_edge = segment.endVertex == nullptr;
-    if (segment_ended_at_edge)
-    {
-        int face_to_try = segment.endOtherFaceIdx;
-        if (face_to_try == -1)
+    const MeshFace& face = mesh->faces[segment.faceIndex];
+    for (unsigned int face_edge_idx = 0; face_edge_idx < 3; face_edge_idx++)
+    { // check segments in connected faces
+        decltype(face_idx_to_segment_idx.begin()) it;
+        if (face.connected_face_index[face_edge_idx] > -1 && (it = face_idx_to_segment_idx.find(face.connected_face_index[face_edge_idx])) != face_idx_to_segment_idx.end())
         {
-            return -1;
-        }
-        return tryFaceNextSegmentIdx(mesh,segment,face_to_try,start_segment_idx);
-    }
-    else
-    {
-        // segment ended at vertex
-
-        const std::vector<uint32_t> &faces_to_try = segment.endVertex->connected_faces;
-        for (int face_to_try : faces_to_try)
-        {
-            int result_segment_idx =
-                tryFaceNextSegmentIdx(mesh,segment,face_to_try,start_segment_idx);
-            if (result_segment_idx == static_cast<int>(start_segment_idx))
+            int segment_idx = (*it).second;
+            Point p1 = segments[segment_idx].start;
+            Point diff = segment.end - p1;
+            if (shorterThen(diff, largest_neglected_gap_first_phase))
             {
-                return start_segment_idx;
-            }
-            else if (result_segment_idx != -1)
-            {
-                // not immediately returned since we might still encounter the start_segment_idx
-                next_segment_idx = result_segment_idx;
+                if (segment_idx == static_cast<int>(start_segment_idx))
+                {
+                    return start_segment_idx;
+                }
+                if (segments[segment_idx].addedToPolygon)
+                {
+                    continue;
+                }
+                next_segment_idx = segment_idx; // not immediately returned since we might still encounter the start_segment_idx
             }
         }
     }
-
     return next_segment_idx;
 }
 
 void SlicerLayer::connectOpenPolylines(Polygons& open_polylines)
 {
-    bool allow_reverse = false;
-    // Search a bit fewer cells but at cost of covering more area.
-    // Since acceptance area is small to start with, the extra is unlikely to hurt much.
-    coord_t cell_size = largest_neglected_gap_first_phase * 2;
-    connectOpenPolylinesImpl(open_polylines, largest_neglected_gap_second_phase, cell_size, allow_reverse);
+    // TODO use some space partitioning data structure to make this run faster than O(n^2)
+    for(unsigned int open_polyline_idx = 0; open_polyline_idx < open_polylines.size(); open_polyline_idx++)
+    {
+        PolygonRef open_polyline = open_polylines[open_polyline_idx];
+        
+        if (open_polyline.size() < 1) continue;
+        for(unsigned int open_polyline_other_idx = 0; open_polyline_other_idx < open_polylines.size(); open_polyline_other_idx++)
+        {
+            PolygonRef open_polyline_other = open_polylines[open_polyline_other_idx];
+            
+            if (open_polyline_other.size() < 1) continue;
+            
+            Point diff = open_polyline.back() - open_polyline_other[0];
+
+            if (shorterThen(diff, largest_neglected_gap_second_phase))
+            {
+                if (open_polyline_idx == open_polyline_other_idx)
+                {
+                    polygons.add(open_polyline);
+                    open_polyline.clear();
+                    break;
+                }
+                else
+                {
+                    for (unsigned int line_idx = 0; line_idx < open_polyline_other.size(); line_idx++)
+                    {
+                        open_polyline.add(open_polyline_other[line_idx]);
+                    }
+                    open_polyline_other.clear();
+                }
+            }
+        }
+    }
 }
 
 void SlicerLayer::stitch(Polygons& open_polylines)
-{
-    bool allow_reverse = true;
-    connectOpenPolylinesImpl(open_polylines, max_stitch1, max_stitch1, allow_reverse);
-}
-
-const SlicerLayer::Terminus SlicerLayer::Terminus::INVALID_TERMINUS{~static_cast<Index>(0U)};
-
-bool SlicerLayer::PossibleStitch::operator<(const PossibleStitch& other) const
-{
-    // better if lower distance
-    if (dist2 > other.dist2)
+{ // TODO This is an inefficient implementation which can run in O(n^3) time.
+    // below code closes smallest gaps first
+    while(1)
     {
-        return true;
-    }
-    else if (dist2 < other.dist2)
-    {
-        return false;
-    }
-
-    // better if in order instead of reversed
-    if (!in_order() && other.in_order())
-    {
-        return true;
-    }
-
-    // better if lower Terminus::Index for terminus_0
-    // This just defines a more total order and isn't strictly necessary.
-    if (terminus_0.asIndex() > other.terminus_0.asIndex())
-    {
-        return true;
-    }
-    else if (terminus_0.asIndex() < other.terminus_0.asIndex())
-    {
-        return false;
-    }
-
-    // better if lower Terminus::Index for terminus_1
-    // This just defines a more total order and isn't strictly necessary.
-    if (terminus_1.asIndex() > other.terminus_1.asIndex())
-    {
-        return true;
-    }
-    else if (terminus_1.asIndex() < other.terminus_1.asIndex())
-    {
-        return false;
-    }
-
-    // The stitches have equal goodness
-    return false;
-}
-
-std::priority_queue<SlicerLayer::PossibleStitch>
-SlicerLayer::findPossibleStitches(
-    const Polygons& open_polylines,
-    coord_t max_dist, coord_t cell_size,
-    bool allow_reverse) const
-{
-    std::priority_queue<PossibleStitch> stitch_queue;
-
-    // maximum distance squared
-    int64_t max_dist2 = max_dist * max_dist;
-
-    // Represents a terminal point of a polyline in open_polylines.
-    struct StitchGridVal
-    {
-        unsigned int polyline_idx;
-        // Depending on the SparsePointGridInclusive, either the start point or the
-        // end point of the polyline
-        Point polyline_term_pt;
-    };
-
-    struct StitchGridValLocator
-    {
-        Point operator()(const StitchGridVal& val) const
+        int64_t best_dist2 = max_stitch1 * max_stitch1;
+        unsigned int best_polyline_1_idx = -1;
+        unsigned int best_polyline_2_idx = -1;
+        bool reversed = false;
+        for(unsigned int polyline_1_idx = 0; polyline_1_idx < open_polylines.size(); polyline_1_idx++)
         {
-            return val.polyline_term_pt;
-        }
-    };
-
-    // Used to find nearby end points within a fixed maximum radius
-    SparsePointGrid<StitchGridVal,StitchGridValLocator> grid_ends(cell_size);
-    // Used to find nearby start points within a fixed maximum radius
-    SparsePointGrid<StitchGridVal,StitchGridValLocator> grid_starts(cell_size);
-
-    // populate grids
-
-    // Inserts the ends of all polylines into the grid (does not
-    //   insert the starts of the polylines).
-    for(unsigned int polyline_0_idx = 0; polyline_0_idx < open_polylines.size(); polyline_0_idx++)
-    {
-        ConstPolygonRef polyline_0 = open_polylines[polyline_0_idx];
-
-        if (polyline_0.size() < 1) continue;
-
-        StitchGridVal grid_val;
-        grid_val.polyline_idx = polyline_0_idx;
-        grid_val.polyline_term_pt = polyline_0.back();
-        grid_ends.insert(grid_val);
-    }
-
-    // Inserts the start of all polylines into the grid.
-    if (allow_reverse)
-    {
-        for(unsigned int polyline_0_idx = 0; polyline_0_idx < open_polylines.size(); polyline_0_idx++)
-        {
-            ConstPolygonRef polyline_0 = open_polylines[polyline_0_idx];
-
-            if (polyline_0.size() < 1) continue;
-
-            StitchGridVal grid_val;
-            grid_val.polyline_idx = polyline_0_idx;
-            grid_val.polyline_term_pt = polyline_0[0];
-            grid_starts.insert(grid_val);
-        }
-    }
-
-    // search for nearby end points
-    for(unsigned int polyline_1_idx = 0; polyline_1_idx < open_polylines.size(); polyline_1_idx++)
-    {
-        ConstPolygonRef polyline_1 = open_polylines[polyline_1_idx];
-
-        if (polyline_1.size() < 1) continue;
-
-        std::vector<StitchGridVal> nearby_ends;
-
-        // Check for stitches that append polyline_1 onto polyline_0
-        // in natural order.  These are stitches that use the end of
-        // polyline_0 and the start of polyline_1.
-        nearby_ends = grid_ends.getNearby(polyline_1[0], max_dist);
-        for (const auto& nearby_end : nearby_ends)
-        {
-            Point diff = nearby_end.polyline_term_pt - polyline_1[0];
-            int64_t dist2 = vSize2(diff);
-            if (dist2 < max_dist2)
+            PolygonRef polyline_1 = open_polylines[polyline_1_idx];
+            
+            if (polyline_1.size() < 1) continue;
+            for(unsigned int polyline_2_idx = 0; polyline_2_idx < open_polylines.size(); polyline_2_idx++)
             {
-                PossibleStitch poss_stitch;
-                poss_stitch.dist2 = dist2;
-                poss_stitch.terminus_0 = Terminus{nearby_end.polyline_idx, true};
-                poss_stitch.terminus_1 = Terminus{polyline_1_idx, false};
-                stitch_queue.push(poss_stitch);
-            }
-        }
-
-        if (allow_reverse)
-        {
-            // Check for stitches that append polyline_1 onto polyline_0
-            // by reversing order of polyline_1.  These are stitches that
-            // use the end of polyline_0 and the end of polyline_1.
-            nearby_ends = grid_ends.getNearby(polyline_1.back(), max_dist);
-            for (const auto& nearby_end : nearby_ends)
-            {
-                // Disallow stitching with self with same end point
-                if (nearby_end.polyline_idx == polyline_1_idx)
-                {
-                    continue;
-                }
-
-                Point diff = nearby_end.polyline_term_pt - polyline_1.back();
+                PolygonRef polyline_2 = open_polylines[polyline_2_idx];
+                
+                if (polyline_2.size() < 1) continue;
+                
+                Point diff = polyline_1.back() - polyline_2[0];
                 int64_t dist2 = vSize2(diff);
-                if (dist2 < max_dist2)
+                if (dist2 < best_dist2)
                 {
-                    PossibleStitch poss_stitch;
-                    poss_stitch.dist2 = dist2;
-                    poss_stitch.terminus_0 = Terminus{nearby_end.polyline_idx, true};
-                    poss_stitch.terminus_1 = Terminus{polyline_1_idx, true};
-                    stitch_queue.push(poss_stitch);
-                }
-            }
-
-            // Check for stitches that append polyline_1 onto polyline_0
-            // by reversing order of polyline_0.  These are stitches that
-            // use the start of polyline_0 and the start of polyline_1.
-            std::vector<StitchGridVal> nearby_starts =
-                grid_starts.getNearby(polyline_1[0], max_dist);
-            for (const auto& nearby_start : nearby_starts)
-            {
-                // Disallow stitching with self with same end point
-                if (nearby_start.polyline_idx == polyline_1_idx)
-                {
-                    continue;
+                    best_dist2 = dist2;
+                    best_polyline_1_idx = polyline_1_idx;
+                    best_polyline_2_idx = polyline_2_idx;
+                    reversed = false;
                 }
 
-                Point diff = nearby_start.polyline_term_pt - polyline_1[0];
-                int64_t dist2 = vSize2(diff);
-                if (dist2 < max_dist2)
+                if (polyline_1_idx != polyline_2_idx)
                 {
-                    PossibleStitch poss_stitch;
-                    poss_stitch.dist2 = dist2;
-                    poss_stitch.terminus_0 = Terminus{nearby_start.polyline_idx, false};
-                    poss_stitch.terminus_1 = Terminus{polyline_1_idx, false};
-                    stitch_queue.push(poss_stitch);
+                    Point diff = polyline_1.back() - polyline_2.back();
+                    int64_t dist2 = vSize2(diff);
+                    if (dist2 < best_dist2)
+                    {
+                        best_dist2 = dist2;
+                        best_polyline_1_idx = polyline_1_idx;
+                        best_polyline_2_idx = polyline_2_idx;
+                        reversed = true;
+                    }
                 }
             }
         }
-    }
-
-    return stitch_queue;
-}
-
-void SlicerLayer::planPolylineStitch(
-    const Polygons& open_polylines,
-    Terminus& terminus_0, Terminus& terminus_1, bool reverse[2]) const
-{
-    size_t polyline_0_idx = terminus_0.getPolylineIdx();
-    size_t polyline_1_idx = terminus_1.getPolylineIdx();
-    bool back_0 = terminus_0.isEnd();
-    bool back_1 = terminus_1.isEnd();
-    reverse[0] = false;
-    reverse[1] = false;
-    if (back_0)
-    {
-        if (back_1)
-        {
-            // back of both polylines
-            // we can reverse either one and then append onto the other
-            // reverse the smaller polyline
-            if (open_polylines[polyline_0_idx].size() <
-                open_polylines[polyline_1_idx].size())
-            {
-                std::swap(terminus_0,terminus_1);
-            }
-            reverse[1] = true;
-        } else {
-            // back of 0, front of 1
-            // already in order, nothing to do
-        }
-    }
-    else
-    {
-        if (back_1)
-        {
-            // front of 0, back of 1
-            // in order if we swap 0 and 1
-            std::swap(terminus_0,terminus_1);
+        
+        if (best_dist2 >= max_stitch1 * max_stitch1)
+            break; // this code is reached if there was nothing to stitch within the distance limits
+        
+        PolygonRef polyline_1 = open_polylines[best_polyline_1_idx];
+        PolygonRef polyline_2 = open_polylines[best_polyline_2_idx];
+        
+        if (best_polyline_1_idx == best_polyline_2_idx)
+        { // connect last piece of 'circle'
+            polygons.add(polyline_1);
+            polyline_1.clear();
         }
         else
-        {
-            // front of both polylines
-            // we can reverse either one and then prepend to the other
-            // reverse the smaller polyline
-            if (open_polylines[polyline_0_idx].size() >
-                open_polylines[polyline_1_idx].size())
+        { // connect two polylines
+            if (reversed)
             {
-                std::swap(terminus_0,terminus_1);
+                if (polyline_1.size() > polyline_2.size()) // decide which polygon to copy into the other
+                {
+                    for(int poly_idx = polyline_2.size()-1; poly_idx >= 0; poly_idx--)
+                        polyline_1.add(polyline_2[poly_idx]);
+                    polyline_2.clear();
+                } 
+                else
+                {
+                    for(int poly_idx = polyline_1.size()-1; poly_idx >= 0; poly_idx--)
+                        polyline_2.add(polyline_1[poly_idx]);
+                    polyline_1.clear();
+                }
+                // note that either way we end up with the end of former polyline_1 next to the start of former polyline_2
             }
-            reverse[0] = true;
-        }
-    }
-}
-
-void SlicerLayer::joinPolylines(PolygonRef& polyline_0, PolygonRef& polyline_1,
-                                const bool reverse[2]) const
-{
-    if (reverse[0])
-    {
-        // reverse polyline_0
-        size_t size_0 = polyline_0.size();
-        for (size_t idx = 0U; idx != size_0/2; ++idx)
-        {
-            std::swap(polyline_0[idx], polyline_0[size_0-1-idx]);
-        }
-    }
-    if (reverse[1])
-    {
-        // reverse polyline_1 by adding in reverse order
-        for(int poly_idx = polyline_1.size() - 1; poly_idx >= 0; poly_idx--)
-            polyline_0.add(polyline_1[poly_idx]);
-    }
-    else
-    {
-        // append polyline_1 onto polyline_0
-        for(Point& p : polyline_1)
-            polyline_0.add(p);
-    }
-    polyline_1.clear();
-}
-
-SlicerLayer::TerminusTrackingMap::TerminusTrackingMap(Terminus::Index end_idx) :
-    m_terminus_old_to_cur_map(end_idx)
-{
-    // Initialize map to everything points to itself since nothing has moved yet.
-    for (size_t idx = 0U; idx != end_idx; ++idx)
-    {
-        m_terminus_old_to_cur_map[idx] = Terminus{idx};
-    }
-    m_terminus_cur_to_old_map = m_terminus_old_to_cur_map;
-}
-
-void SlicerLayer::TerminusTrackingMap::updateMap(
-    size_t num_terms,
-    const Terminus *cur_terms, const Terminus *next_terms,
-    size_t num_removed_terms,
-    const Terminus *removed_cur_terms)
-{
-    // save old locations
-    std::vector<Terminus> old_terms(num_terms);
-    for (size_t idx = 0U; idx != num_terms; ++idx)
-    {
-        old_terms[idx] = getOldFromCur(cur_terms[idx]);
-    }
-    // update using maps old <-> cur and cur <-> next
-    for (size_t idx = 0U; idx != num_terms; ++idx)
-    {
-        m_terminus_old_to_cur_map[old_terms[idx].asIndex()] = next_terms[idx];
-        Terminus next_term = next_terms[idx];
-        if (next_term != Terminus::INVALID_TERMINUS)
-        {
-            m_terminus_cur_to_old_map[next_term.asIndex()] = old_terms[idx];
-        }
-    }
-    // remove next locations that no longer exist
-    for (size_t rem_idx = 0U; rem_idx != num_removed_terms; ++rem_idx)
-    {
-        m_terminus_cur_to_old_map[removed_cur_terms[rem_idx].asIndex()] =
-            Terminus::INVALID_TERMINUS;
-    }
-}
-
-void SlicerLayer::connectOpenPolylinesImpl(Polygons& open_polylines, coord_t max_dist, coord_t cell_size, bool allow_reverse)
-{
-    // below code closes smallest gaps first
-
-    std::priority_queue<PossibleStitch> stitch_queue =
-        findPossibleStitches(open_polylines, max_dist, cell_size, allow_reverse);
-
-    static const Terminus INVALID_TERMINUS = Terminus::INVALID_TERMINUS;
-    Terminus::Index terminus_end_idx = Terminus::endIndexFromPolylineEndIndex(open_polylines.size());
-    // Keeps track of how polyline end point locations move around
-    TerminusTrackingMap terminus_tracking_map(terminus_end_idx);
-
-    while (!stitch_queue.empty())
-    {
-        // Get the next best stitch
-        PossibleStitch next_stitch;
-        next_stitch = stitch_queue.top();
-        stitch_queue.pop();
-        Terminus old_terminus_0 = next_stitch.terminus_0;
-        Terminus terminus_0 = terminus_tracking_map.getCurFromOld(old_terminus_0);
-        if (terminus_0 == INVALID_TERMINUS)
-        {
-            // if we already used this terminus, then this stitch is no longer usable
-            continue;
-        }
-        Terminus old_terminus_1 = next_stitch.terminus_1;
-        Terminus terminus_1 = terminus_tracking_map.getCurFromOld(old_terminus_1);
-        if (terminus_1 == INVALID_TERMINUS)
-        {
-            // if we already used this terminus, then this stitch is no longer usable
-            continue;
-        }
-
-        size_t best_polyline_0_idx = terminus_0.getPolylineIdx();
-        size_t best_polyline_1_idx = terminus_1.getPolylineIdx();
-
-        // check to see if this completes a polygon
-        bool completed_poly = best_polyline_0_idx == best_polyline_1_idx;
-        if (completed_poly)
-        {
-            // finished polygon
-            PolygonRef polyline_0 = open_polylines[best_polyline_0_idx];
-            polygons.add(polyline_0);
-            polyline_0.clear();
-            Terminus cur_terms[2] = {{best_polyline_0_idx, false},
-                                     {best_polyline_0_idx, true}};
-            for (size_t idx = 0U; idx != 2U; ++idx)
+            else
             {
-                terminus_tracking_map.markRemoved(cur_terms[idx]);
+                for(Point& p : polyline_2)
+                    polyline_1.add(p);
+                polyline_2.clear();
             }
-            continue;
         }
-
-        // we need to join these polylines
-
-        // plan how to join polylines
-        bool reverse[2];
-        planPolylineStitch(open_polylines, terminus_0, terminus_1, reverse);
-
-        // need to reread since planPolylineStitch can swap terminus_0/1
-        best_polyline_0_idx = terminus_0.getPolylineIdx();
-        best_polyline_1_idx = terminus_1.getPolylineIdx();
-        PolygonRef polyline_0 = open_polylines[best_polyline_0_idx];
-        PolygonRef polyline_1 = open_polylines[best_polyline_1_idx];
-
-        // join polylines according to plan
-        joinPolylines(polyline_0, polyline_1, reverse);
-
-        // update terminus_tracking_map
-        Terminus cur_terms[4] = {{best_polyline_0_idx, false},
-                                 {best_polyline_0_idx, true},
-                                 {best_polyline_1_idx, false},
-                                 {best_polyline_1_idx, true}};
-        Terminus next_terms[4] = {{best_polyline_0_idx, false},
-                                  INVALID_TERMINUS,
-                                  INVALID_TERMINUS,
-                                  {best_polyline_0_idx, true}};
-        if (reverse[0])
-        {
-            std::swap(next_terms[0],next_terms[1]);
-        }
-        if (reverse[1])
-        {
-            std::swap(next_terms[2],next_terms[3]);
-        }
-        // cur_terms -> next_terms has movement map
-        // best_polyline_1 is always removed
-        terminus_tracking_map.updateMap(4U, cur_terms, next_terms,
-                                        2U, &cur_terms[2]);
     }
 }
 
@@ -542,7 +207,7 @@ void SlicerLayer::stitch_extensive(Polygons& open_polylines)
     // Then find the shortest path over this polygon that can be used to connect the open polygons,
     // And generate a path over this shortest bit to link up the 2 open polygons.
     // (If these 2 open polygons are the same polygon, then the final result is a closed polyon)
-
+    
     while(1)
     {
         unsigned int best_polyline_1_idx = -1;
@@ -552,12 +217,12 @@ void SlicerLayer::stitch_extensive(Polygons& open_polylines)
         best_result.polygonIdx = -1;
         best_result.pointIdxA = -1;
         best_result.pointIdxB = -1;
-
+        
         for(unsigned int polyline_1_idx = 0; polyline_1_idx < open_polylines.size(); polyline_1_idx++)
         {
             PolygonRef polyline_1 = open_polylines[polyline_1_idx];
             if (polyline_1.size() < 1) continue;
-
+            
             {
                 GapCloserResult res = findPolygonGapCloser(polyline_1[0], polyline_1.back());
                 if (res.len > 0 && res.len < best_result.len)
@@ -572,7 +237,7 @@ void SlicerLayer::stitch_extensive(Polygons& open_polylines)
             {
                 PolygonRef polyline_2 = open_polylines[polyline_2_idx];
                 if (polyline_2.size() < 1 || polyline_1_idx == polyline_2_idx) continue;
-
+                
                 GapCloserResult res = findPolygonGapCloser(polyline_1[0], polyline_2.back());
                 if (res.len > 0 && res.len < best_result.len)
                 {
@@ -582,7 +247,7 @@ void SlicerLayer::stitch_extensive(Polygons& open_polylines)
                 }
             }
         }
-
+        
         if (best_result.len < POINT_MAX)
         {
             if (best_polyline_1_idx == best_polyline_2_idx)
@@ -660,7 +325,7 @@ GapCloserResult SlicerLayer::findPolygonGapCloser(Point ip0, Point ip1)
     ret.pointIdxA = c1.pointIdx;
     ret.pointIdxB = c2.pointIdx;
     ret.AtoB = true;
-
+    
     if (ret.pointIdxA == ret.pointIdxB)
     {
         //Connection points are on the same line segment.
@@ -686,7 +351,7 @@ GapCloserResult SlicerLayer::findPolygonGapCloser(Point ip0, Point ip1)
             p0 = p1;
         }
         lenB += vSize(p0 - ip0);
-
+        
         if (lenA < lenB)
         {
             ret.AtoB = true;
@@ -708,7 +373,7 @@ ClosePolygonResult SlicerLayer::findPolygonPointClosestTo(Point input)
         for(unsigned int i=0; i<polygons[n].size(); i++)
         {
             Point p1 = polygons[n][i];
-
+            
             //Q = A + Normal( B - A ) * ((( B - A ) dot ( P - A )) / VSize( A - B ));
             Point pDiff = p1 - p0;
             int64_t lineLength = vSize(pDiff);
@@ -737,18 +402,18 @@ ClosePolygonResult SlicerLayer::findPolygonPointClosestTo(Point input)
 void SlicerLayer::makePolygons(const Mesh* mesh, bool keep_none_closed, bool extensive_stitching)
 {
     Polygons open_polylines;
-
+    
     makeBasicPolygonLoops(mesh, open_polylines);
-
+    
     connectOpenPolylines(open_polylines);
-
+    
     // TODO: (?) for mesh surface mode: connect open polygons. Maybe the above algorithm can create two open polygons which are actually connected when the starting segment is in the middle between the two open polygons.
 
     if (mesh->getSettingAsSurfaceMode("magic_mesh_surface_mode") == ESurfaceMode::NORMAL)
     { // don't stitch when using (any) mesh surface mode, i.e. also don't stitch when using mixed mesh surface and closed polygons, because then polylines which are supposed to be open will be closed
         stitch(open_polylines);
     }
-
+    
     if (extensive_stitching)
     {
         stitch_extensive(open_polylines);
@@ -759,10 +424,10 @@ void SlicerLayer::makePolygons(const Mesh* mesh, bool keep_none_closed, bool ext
         for (PolygonRef polyline : open_polylines)
         {
             if (polyline.size() > 0)
-                polygons.add(polyline);
+                openPolylines.add(polyline);
         }
     }
-
+    
     for (PolygonRef polyline : open_polylines)
     {
         if (polyline.size() > 0)
@@ -776,9 +441,9 @@ void SlicerLayer::makePolygons(const Mesh* mesh, bool keep_none_closed, bool ext
 
     //Finally optimize all the polygons. Every point removed saves time in the long run.
     polygons.simplify();
-
+    
     polygons.removeDegenerateVerts(); // remove verts connected to overlapping line segments
-
+    
     int xy_offset = mesh->getSettingInMicrons("xy_offset");
     if (xy_offset != 0)
     {
@@ -787,30 +452,24 @@ void SlicerLayer::makePolygons(const Mesh* mesh, bool keep_none_closed, bool ext
 }
 
 
-Slicer::Slicer(Mesh* mesh, int initial, int thickness, int slice_layer_count, bool keep_none_closed, bool extensive_stitching)
+Slicer::Slicer(const 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;
+        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;
         int32_t minZ = p0.z;
         int32_t maxZ = p0.z;
         if (p1.z < minZ) minZ = p1.z;
@@ -823,56 +482,22 @@ Slicer::Slicer(Mesh* mesh, int initial, int thickness, int slice_layer_count, bo
             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
@@ -881,22 +506,14 @@ Slicer::Slicer(Mesh* mesh, int initial, int thickness, int slice_layer_count, bo
             }
             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++)
+    for(unsigned int layer_nr=0; layer_nr<layers.size(); layer_nr++)
     {
-        layers_ref[layer_nr].makePolygons(mesh, keep_none_closed, extensive_stitching);
+        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());
 }
 
 }//namespace cura

src/slicer.h

@@ -2,8 +2,6 @@
 #ifndef SLICER_H
 #define SLICER_H
 
-#include <queue>
-
 #include "mesh.h"
 #include "utils/polygon.h"
 /*
@@ -16,13 +14,8 @@ 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;
+    int faceIndex;
+    bool addedToPolygon;
 };
 
 class ClosePolygonResult
@@ -30,17 +23,17 @@ class ClosePolygonResult
     //The line on which the point lays is between pointIdx-1 and pointIdx
 public:
     Point intersectionPoint;
-    int polygonIdx = -1;
-    unsigned int pointIdx = -1;
+    int polygonIdx;
+    unsigned int pointIdx;
 };
 class GapCloserResult
 {
 public:
-    int64_t len = -1;
-    int polygonIdx = -1;
-    unsigned int pointIdxA = -1;
-    unsigned int pointIdxB = -1;
-    bool AtoB = false;
+    int64_t len;
+    int polygonIdx;
+    unsigned int pointIdxA;
+    unsigned int pointIdxB;
+    bool AtoB;
 };
 
 class SlicerLayer
@@ -48,14 +41,14 @@ class SlicerLayer
 public:
     std::vector<SlicerSegment> segments;
     std::unordered_map<int, int> face_idx_to_segment_idx; // topology
-
-    int z = -1;
+    
+    int z;
     Polygons polygons;
     Polygons openPolylines;
 
     /*!
      * Connect the segments into polygons for this layer of this \p mesh
-     *
+     * 
      * \param[in] mesh The mesh data for which we are connecting sliced segments (The face data is used)
      * \param keepNoneClosed Whether to throw away the data for segments which we couldn't stitch into a polygon
      * \param extensiveStitching Whether to perform extra work to try and close polylines into polygons when there are large gaps
@@ -65,7 +58,7 @@ public:
 protected:
     /*!
      * Connect the segments into loops which correctly form polygons (don't perform stitching here)
-     *
+     * 
      * \param[in] mesh The mesh data for which we are connecting sliced segments (The face data is used)
      * \param[out] open_polylines The polylines which are stiched, but couldn't be closed into a loop
      */
@@ -73,7 +66,7 @@ protected:
 
     /*!
      * Connect the segments into a loop, starting from the segment with index \p start_segment_idx
-     *
+     * 
      * \param[in] mesh The mesh data for which we are connecting sliced segments (The face data is used)
      * \param[out] open_polylines The polylines which are stiched, but couldn't be closed into a loop
      * \param[in] start_segment_idx The index into SlicerLayer::segments for the first segment from which to start the polygon loop
@@ -84,7 +77,7 @@ protected:
      * Get the next segment connected to the end of \p segment.
      * Used to make closed polygon loops.
      * Return ASAP if segment is (also) connected to SlicerLayer::segments[\p start_segment_idx]
-     *
+     * 
      * \param[in] mesh The mesh data for which we are connecting sliced segments (The face data is used)
      * \param[in] segment The segment from which to start looking for the next
      * \param[in] start_segment_idx The index to the segment which when conected to \p segment will immediately stop looking for further candidates.
@@ -94,18 +87,18 @@ protected:
     /*!
      * Connecting polygons that are not closed yet, as models are not always perfect manifold we need to join some stuff up to get proper polygons.
      * First link up polygon ends that are within 2 microns.
-     *
+     * 
      * Clears all open polylines which are used up in the process
-     *
+     * 
      * \param[in,out] open_polylines The polylines which are stiched, but couldn't be closed into a loop
      */
     void connectOpenPolylines(Polygons& open_polylines);
 
     /*!
      * Link up all the missing ends, closing up the smallest gaps first. This is an inefficient implementation which can run in O(n*n*n) time.
-     *
+     * 
      * Clears all open polylines which are used up in the process
-     *
+     * 
      * \param[in,out] open_polylines The polylines which are stiched, but couldn't be closed into a loop yet
      */
     void stitch(Polygons& open_polylines);
@@ -116,371 +109,12 @@ protected:
 
     /*!
      * Try to close up polylines into polygons while they have large gaps in them.
-     *
+     * 
      * Clears all open polylines which are used up in the process
-     *
+     * 
      * \param[in,out] open_polylines The polylines which are stiched, but couldn't be closed into a loop yet
      */
     void stitch_extensive(Polygons& open_polylines);
-
-private:
-    /*!
-     * \brief This class represents the location of an end point of a
-     * polyline in a polyline vector.
-     *
-     * The location records the index in the polyline vector and
-     * whether this is the vertex at the start of the polyline or the
-     * vertex at the end.
-     */
-    class Terminus
-    {
-    public:
-        /*! A representation of Terminus that can be used as an array index.
-         *
-         * See \ref asIndex() for more information.
-         */
-        using Index = size_t;
-
-        /*! A Terminus value representing an invalid value.
-         *
-         * This is used to record when Terminus are removed.
-         */
-        static const Terminus INVALID_TERMINUS;
-
-        /*! Constructor leaving uninitialized. */
-        Terminus()
-        {}
-
-        /*! Constructor from Index representation.
-         *
-         * Terminus{t.asIndex()} == t for all Terminus t.
-         */
-        Terminus(Index idx)
-        {
-            m_idx = idx;
-        }
-
-        /*! Constuctor from the polyline index and which end of the polyline.
-         *
-         * Terminus{t.getPolylineIdx(), t.isEnd()} == t for all Terminus t.
-         */
-        Terminus(size_t polyline_idx, bool is_end)
-        {
-            m_idx = polyline_idx * 2  + (is_end ? 1 : 0);
-        }
-
-        /*! Gets the polyline index for this Terminus. */
-        size_t getPolylineIdx() const
-        {
-            return m_idx / 2;
-        }
-
-        /*! Gets whether this Terminus represents the end point of the polyline. */
-        bool isEnd() const
-        {
-            return (m_idx & 1) == 1;
-        }
-
-        /*! Gets the Index representation of this Terminus.
-         *
-         * The index representation much satisfy the following:
-         * 1. for all Terminus t0, t1: t0 == t1 implies t0.asIndex() == t1.asIndex()
-         * 2. for all Terminus t0, t1: t0 != t1 implies t0.asIndex() != t1.asIndex()
-         * 3. t0.asIndex() >= 0
-         * 4. if y = \ref endIndexFromPolylineEndIndex(x), then for all Terminus t
-         *       if t.getPolylineIdx() < x then t.asIndex() < y
-         *
-         * In addition, the Index representation should be reasonably
-         * compact for efficiency.  This means that for polyline index
-         * in [0,x) and Terminus t with t.getPolylineIdx() < x, the
-         * set of containing all t.asIndex() union {0} should be
-         * small.  In other words, t.asIndex() should map to [0,y)
-         * where y is as small as possible.
-         */
-        Index asIndex() const
-        {
-            return m_idx;
-        }
-
-        /*! Calculates the Terminus end Index from the polyline vector end index.
-         *
-         * \param[in] polyline_end_idx The index of the first invalid
-         *     element of the polyline vector.
-         * \return The Index for the first invalid Terminus for the polyline
-         *     vector.
-         */
-        static Index endIndexFromPolylineEndIndex(unsigned int polyline_end_idx)
-        {
-            return polyline_end_idx*2;
-        }
-
-        /*! Tests for equality.
-        *
-        * Two Terminus are equal if they return the same results for
-        * \ref getPolylineIdx() and \ref isEnd().
-        */
-        bool operator==(const Terminus &other)
-        {
-            return m_idx == other.m_idx;
-        }
-
-        /*! Tests for inequality. */
-        bool operator!=(const Terminus &other)
-        {
-            return m_idx != other.m_idx;
-        }
-
-    private:
-        /*! The Index representation of the Terminus.
-         *
-         * The polyline_idx and end flags are calculated from this on demand.
-         */
-        Index m_idx = -1;
-    };
-
-    /*!
-     * \brief Represents a possible stitch between two polylines.
-     *
-     * This represents the possibility of creating a new merged
-     * polyline from appending terminus_1.getPolylineIdx() onto
-     * terminus_0.getPolylineIdx() using the Terminus points as the
-     * join point.  Consider polylines A -> B and C -> D.  If
-     * terminus_0 is B and terminus_1 is C, then this stitch
-     * represents A -> B -> C -> D.  If terminus_0 is C and terminus_1
-     * is A, then this stitch represents D -> C -> A -> B.  In
-     * general, this stitch represents the polyline:
-     *   the other terminus of polyline 0 -> terminus_0 -> terminus_1
-     *     -> the other terminus of polyline 1.
-     *
-     * This class also stores the squared distance involved in making
-     * the stitch.
-     */
-    struct PossibleStitch
-    {
-        /*! Squared distance from terminus_0 to terminus_1. */
-        int64_t dist2 = -1;
-        /*! The Terminus representing the end of polyline_0 where the
-         * join would happen. */
-        Terminus terminus_0;
-        /*! The Terminus representing the end of polyline_1 where the
-         * join would happen. */
-        Terminus terminus_1;
-
-        /*! True if this stitch doesn't require any polyline reversals.
-         *
-         * If this is true, then the polylines can be appended using
-         * their natural order.
-         */
-        bool in_order() const
-        {
-            // in order if using back of line 0 and front of line 1
-            return terminus_0.isEnd() &&
-                !terminus_1.isEnd();
-        }
-
-        /*! Orders PossibleStitch by goodness.
-         *
-         * Better PossibleStitch are > then worse PossibleStitch.
-         * priority_queue will give greatest first so greatest
-         * must be most desirable stitch
-        */
-        bool operator<(const PossibleStitch &other) const;
-    };
-
-    /*!
-     * \brief Tracks movements of polyline end point locations (Terminus).
-     *
-     * Tracks the movement of polyline end point locations within the
-     * polyline vector as polylines are joined, reversed, and used to
-     * form polygons.
-     */
-    class TerminusTrackingMap
-    {
-    public:
-        /*! Initializes the TerminusTrackingMap with the size indicated.
-         *
-         * \param end_idx The first invalid Terminus::Index.  This usually
-         *    comes from \ref Terminus::endIndexFromPolylineEndIndex().
-         */
-        TerminusTrackingMap(Terminus::Index end_idx);
-
-        /*! Given the old Terminus location returns the current location.
-         *
-         * If the old location is no longer the endpoint of a polyline
-         * in the polyline vector, then this returns
-         * Terminus::INVALID_TERMINUS.  As long as the old location is
-         * still an endpoint in the polyline vector, then
-         * getCurFromOld(old) will always refer to the same point.
-         * Endpoints are removed from the polyline vector as polylines
-         * are merged or converted to Polygons.
-         *
-         * \param old The old Terminus location.  Must not be
-         *     INVALID_TERMINUS.
-         * \return The current Terminus location or INVALID_TERMINUS
-         *     if the old endpoint is no longer an endpoint.
-         */
-        Terminus getCurFromOld(const Terminus &old) const
-        {
-            return m_terminus_old_to_cur_map[old.asIndex()];
-        }
-
-        /*! Given the current Terminus location returns the old location.
-         *
-         * \param cur The current Terminus location.  Must not be
-         *     INVALID_TERMINUS.
-         * \return The old Terminus location.  Returns
-         *     INVALID_TERMINUS if the old Terminus location was
-         *     removed (used to form a Polygon).
-         */
-        Terminus getOldFromCur(const Terminus &cur) const
-        {
-            return m_terminus_cur_to_old_map[cur.asIndex()];
-        }
-
-        /*! Mark the current Terminus as being removed.
-         *
-         * This marks the current Terminus as being removed from the
-         * polyline vector.
-         */
-        void markRemoved(const Terminus &cur)
-        {
-            Terminus old = getOldFromCur(cur);
-            m_terminus_old_to_cur_map[old.asIndex()] = Terminus::INVALID_TERMINUS;
-            m_terminus_cur_to_old_map[cur.asIndex()] = Terminus::INVALID_TERMINUS;
-        }
-
-        /*! Update the map for movement of Terminus.
-         *
-         * This updates the map for the movement / removal of Terminus
-         * locations.  next_terms[i] should refer to the same point as
-         * cur_terms[i] for i < num_terms, unless the Terminus was
-         * removed.  If the Terminus was removed, next_terms[i] should
-         * be INVALID_TERMINUS.
-         *
-         * removed_cur_terms should refer to those Terminus that are
-         * no longer present after the update.  removed_cur_terms
-         * should be the set of terminus values that are in cur_terms
-         * but not in next_terms, i.e. viewing the inputs as sets:
-         * removed_cur_terms = next_terms - cur_terms.  It is passed
-         * separately to avoid calculating the set difference since
-         * the caller generally has this information readily
-         * available.
-         *
-         * \param num_terms The number of Terminus that changed.
-         * \param cur_terms The current Terminus locations.  Must be
-         *     of size num_terms.  Must not contain INVALID_TERMINUS.
-         * \param next_terms The Terminus locations after the update.
-         *     Must be of size num_terms.  A value of INVALID_TERMINUS
-         *     indicates that the Terminus was removed.
-         * \param num_removed_terms The number of Terminus locations
-         *     that are being removed by the update.
-         * \param removed_cur_terms The Terminus locations that will
-         *     be removed after the update.
-         */
-        void updateMap(size_t num_terms,
-                       const Terminus *cur_terms, const Terminus *next_terms,
-                       size_t num_removed_terms,
-                       const Terminus *removed_cur_terms);
-
-    private:
-        /*! map from old terminus location to current terminus location */
-        std::vector<Terminus> m_terminus_old_to_cur_map;
-        /*! map from current terminus location to old terminus location */
-        std::vector<Terminus> m_terminus_cur_to_old_map;
-    };
-
-    /*!
-     * Try to find a segment from face \p face_idx to continue \p segment.
-     *
-     * \param[in] mesh The mesh being sliced.
-     * \param[in] segment The previous segment that we want to find a continuation for.
-     * \param[in] face_idx The index of the face that might have generated a continuation segment.
-     * \param[in] start_segment_idx The index of the segment that started this polyline.
-     */
-    int tryFaceNextSegmentIdx(const Mesh* mesh, const SlicerSegment& segment,
-                              int face_idx, unsigned int start_segment_idx) const;
-
-    /*!
-     * Find possible allowed stitches in goodness order.
-     *
-     * This finds all stitches that are allowed by the parameters.
-     * The stitches are returned in a priority_queue that returns them
-     * in order from best to worst stitch.
-     *
-     * \param open_polylines The polylines to try to stitch together.
-     * \param max_dist The maximum distance between end points for an
-     *     allowed stitch.
-     * \param cell_size The cell size to use for the SparsePointGridInclusive.  This
-     *     affects speed, but does not otherwise affect the results.
-     *     This value should generally be close to max_dist.
-     * \param allow_reverse Whether stitches are allowed that reverse
-     *     the order of a polyline.
-     * \return The stitches that are allowed in order from best to worst.
-     */
-    std::priority_queue<PossibleStitch> findPossibleStitches(
-        const Polygons& open_polylines, coord_t max_dist, coord_t cell_size,
-        bool allow_reverse) const;
-
-    /*! Plans the best way to perform a stitch.
-     *
-     * Let polyline_0 be open_polylines[terminus_0.getPolylineIdx()] and
-     *     polyline_1 be open_polylines[terminus_1.getPolylineIdx()].
-     *
-     * The plan consists of appending polyline_1 to polyline_0.  If
-     * reverse[0] is true, then polyline_0 should be reversed before
-     * appending.  If reverse[1] is true, then polyline_1 should be
-     * reversed before appending.  Note that terminus_0 and terminus_1
-     * may be swapped by this function.
-     *
-     * \param[in] open_polylines The polyline storage vector.
-     * \param[in,out] terminus_0 the Terminus on polyline_0 to join at.
-     * \param[in,out] terminus_1 the Terminus on polyline_1 to join at.
-     * \param[out] reverse Whether the polylines need to be reversed.
-     */
-    void planPolylineStitch(const Polygons& open_polylines,
-                            Terminus& terminus_0, Terminus& terminus_1,
-                            bool reverse[2]) const;
-
-    /*! Joins polyline_1 onto polyline_0.
-     *
-     * Appends polyline_1 to polyline_0.  It reverses the polylines first if either
-     * reverse[i] is true.  Clears polyline_1.
-     *
-     * \param[in,out] polyline_0 On input, the polyline that will form
-     *     the first part of the joined polyline.  On output, the
-     *     joined polyline.
-     * \param[in,out] polyline_1 On input, the polyline that will form
-     *     the second of the joined polyline.  On output, an empty
-     *     polyline.
-     * \param[in] reverse Whether to reverse the polylines before
-     *     joining.  reverse[0] indicates whether to reverse
-     *     polyline_0 and reverse[1] indicates whether to reverse
-     *     polyline_1
-     */
-    void joinPolylines(PolygonRef& polyline_0, PolygonRef& polyline_1,
-                       const bool reverse[2]) const;
-
-    /*!
-     * Connecting polylines that are not closed yet.
-     *
-     * Any polylines that are closed by this function are added to
-     * this->polygons.  All possible polyline joins that meet the
-     * distance and reversal criteria will be performed.  This
-     * function will not introduce any copies of the same polyline
-     * segment.
-     *
-     * \param[in,out] open_polylines The polylines which couldn't be
-     *    closed into a loop
-     * \param[in] max_dist The maximum distance that polyline ends can
-     *     be separated and still be joined.
-     * \param[in] cell_size The cell size to use internally in the
-     *     grid.  This affects speed but not results.
-     * \param[in] allow_reverse If true, then this function is allowed
-     *     to reverse edge directions to merge polylines.
-     */
-    void connectOpenPolylinesImpl(Polygons& open_polylines,
-                                  coord_t max_dist, coord_t cell_size,
-                                  bool allow_reverse);
 };
 
 class Slicer
@@ -488,13 +122,13 @@ class Slicer
 public:
     std::vector<SlicerLayer> layers;
 
-    const Mesh* mesh = nullptr; //!< The sliced mesh
-
-    Slicer(Mesh* mesh, int initial, int thickness, int slice_layer_count, bool keepNoneClosed, bool extensiveStitching);
+    const Mesh* mesh; //!< The sliced mesh
+    
+    Slicer(const 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
@@ -505,7 +139,7 @@ public:
         int64_t y = y0 + num / dx_01;
         return y;
     }
-
+    
     SlicerSegment project2D(Point3& p0, Point3& p1, Point3& p2, int32_t z) const
     {
         SlicerSegment seg;
@@ -517,7 +151,7 @@ public:
 
         return seg;
     }
-
+    
     void dumpSegmentsToHTML(const char* filename);
 };
 

src/support.cpp

@@ -1,22 +1,16 @@
-//Copyright (C) 2013 David Braam
-//Copyright (c) 2016 Ultimaker B.V.
-//CuraEngine is released under the terms of the AGPLv3 or higher.
+/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
+#include "support.h"
 
 #include <cmath> // sqrt
 #include <utility> // pair
 #include <deque>
-#include <cmath> // round
-
-#include "support.h"
-
-#include "utils/math.h"
 #include "progress/Progress.h"
 
 namespace cura 
 {
     
     
-Polygons AreaSupport::join(Polygons& supportLayer_up, Polygons& supportLayer_this, int64_t supportJoinDistance, int64_t smoothing_distance, int max_smoothing_angle, bool conical_support, int64_t conical_support_offset, int64_t conical_smallest_breadth)
+Polygons AreaSupport::join(Polygons& supportLayer_up, Polygons& supportLayer_this, int64_t supportJoinDistance, int64_t smoothing_distance, int min_smoothing_area, bool conical_support, int64_t conical_support_offset, int64_t conical_smallest_breadth)
 {
     Polygons joined;
     if (conical_support)
@@ -36,98 +30,44 @@ Polygons AreaSupport::join(Polygons& supportLayer_up, Polygons& supportLayer_thi
         joined = joined.offset(supportJoinDistance)
                         .offset(-supportJoinDistance);
     }
-
-    // remove jagged line pieces introduced by unioning separate overhang areas for consectuive layers
-    //
-    // support may otherwise look like:
-    //      _____________________      .
-    //     /                     \      } dist_from_lower_layer
-    //    /__                   __\    /
-    //      /''--...........--''\        `\                                                 .
-    //     /                     \         } dist_from_lower_layer
-    //    /__                   __\      ./
-    //      /''--...........--''\     `\                                                    .
-    //     /                     \      } dist_from_lower_layer
-    //    /_______________________\   ,/
-    //            rather than
-    //      _____________________
-    //     /                     \                                                          .
-    //    /                       \                                                         .
-    //    |                       |
-    //    |                       |
-    //    |                       |
-    //    |                       |
-    //    |                       |
-    //    |_______________________|
-    //
-    // dist_from_lower_layer may be up to max_dist_from_lower_layer (see below), but that value may be extremely high
-    joined = joined.smooth_outward(max_smoothing_angle, smoothing_distance);
-
+    if (smoothing_distance > 0)
+        joined = joined.smooth(smoothing_distance, min_smoothing_area);
+    
     return joined;
 }
 
 void AreaSupport::generateSupportAreas(SliceDataStorage& storage, unsigned int layer_count)
 {
-    int max_layer_nr_support_mesh_filled;
-    for (max_layer_nr_support_mesh_filled = storage.support.supportLayers.size() - 1; max_layer_nr_support_mesh_filled >= 0; max_layer_nr_support_mesh_filled--)
-    {
-        const SupportLayer& support_layer = storage.support.supportLayers[max_layer_nr_support_mesh_filled];
-        if (support_layer.supportAreas.size() > 0)
-        {
-            break;
-        }
-    }
-    storage.support.layer_nr_max_filled_layer = std::max(storage.support.layer_nr_max_filled_layer, max_layer_nr_support_mesh_filled);
-    for (int layer_nr = 0; layer_nr < max_layer_nr_support_mesh_filled; layer_nr++)
-    {
-        SupportLayer& support_layer = storage.support.supportLayers[max_layer_nr_support_mesh_filled];
-        support_layer.support_mesh = support_layer.support_mesh.unionPolygons();
-    }
-
     // initialization of supportAreasPerLayer
-    if (layer_count > storage.support.supportLayers.size())
-    { // there might alsready be anti_overhang_area data in the supportLayers
-        storage.support.supportLayers.resize(layer_count);
-    }
-
-    // generate support areas
-    for (unsigned int mesh_idx = 0; mesh_idx < storage.meshes.size(); mesh_idx++)
+    for (unsigned int layer_idx = 0; layer_idx < layer_count ; layer_idx++)
+        storage.support.supportLayers.emplace_back();
+    
+    for(unsigned int mesh_idx = 0; mesh_idx < storage.meshes.size(); mesh_idx++)
     {
         SliceMeshStorage& mesh = storage.meshes[mesh_idx];
-        if (mesh.getSettingBoolean("infill_mesh") || mesh.getSettingBoolean("anti_overhang_mesh"))
-        {
-            continue;
-        }
         std::vector<Polygons> supportAreas;
         supportAreas.resize(layer_count, Polygons());
         generateSupportAreas(storage, mesh_idx, layer_count, supportAreas);
-
-        for (unsigned int layer_idx = 0; layer_idx < layer_count; layer_idx++)
+        
+        if (mesh.getSettingBoolean("support_roof_enable"))
         {
-            storage.support.supportLayers[layer_idx].supportAreas.add(supportAreas[layer_idx]);
+            generateSupportRoofs(storage, supportAreas, layer_count, storage.getSettingInMicrons("layer_height"), mesh.getSettingInMicrons("support_roof_height"));
+        }
+        else 
+        {
+            for (unsigned int layer_idx = 0; layer_idx < layer_count ; 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);
-        }
+        storage.support.supportLayers[layer_idx].supportAreas = storage.support.supportLayers[layer_idx].supportAreas.unionPolygons();
     }
+    
+    storage.support.generated = true;
 }
 
 /* 
@@ -153,56 +93,48 @@ void AreaSupport::generateSupportAreas(SliceDataStorage& storage, unsigned int m
     if (support_type == ESupportType::NONE)
         return;
     
-    const double supportAngle = mesh.getSettingInAngleRadians("support_angle");
-    const bool supportOnBuildplateOnly = support_type == ESupportType::PLATFORM_ONLY;
-    const int supportZDistanceBottom = mesh.getSettingInMicrons("support_bottom_distance");
-    const int supportZDistanceTop = mesh.getSettingInMicrons("support_top_distance");
-    const int join_distance = mesh.getSettingInMicrons("support_join_distance");
-    const int support_bottom_stair_step_height = mesh.getSettingInMicrons("support_bottom_stair_step_height");
+    double supportAngle = mesh.getSettingInAngleRadians("support_angle");
+    bool supportOnBuildplateOnly = support_type == ESupportType::PLATFORM_ONLY;
+    int supportZDistanceBottom = mesh.getSettingInMicrons("support_bottom_distance");
+    int supportZDistanceTop = mesh.getSettingInMicrons("support_top_distance");
+    int join_distance = mesh.getSettingInMicrons("support_join_distance");
+    int support_bottom_stair_step_height = mesh.getSettingInMicrons("support_bottom_stair_step_height");
+    int smoothing_distance = mesh.getSettingInMicrons("support_area_smoothing"); 
+    
+    int extension_offset = mesh.getSettingInMicrons("support_offset");
+    
+    int supportTowerDiameter = mesh.getSettingInMicrons("support_tower_diameter");
+    int supportMinAreaSqrt = mesh.getSettingInMicrons("support_minimal_diameter");
+    double supportTowerRoofAngle = mesh.getSettingInAngleRadians("support_tower_roof_angle");
+    
+    //std::cerr <<" towerDiameter=" << towerDiameter <<", supportMinAreaSqrt=" << supportMinAreaSqrt << std::endl;
+    
+    int min_smoothing_area = 100*100; // minimal area for which to perform smoothing
+    int z_layer_distance_tower = 1; // start tower directly below overhang point
+        
+    int layerThickness = storage.getSettingInMicrons("layer_height");
+    int extrusionWidth = storage.getSettingInMicrons("support_line_width"); 
+    int supportXYDistance = mesh.getSettingInMicrons("support_xy_distance");
+    int support_xy_distance_overhang = mesh.getSettingInMicrons("support_xy_distance_overhang");
 
-    const int extension_offset = mesh.getSettingInMicrons("support_offset");
+    bool use_support_xy_distance_overhang = mesh.getSettingAsSupportDistPriority("support_xy_overrides_z") == SupportDistPriority::Z_OVERRIDES_XY; // whether to use a different xy distance at overhangs
 
-    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");
-    const int support_xy_distance_overhang = mesh.getSettingInMicrons("support_xy_distance_overhang");
-
-    const bool use_support_xy_distance_overhang = mesh.getSettingAsSupportDistPriority("support_xy_overrides_z") == SupportDistPriority::Z_OVERRIDES_XY; // whether to use a different xy distance at overhangs
-
-    const double conical_support_angle = mesh.getSettingInAngleRadians("support_conical_angle");
-    const bool conical_support = mesh.getSettingBoolean("support_conical_enabled") && conical_support_angle != 0;
-    const int64_t conical_smallest_breadth = mesh.getSettingInMicrons("support_conical_min_width");
-
-    int support_skin_extruder_nr = storage.getSettingAsIndex("support_interface_extruder_nr");
-    int support_infill_extruder_nr = storage.getSettingAsIndex("support_infill_extruder_nr");
-    bool interface_enable = mesh.getSettingBoolean("support_interface_enable");
-
-    // derived settings:
-    const int max_smoothing_angle = 135; // maximum angle of inner corners to be smoothed
-    int smoothing_distance;
-    { // compute best smoothing_distance
-        ExtruderTrain& infill_train = *storage.meshgroup->getExtruderTrain(support_infill_extruder_nr);
-        int support_infill_line_width = infill_train.getSettingInMicrons("support_interface_line_width");
-        smoothing_distance = support_infill_line_width;
-        if (interface_enable)
-        {
-            ExtruderTrain& interface_train = *storage.meshgroup->getExtruderTrain(support_skin_extruder_nr);
-            int support_interface_line_width = interface_train.getSettingInMicrons("support_interface_line_width");
-            smoothing_distance = std::max(support_interface_line_width, smoothing_distance);
-        }
+    bool conical_support = mesh.getSettingBoolean("support_conical_enabled");
+    double conical_support_angle = mesh.getSettingInAngleRadians("support_conical_angle");
+    int64_t conical_smallest_breadth = mesh.getSettingInMicrons("support_conical_min_width");
+    
+    if (conical_support_angle == 0)
+    {
+        conical_support = false;
     }
-
-    const int z_layer_distance_tower = 1; // start tower directly below overhang point
+    
+    // derived settings:
     
     
     int supportLayerThickness = layerThickness;
     
-    const unsigned int layerZdistanceTop = std::max(0U, round_up_divide(supportZDistanceTop, supportLayerThickness)) + 1; // support must always be 1 layer below overhang
-    const unsigned int layerZdistanceBottom = std::max(0U, round_up_divide(supportZDistanceBottom, supportLayerThickness));
+    int layerZdistanceTop       = std::max(0, supportZDistanceTop / supportLayerThickness) + 1; // support must always be 1 layer below overhang
+    unsigned int layerZdistanceBottom    = std::max(0, supportZDistanceBottom / supportLayerThickness); 
 
     double tanAngle = tan(supportAngle) - 0.01;  // the XY-component of the supportAngle
     int max_dist_from_lower_layer = tanAngle * supportLayerThickness; // max dist which can be bridged
@@ -225,8 +157,9 @@ void AreaSupport::generateSupportAreas(SliceDataStorage& storage, unsigned int m
     
     // early out
     
-    if ( layerZdistanceTop + 1 > support_layer_count )
+    if ( layerZdistanceTop + 1 > (int) support_layer_count )
     {
+        storage.support.generated = false; // no (first layer) support can be generated 
         return;
     }
     
@@ -235,10 +168,7 @@ 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
-    if (use_towers)
-    {
-        AreaSupport::detectOverhangPoints(storage, mesh, overhang_points, layer_count, supportMinAreaSqrt);
-    }
+    AreaSupport::detectOverhangPoints(storage, mesh, overhang_points, layer_count, supportMinAreaSqrt, extrusionWidth);
 
     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--)
@@ -246,6 +176,7 @@ void AreaSupport::generateSupportAreas(SliceDataStorage& storage, unsigned int m
         basic_and_full_overhang_above.push_front(computeBasicAndFullOverhang(storage, mesh, layer_idx, max_dist_from_lower_layer));
     }
 
+    bool still_in_upper_empty_layers = true;
     int overhang_points_pos = overhang_points.size() - 1;
     Polygons supportLayer_last;
     std::vector<Polygons> towerRoofs;
@@ -262,13 +193,15 @@ void AreaSupport::generateSupportAreas(SliceDataStorage& storage, unsigned int m
         }
 
         Polygons& supportLayer_this = overhang; 
-
+        
         if (extension_offset)
         {
             supportLayer_this = supportLayer_this.offset(extension_offset);
         }
-
-        if (use_towers)
+        
+        supportLayer_this.simplify(50); // TODO: hardcoded value!
+        
+        if (supportMinAreaSqrt > 0)
         {
             // handle straight walls
             AreaSupport::handleWallStruts(supportLayer_this, supportMinAreaSqrt, supportTowerDiameter);
@@ -278,11 +211,10 @@ void AreaSupport::generateSupportAreas(SliceDataStorage& storage, unsigned int m
     
         if (layer_idx+1 < support_layer_count)
         { // join with support from layer up                
-            supportLayer_this = AreaSupport::join(supportLayer_last, supportLayer_this, join_distance, smoothing_distance, max_smoothing_angle, conical_support, conical_support_offset, conical_smallest_breadth);
+            supportLayer_this = AreaSupport::join(supportLayer_last, supportLayer_this, join_distance, smoothing_distance, min_smoothing_area, conical_support, conical_support_offset, conical_smallest_breadth);
         }
-
-        supportLayer_this = supportLayer_this.unionPolygons(storage.support.supportLayers[layer_idx].support_mesh);
-
+        
+        
         // move up from model
         if (layerZdistanceBottom > 0 && layer_idx >= layerZdistanceBottom)
         {
@@ -290,8 +222,8 @@ void AreaSupport::generateSupportAreas(SliceDataStorage& storage, unsigned int m
             int bottomLayer = ((layer_idx - layerZdistanceBottom) / stepHeight) * stepHeight;
             supportLayer_this = supportLayer_this.difference(storage.getLayerOutlines(bottomLayer, false));
         }
-
-
+        
+        
         supportLayer_last = supportLayer_this;
         
         
@@ -311,12 +243,18 @@ void AreaSupport::generateSupportAreas(SliceDataStorage& storage, unsigned int m
             }
             else
             {
-                supportLayer_this = supportLayer_this.difference(outlines.offset(supportXYDistance));
+                supportLayer_this = supportLayer_this.difference(storage.getLayerOutlines(layer_idx, false).offset(supportXYDistance));
             }
         }
 
         supportAreas[layer_idx] = supportLayer_this;
 
+        if (still_in_upper_empty_layers && supportLayer_this.size() > 0)
+        {
+            storage.support.layer_nr_max_filled_layer = std::max(storage.support.layer_nr_max_filled_layer, (int)layer_idx);
+            still_in_upper_empty_layers = false;
+        }
+        
         Progress::messageProgress(Progress::Stage::SUPPORT, storage.meshes.size() * mesh_idx + support_layer_count - layer_idx, support_layer_count * storage.meshes.size());
     }
     
@@ -353,30 +291,6 @@ void AreaSupport::generateSupportAreas(SliceDataStorage& storage, unsigned int m
             supportAreas[layer_idx] = touching_buildplate;
         }
     }
-
-    //Enforce top Z distance.
-    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 - 1); layer_idx++)
-        {
-            supportAreas[layer_idx] = supportAreas[layer_idx].difference(storage.getLayerOutlines(layer_idx + layerZdistanceTop - 1, false));
-        }
-    }
-
-    for (unsigned int layer_idx = supportAreas.size() - 1; layer_idx != (unsigned int) std::max(-1, storage.support.layer_nr_max_filled_layer) ; layer_idx--)
-    {
-        const Polygons& support_here = supportAreas[layer_idx];
-        if (support_here.size() > 0)
-        {
-            storage.support.layer_nr_max_filled_layer = layer_idx;
-            break;
-        }
-    }
-
-    storage.support.generated = true;
 }
 
 
@@ -399,12 +313,6 @@ std::pair<Polygons, Polygons> AreaSupport::computeBasicAndFullOverhang(const Sli
     Polygons supportLayer_supported =  supportLayer_supporter.offset(max_dist_from_lower_layer);
     Polygons basic_overhang = supportLayer_supportee.difference(supportLayer_supported);
 
-    const SupportLayer& support_layer = storage.support.supportLayers[layer_idx];
-    if (support_layer.anti_overhang.size())
-    {
-        basic_overhang = basic_overhang.difference(support_layer.anti_overhang);
-    }
-
 //     Polygons support_extension = basic_overhang.offset(max_dist_from_lower_layer);
 //     support_extension = support_extension.intersection(supportLayer_supported);
 //     support_extension = support_extension.intersection(supportLayer_supportee);
@@ -423,12 +331,11 @@ void AreaSupport::detectOverhangPoints(
     SliceMeshStorage& mesh, 
     std::vector<std::pair<int, std::vector<Polygons>>>& overhang_points, // stores overhang_points along with the layer index at which the overhang point occurs)
     int layer_count,
-    int supportMinAreaSqrt
-)
+    int supportMinAreaSqrt,
+    int extrusionWidth
+                  )
 {
-    ExtruderTrain* infill_extr = storage.meshgroup->getExtruderTrain(storage.getSettingAsIndex("support_infill_extruder_nr"));
-    const unsigned int support_line_width = infill_extr->getSettingInMicrons("support_line_width");
-    for (int layer_idx = 0; layer_idx < layer_count; layer_idx++)
+    for (int layer_idx = 0 ; layer_idx < layer_count ; layer_idx++)
     {
         SliceLayer& layer = mesh.layers[layer_idx];
         for (SliceLayerPart& part : layer.parts)
@@ -436,25 +343,17 @@ void AreaSupport::detectOverhangPoints(
             if (part.outline.outerPolygon().area() < supportMinAreaSqrt * supportMinAreaSqrt) 
             {
                 Polygons part_poly_computed;
-                Polygons& part_poly = (part.insets.size() > 0) ? part.insets[0] : part_poly_computed; // don't copy inset if its already computed
-                if (part.insets.size() == 0)
-                {
-                    part_poly_computed = part.outline.offset(-support_line_width / 2);
-                }
+                Polygons& part_poly = (part.insets.size() > 0)? part.insets[0] : part_poly_computed; // don't copy inset if its already computed
+                if (part.insets.size() == 0) { part_poly_computed = part.outline.offset(-extrusionWidth/2); }
                 
                 if (part_poly.size() > 0)
                 {
-                    Polygons part_poly_recomputed = part_poly.difference(storage.support.supportLayers[layer_idx].anti_overhang);
-                    if (part_poly_recomputed.size() == 0)
-                    {
-                        continue;
-                    }
                     if (overhang_points.size() > 0 && overhang_points.back().first == layer_idx)
-                        overhang_points.back().second.push_back(part_poly_recomputed);
+                        overhang_points.back().second.push_back(part_poly);
                     else 
                     {
                         std::vector<Polygons> small_part_polys;
-                        small_part_polys.push_back(part_poly_recomputed);
+                        small_part_polys.push_back(part_poly);
                         overhang_points.emplace_back<std::pair<int, std::vector<Polygons>>>(std::make_pair(layer_idx, small_part_polys));
                     }
                 }
@@ -505,21 +404,15 @@ void AreaSupport::handleTowers(
     }
     
     // make tower roofs
-    for (unsigned int roof_idx = 0; roof_idx < towerRoofs.size(); roof_idx++)
+    //for (Polygons& tower_roof : towerRoofs)
+    for (unsigned int r = 0; r < towerRoofs.size(); r++)
     {
-        Polygons& tower_roof = towerRoofs[roof_idx];
-        if (tower_roof.size() > 0)
+        supportLayer_this = supportLayer_this.unionPolygons(towerRoofs[r]);
+        
+        Polygons& tower_roof = towerRoofs[r];
+        if (tower_roof.size() > 0 && tower_roof[0].area() < supportTowerDiameter * supportTowerDiameter)
         {
-            supportLayer_this = supportLayer_this.unionPolygons(tower_roof);
-
-            if (tower_roof[0].area() < supportTowerDiameter * supportTowerDiameter)
-            {
-                tower_roof = tower_roof.offset(towerRoofExpansionDistance);
-            }
-            else
-            {
-                tower_roof.clear();
-            }
+            towerRoofs[r] = tower_roof.offset(towerRoofExpansionDistance);
         }
     }
 }
@@ -572,58 +465,26 @@ void AreaSupport::handleWallStruts(
 }
 
 
-void AreaSupport::generateSupportInterface(SliceDataStorage& storage, const SliceMeshStorage& mesh, const unsigned int layer_count)
+void AreaSupport::generateSupportRoofs(SliceDataStorage& storage, std::vector<Polygons>& supportAreas,  unsigned int layer_count, int layerThickness, int support_roof_height)
 {
-    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"));
-    const unsigned int z_distance_bottom = round_up_divide(mesh.getSettingInMicrons("support_bottom_distance"), storage.getSettingInMicrons("layer_height"));
-    const unsigned int z_distance_top = round_up_divide(mesh.getSettingInMicrons("support_top_distance"), storage.getSettingInMicrons("layer_height"));
-
-    const int skip_layer_count = std::max(1u, round_divide(mesh.getSettingInMicrons("support_interface_skip_height"), storage.getSettingInMicrons("layer_height")));
-    const int interface_line_width = storage.meshgroup->getExtruderTrain(storage.getSettingAsIndex("support_interface_extruder_nr"))->getSettingInMicrons("support_interface_line_width");
-
+    int roof_layer_count = support_roof_height / layerThickness;
+    
     std::vector<SupportLayer>& supportLayers = storage.support.supportLayers;
     for (unsigned int layer_idx = 0; layer_idx < layer_count; layer_idx++)
     {
         SupportLayer& layer = supportLayers[layer_idx];
-
-        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 (layer_idx + roof_layer_count < supportLayers.size())
         {
-            continue;
+            Polygons roofs = supportAreas[layer_idx].difference(supportAreas[layer_idx + roof_layer_count]);
+            roofs.removeSmallAreas(1.0);
+            layer.roofs.add(roofs);
+            layer.supportAreas.add(supportAreas[layer_idx].difference(layer.roofs));
         }
-        Polygons roofs;
-        if (roof_layer_count > 0)
+        else 
         {
-            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);
+            layer.roofs.add(layer.supportAreas);
         }
-        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

@@ -12,11 +12,12 @@ class AreaSupport {
 public:
 
     /*!
-     * Generate the support areas and support skin areas for all models.
+     * Generate the support areas and support roof areas for all models.
      * \param storage data storage containing the input layer outline data and containing the output support storage per layer
      * \param layer_count total number of layers
      */
     static void generateSupportAreas(SliceDataStorage& storage, unsigned int layer_count);
+        
 private:
     /*!
      * Generate support polygons over all layers for one object.
@@ -32,13 +33,14 @@ private:
 
 
     /*!
-     * Generate support skin areas and non-skin areas for a given mesh.
+     * Generate support roof areas and non-roof areas for a given mesh.
      * 
-     * \param storage Output storage: support area + support skin area output
-     * \param mesh The mesh to generate support skins for.
-     * \param layer_count The number of layers in this mesh group.
+     * \param storage Output storage: support area + support roof area output
+     * \param supportAreas The basic support areas for the current mesh
+     * \param layerThickness The layer height
+     * \param support_roof_height The thickness of the hammock in z directiontt
      */
-    static void generateSupportInterface(SliceDataStorage& storage, const SliceMeshStorage& mesh, const unsigned int layer_count);
+    static void generateSupportRoofs(SliceDataStorage& storage, std::vector<Polygons>& supportAreas,  unsigned int layer_count, int layerThickness, int support_roof_height);
 
     /*!
      * Join current support layer with the support of the layer above, (make support conical) and perform smoothing etc operations.
@@ -62,13 +64,15 @@ private:
      * \param overhang_points stores overhang_points along with the layer index at which the overhang point occurs
      * \param layer_count total number of layers
      * \param supportMinAreaSqrt diameter of the minimal area which can be supported without a specialized strut
+     * \param extrusionWidth extrusionWidth
      */
     static void detectOverhangPoints(
         SliceDataStorage& storage,
         SliceMeshStorage& mesh,
         std::vector<std::pair<int, std::vector<Polygons>>>& overhang_points, 
         int layer_count,
-        int supportMinAreaSqrt
+        int supportMinAreaSqrt,
+        int extrusionWidth
     );
     
     /*!

src/timeEstimate.cpp

@@ -2,10 +2,8 @@
 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
-
-#include "utils/math.h"
 #include "timeEstimate.h"
-#include "settings/settings.h"
+#include "settings/settings.h" 
 
 namespace cura
 {
@@ -29,6 +27,7 @@ void TimeEstimateCalculator::setFirmwareDefaults(const SettingsBaseVirtual* sett
     acceleration = settings_base->getSettingInMillimetersPerSecond("machine_acceleration");
 }
 
+template<typename T> const T square(const T& a) { return a * a; }
 
 void TimeEstimateCalculator::setPosition(Position newPos)
 {
@@ -50,11 +49,6 @@ void TimeEstimateCalculator::setMaxXyJerk(double jerk)
     max_xy_jerk = jerk;
 }
 
-void TimeEstimateCalculator::setMaxZFeedrate(double max_z_feedrate)
-{
-    max_feedrate[Z_AXIS] = max_z_feedrate;
-}
-
 void TimeEstimateCalculator::reset()
 {
     extra_time = 0.0;