cleanup: removed double setisinside (CURA-1841)

Contributes to issue CURA-1792.

.gitignore

@@ -1,25 +1,49 @@
 *.tar.bz2
 *.tar.gz
 *.7z
-*.pyc
 *.zip
-*.exe
-.idea
 .DS_Store
-_bin
-_obj
-*.depend
-*.o
-.*.swp
-*.gcode
-CuraEngine
-build/*
 *~
 NUL
+*.gcode
+
+## Building result.
+build/*
+*.pyc
+*.exe
+*.a
+*.o
+CuraEngine
+_bin
+_obj
+
+## CMake files
+cmake_install.cmake         
+CMakeCache.txt
+CMakeFiles/
+CPackSourceConfig.cmake
+
+# Visual Studio files generated by CMake
+*.vcxproj
+*.vcxproj.filters
+CuraEngine.sln
+
+# Makefile generated by CMake
+Makefile
+
+## IDE project files.
 CuraEngine.layout
 CuraEngine.cbp
+*kdev*
+*.kate-swp
+nbproject/*
+.idea
+*.depend
+.*.swp
+
+## Documentation.
 documentation/html/*
 documentation/latex/*
 
-*kdev*
-*.kate-swp
+## Test results.
+tests/output.xml

CMakeLists.txt

@@ -2,7 +2,14 @@ project(CuraEngine)
 
 cmake_minimum_required(VERSION 2.8.12)
 
-find_package(Arcus REQUIRED)
+option (ENABLE_ARCUS
+    "Enable support for ARCUS" ON)
+
+if (ENABLE_ARCUS)
+    message(STATUS "Building with Arcus")
+    find_package(Arcus REQUIRED)
+    add_definitions(-DARCUS)
+endif ()
 
 if(NOT ${CMAKE_VERSION} VERSION_LESS 3.1)
     set(CMAKE_CXX_STANDARD 11)
@@ -10,6 +17,22 @@ else()
     set(CMAKE_CXX_FLAGS "-std=c++11")
 endif()
 
+if(APPLE AND CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -stdlib=libc++")
+endif()
+
+set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
+
+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)
+    message(STATUS "Building debug release of CuraEngine.")
+    add_definitions(-DASSERT_INSANE_OUTPUT)
+endif()
+
 # Add warnings
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
 
@@ -21,55 +44,124 @@ include_directories(${CMAKE_CURRENT_BINARY_DIR} libs)
 
 add_library(clipper STATIC libs/clipper/clipper.cpp)
 
-set(engine_SRCS
+set(engine_SRCS # Except main.cpp.
     src/bridge.cpp
-    src/comb.cpp
     src/commandSocket.cpp
+    src/ExtruderTrain.cpp
     src/FffGcodeWriter.cpp
     src/FffPolygonGenerator.cpp
     src/FffProcessor.cpp
     src/gcodeExport.cpp
+    src/GCodePathConfig.cpp
     src/gcodePlanner.cpp
     src/infill.cpp
-    src/inset.cpp
+    src/WallsComputation.cpp
     src/layerPart.cpp
-    src/main.cpp
+    src/LayerPlanBuffer.cpp
     src/MergeInfillLines.cpp
     src/mesh.cpp
     src/MeshGroup.cpp
     src/multiVolumes.cpp
     src/pathOrderOptimizer.cpp
     src/PrimeTower.cpp
-    src/Progress.cpp
     src/raft.cpp
-    src/settingRegistry.cpp
-    src/settings.cpp
     src/skin.cpp
     src/skirt.cpp
     src/sliceDataStorage.cpp
     src/slicer.cpp
     src/support.cpp
     src/timeEstimate.cpp
+    src/WallsComputation.cpp
     src/wallOverlap.cpp
     src/Weaver.cpp
     src/Wireframe2gcode.cpp
 
+    src/infill/NoZigZagConnectorProcessor.cpp
+    src/infill/ZigzagConnectorProcessorConnectedEndPieces.cpp
+    src/infill/ZigzagConnectorProcessorDisconnectedEndPieces.cpp
+    src/infill/ZigzagConnectorProcessorEndPieces.cpp
+    src/infill/ZigzagConnectorProcessorNoEndPieces.cpp
+
+    src/pathPlanning/Comb.cpp
+    src/pathPlanning/LinePolygonsCrossings.cpp
+
+    src/progress/Progress.cpp
+    src/progress/ProgressStageEstimator.cpp
+
+    src/settings/SettingConfig.cpp
+    src/settings/SettingContainer.cpp
+    src/settings/SettingRegistry.cpp
+    src/settings/settings.cpp
+
+    src/utils/AABB.cpp
+    src/utils/AABB3D.cpp
+    src/utils/Date.cpp
     src/utils/gettime.cpp
+    src/utils/LinearAlg2D.cpp
     src/utils/logoutput.cpp
     src/utils/polygonUtils.cpp
     src/utils/polygon.cpp
 )
 
-protobuf_generate_cpp(engine_PB_SRCS engine_PB_HEADERS Cura.proto)
+# List of tests. For each test there must be a file tests/${NAME}.cpp and a file tests/${NAME}.h.
+set(engine_TEST
+    GCodePlannerTest
+)
+set(engine_TEST_INFILL
+)
+set(engine_TEST_UTILS
+    BucketGrid2DTest
+    LinearAlg2DTest
+    PolygonUtilsTest
+)
 
-add_executable(CuraEngine ${engine_SRCS} ${engine_PB_SRCS})
-target_link_libraries(CuraEngine clipper Arcus)
+# Generating ProtoBuf protocol
+if (ENABLE_ARCUS)
+protobuf_generate_cpp(engine_PB_SRCS engine_PB_HEADERS Cura.proto)
+endif ()
+
+# Compiling CuraEngine itself.
+add_library(_CuraEngine ${engine_SRCS} ${engine_PB_SRCS}) #First compile all of CuraEngine as library, allowing this to be re-used for tests.
+target_link_libraries(_CuraEngine clipper)
+if (ENABLE_ARCUS)
+    target_link_libraries(_CuraEngine Arcus)
+endif ()
+
+set_target_properties(_CuraEngine PROPERTIES COMPILE_DEFINITIONS "VERSION=\"${CURA_ENGINE_VERSION}\"")
 
 if (UNIX)
-    target_link_libraries(CuraEngine pthread)
+    target_link_libraries(_CuraEngine pthread)
+endif()
+add_executable(CuraEngine src/main.cpp) #Then compile main.cpp as separate executable, and link the library to it.
+target_link_libraries(CuraEngine _CuraEngine)
+
+# Compiling the test environment.
+if (BUILD_TESTS)
+    message(STATUS "Building tests...")
+    enable_testing()
+    foreach (test ${engine_TEST})
+        add_executable(${test} tests/main.cpp tests/${test}.cpp)
+        target_link_libraries(${test} _CuraEngine cppunit)
+        add_test(${test} ${test})
+    endforeach()
+    foreach (test ${engine_TEST_INFILL})
+        add_executable(${test} tests/main.cpp tests/infill/${test}.cpp)
+        target_link_libraries(${test} _CuraEngine cppunit)
+        add_test(${test} ${test})
+    endforeach()
+    foreach (test ${engine_TEST_UTILS})
+        add_executable(${test} tests/main.cpp tests/utils/${test}.cpp)
+        target_link_libraries(${test} _CuraEngine cppunit)
+        add_test(${test} ${test})
+    endforeach()
 endif()
 
+
+add_custom_command(TARGET CuraEngine POST_BUILD
+                   COMMAND ${CMAKE_COMMAND} -E copy_directory
+                       ${CMAKE_SOURCE_DIR}/resources $<TARGET_FILE_DIR:CuraEngine>)
+
+# Installing CuraEngine.
 include(GNUInstallDirs)
 install(TARGETS CuraEngine DESTINATION ${CMAKE_INSTALL_BINDIR})
-include(CPackConfig.cmake)
-
+include(CPackConfig.cmake)

CPackConfig.cmake

@@ -1,19 +1,12 @@
 set(CPACK_PACKAGE_VENDOR "Ultimaker")
 set(CPACK_PACKAGE_CONTACT "Arjen Hiemstra <a.hiemstra@ultimaker.com>")
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Cura Engine")
-set(CPACK_PACKAGE_VERSION_MAJOR 15)
-set(CPACK_PACKAGE_VERSION_MINOR 05)
-set(CPACK_PACKAGE_VERSION_PATCH 90)
-set(CPACK_GENERATOR "DEB;RPM")
-
-set(RPM_REQUIRES
-    "arcus >= 15.05.90"
-    "protobuf >= 3.0.0"
-    "libstdc++6 >= 4.9.0"
-    "libgcc1 >= 4.9.0"
-)
-string(REPLACE ";" "," RPM_REQUIRES "${RPM_REQUIRES}")
-set(CPACK_RPM_PACKAGE_REQUIRES ${RPM_REQUIRES})
+set(CPACK_PACKAGE_VERSION "15.05.90")
+set(CPACK_GENERATOR "DEB")
+if(NOT DEFINED CPACK_DEBIAN_PACKAGE_ARCHITECTURE)
+  execute_process(COMMAND dpkg --print-architecture OUTPUT_VARIABLE CPACK_DEBIAN_PACKAGE_ARCHITECTURE OUTPUT_STRIP_TRAILING_WHITESPACE)
+endif()
+set(CPACK_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME}-${CPACK_PACKAGE_VERSION}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}")
 
 set(DEB_DEPENDS
     "arcus (>= 15.05.90)"

Cura.proto

@@ -2,20 +2,26 @@ syntax = "proto3";
 
 package cura.proto;
 
-
-message ObjectList 
+message ObjectList
 {
     repeated Object objects = 1;
-    repeated Setting settings = 2;
+    repeated Setting settings = 2; // meshgroup settings (for one-at-a-time printing)
 }
 
-// typeid 1
 message Slice
 {
-    repeated ObjectList object_lists = 1;
+    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
 }
 
-message Object 
+message Extruder
+{
+    int32 id = 1;
+    SettingList settings = 2;
+}
+
+message Object
 {
     int64 id = 1;
     bytes vertices = 2; //An array of 3 floats.
@@ -24,32 +30,17 @@ message Object
     repeated Setting settings = 5; // Setting override per object, overruling the global settings.
 }
 
-// typeid 3
-message Progress 
+message Progress
 {
     float amount = 1;
 }
 
-// typeid 2
-message SlicedObjectList 
-{
-    repeated SlicedObject objects = 1;
-}
-
-message SlicedObject 
-{
-    int64 id = 1;
-
-    repeated Layer layers = 2;
-}
-
 message Layer {
     int32 id = 1;
+    float height = 2; // Z position
+    float thickness = 3; // height of a single layer
 
-    float height = 2;
-    float thickness = 3;
-
-    repeated Polygon polygons = 4;
+    repeated Polygon polygons = 4; // layer data
 }
 
 message Polygon {
@@ -62,37 +53,42 @@ message Polygon {
         SkirtType = 5;
         InfillType = 6;
         SupportInfillType = 7;
+        MoveCombingType = 8;
+        MoveRetractionType = 9;
     }
-    Type type = 1;
-    bytes points = 2;
-    float line_width = 3;
+    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
 }
 
-// typeid 4
 message GCodeLayer {
-    int64 id = 1;
     bytes data = 2;
 }
 
-// typeid 5
-message ObjectPrintTime {
-    int64 id = 1;
-    float time = 2;
-    float material_amount = 3;
+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
+}
+
+message MaterialEstimates {
+    int64 id = 1;
+    float material_amount = 2; // material used in the extruder
 }
 
-// typeid 6
 message SettingList {
     repeated Setting settings = 1;
 }
 
 message Setting {
-    string name = 1;
+    string name = 1; // Internal key to signify a setting
 
-    bytes value = 2;
+    bytes value = 2; // The value of the setting
 }
 
-// typeid 7
 message GCodePrefix {
-    bytes data = 2;
+    bytes data = 2; // Header string to be prenpended before the rest of the gcode sent from the engine
+}
+
+message SlicingFinished {
 }

Doxyfile

@@ -178,7 +178,7 @@ JAVADOC_AUTOBRIEF      = NO
 # requiring an explicit \brief command for a brief description.)
 # The default value is: NO.
 
-QT_AUTOBRIEF           = NO
+QT_AUTOBRIEF           = YES
 
 # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
 # multi-line C++ special comment block (i.e. a block of //! or /// comments) as

README.md

@@ -51,14 +51,21 @@ Running
 =======
 Other than running CuraEngine from a frontend, such as Ultimaker/Cura, one can run CuraEngine from the command line.
 For that one needs a settings JSON file, which can be found in the Ultimaker/Cura repository.
+Note that the structure of the json files has changed since 2.1. In the corresponding branch of the Cura repository you can find how the json files used to be structured.
+
 An example run for an UM2 machine looks as follows:
 * Navigate to the CuraEngine directory and execute the following
 ```
-./build/CuraEngine slice -v -j ../Cura/resources/machines/dual_extrusion_printer.json -o "output/test.gcode" -e1 -s infill_line_distance=0 -e0 -l "/model_1.stl" -e1 -l "fully_filled_model.stl" 
+./build/CuraEngine slice -v -j ../Cura/resources/definitions/dual_extrusion_printer.def.json -o "output/test.gcode" -e1 -s infill_line_distance=0 -e0 -l "/model_1.stl" -e1 -l "fully_filled_model.stl" 
 ```
 
 Run `CuraEngine help` for a general description of how to use the CuraEngine tool.
 
+[Set the environment variable](https://help.ubuntu.com/community/EnvironmentVariables) CURA_ENGINE_SEARCH_PATH to the appropriate paths, delimited by a colon e.g.
+```
+CURA_ENGINE_SEARCH_PATH=/path/to/Cura/resources/definitions:/user/defined/path
+```
+
 Internals
 =========
 

documentation/code_conventions.md

@@ -1,126 +0,0 @@
-Code Conventions
-=======
-Note that the code convention described here have not all yet been fully implemented.
-
-Bracketing and indenting
------
-~~~~~~~~~~~~~~~{.cpp}
-if (condition) // brackets always on new lines
-{ // allways a bracket after an if, for, while, etc.
-    // indent always with 4 spaces, never with tabs
-}
-else // else on new line
-{
-    // more code
-}
-~~~~~~~~~~~~~~~
-
-Naming conventions
-------
- * variables: lower_case_with_underscores
- * functions: loweCamelCase
- * classes: UpperCamelCase
- * macros: UPPER_CASE_WITH_UNDERSCORES
-~~~~~~~~~~~~~~~{.cpp}
-#define UPPER_CASE_MACRO 1
-
-class UpperCamelCase
-{
-private:
-    MemberVariableObject with_underscores;
-public:
-    MemberVariableObject with_underscores;
-
-public:
-    UpperCamelCase();
-    ~UpperCamelCase();
-    
-    // start with input variable(s) and end with output variable(s)
-    void lowerCamelCaseFunctions(ParamObject& also_with_underscores)
-    {
-        LocalObject under_scores;
-    }
-private:
-    void putFunctionsAndVariablesInSeperatePublicPrivateBlocks();
-};
-~~~~~~~~~~~~~~~
-
-Ordering
-----
-~~~~~~~~~~~~~~~{.cpp}
-class Example
-{
-    // start with input variable(s) and end with output parameter(s) 
-    void function1(ParamObject& input_variable, int setting_parameter, ParamObject2& return_parameter)
-    {
-        function2();
-        function3();
-    }
-    
-    // place functions called solely by one other function below it chronologically
-    void function2();
-    
-    void function3();
-};
-~~~~~~~~~~~~~~~
-
-Documentation
-----
-We use [Doxygen](www.doxygen.org/) to generate documentation. Try to keep your documentation in doxygen style.
-
-Here's a small example:
-~~~~~~~~~~~~~~~{.cpp}
-/ *!
- * Doxygen style comments!
- *
- * \param param1 explanation may refer to another \p param2
- * /
-void function(int param1, int param2)
-{
-    // non-doxygen style comments on implementation details
-}
-
-int member; //!< inline doxygen comment on the entry to the left
-~~~~~~~~~~~~~~~
-
-Files
---------
-For a file Foo.h (UpperCamelCase):
-~~~~~~~~~~~~~~~{.cpp}
-#ifndef FOO_H
-#define FOO_H
-// [content]
-#endif//FOO_H
-~~~~~~~~~~~~~~~
-
-
-Other
-----
-~~~~~~~~~~~~~~~{.cpp}
-#include <all>
-#include <includes>
-#include <on>
-#include <top>
-
-#include <first_system_includes>
-
-#include <then_library_includes>
-
-#include "finally_local_includes"
-
-enum class EnumExample 
-{
-    ELEM0 = 0,
-    ELEM1 = 1
-};
-~~~~~~~~~~~~~~~
-
-Illegal syntax
-----
-~~~~~~~~~~~~~~~{.cpp}
-void function()
-{
-    if (condition)
-        single_line_outside_code_block(); // always use braces!
-}; // unneccesary semicolon after function definition is not allowed
-~~~~~~~~~~~~~~~

libs/clipper/README

@@ -1,8 +1,39 @@
 =====================================================================
 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.1.3 (19 January 2014)
+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
 * Fixed potential endless loop condition when adding open 
   paths to Clipper.
 * Fixed missing implementation of SimplifyPolygon function 
@@ -13,11 +44,11 @@ v6.1.3 (19 January 2014)
 * Overloaded MinkowskiSum function to accommodate multi-contour 
   paths.  
 
-v6.1.2 (15 December 2013)
+v6.1.2 (15 December 2013) Rev 444
 * Fixed broken C++ header file.
 * Minor improvement to joining polygons.
 
-v6.1.1 (13 December 2013)
+v6.1.1 (13 December 2013) Rev 441
 * 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.1.3a                                                          *
-* Date      :  22 January 2014                                                 *
+* Version   :  6.2.1                                                           *
+* Date      :  31 October 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.1.3"
+#define CLIPPER_VERSION "6.2.0"
 
 //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,11 +44,10 @@
 //#define use_xyz
 
 //use_lines: Enables line clipping. Adds a very minor cost to performance.
-//#define use_lines
+#define use_lines
   
-//use_deprecated: Enables support for the obsolete OffsetPaths() function
-//which has been replace with the ClipperOffset class.
-#define use_deprecated  
+//use_deprecated: Enables temporary support for the obsolete functions
+//#define use_deprecated  
 
 #include <vector>
 #include <set>
@@ -57,6 +56,7 @@
 #include <cstdlib>
 #include <ostream>
 #include <functional>
+#include <queue>
 
 namespace ClipperLib {
 
@@ -69,11 +69,16 @@ enum PolyType { ptSubject, ptClip };
 enum PolyFillType { pftEvenOdd, pftNonZero, pftPositive, pftNegative };
 
 #ifdef use_int32
-typedef int cInt;
-typedef unsigned int cUInt;
+  typedef int cInt;
+  static cInt const loRange = 0x7FFF;
+  static cInt const hiRange = 0x7FFF;
 #else
-typedef signed long long cInt;
-typedef unsigned long long cUInt;
+  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;
+
 #endif
 
 struct IntPoint {
@@ -117,15 +122,12 @@ struct DoublePoint
 //------------------------------------------------------------------------------
 
 #ifdef use_xyz
-typedef void (*TZFillCallback)(IntPoint& z1, IntPoint& z2, IntPoint& pt);
+typedef void (*ZFillCallback)(IntPoint& e1bot, IntPoint& e1top, IntPoint& e2bot, IntPoint& e2top, 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;
@@ -134,6 +136,7 @@ class PolyNode
 { 
 public:
     PolyNode();
+    virtual ~PolyNode(){};
     Path Contour;
     PolyNodes Childs;
     PolyNode* Parent;
@@ -168,11 +171,6 @@ 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);
@@ -183,8 +181,7 @@ 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, PolyFillType pathFillType, bool pathIsClosed);
+void MinkowskiSum(const Path& pattern, const Paths& paths, Paths& solution, bool pathIsClosed);
 void MinkowskiDiff(const Path& poly1, const Path& poly2, Paths& solution);
 
 void PolyTreeToPaths(const PolyTree& polytree, Paths& paths);
@@ -202,7 +199,7 @@ enum EdgeSide { esLeft = 1, esRight = 2};
 //forward declarations (for stuff used internally) ...
 struct TEdge;
 struct IntersectNode;
-struct LocalMinima;
+struct LocalMinimum;
 struct Scanbeam;
 struct OutPt;
 struct OutRec;
@@ -213,7 +210,6 @@ 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
@@ -236,12 +232,14 @@ 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);
-  LocalMinima      *m_CurrentLM;
-  LocalMinima      *m_MinimaList;
+
+  typedef std::vector<LocalMinimum> MinimaList;
+  MinimaList::iterator m_CurrentLM;
+  MinimaList           m_MinimaList;
+
   bool              m_UseFullRange;
   EdgeList          m_edges;
   bool             m_PreserveCollinear;
@@ -268,7 +266,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(TZFillCallback zFillFunc);
+  void ZFillFunction(ZFillCallback zFillFunc);
 #endif
 protected:
   void Reset();
@@ -279,7 +277,8 @@ private:
   JoinList          m_GhostJoins;
   IntersectList     m_IntersectList;
   ClipType          m_ClipType;
-  std::set< cInt, std::greater<cInt> > m_Scanbeam;
+  typedef std::priority_queue<cInt> ScanbeamList;
+  ScanbeamList      m_Scanbeam;
   TEdge           *m_ActiveEdges;
   TEdge           *m_SortedEdges;
   bool             m_ExecuteLocked;
@@ -289,7 +288,7 @@ private:
   bool             m_UsingPolyTree; 
   bool             m_StrictSimple;
 #ifdef use_xyz
-  TZFillCallback   m_ZFill; //custom callback 
+  ZFillCallback   m_ZFill; //custom callback 
 #endif
   void SetWindingCount(TEdge& edge);
   bool IsEvenOddFillType(const TEdge& edge) const;
@@ -308,21 +307,19 @@ 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,
-    const IntPoint &pt, bool protect = false);
+  void IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &pt);
   OutRec* CreateOutRec();
   OutPt* AddOutPt(TEdge *e, const IntPoint &pt);
   void DisposeAllOutRecs();
   void DisposeOutRec(PolyOutList::size_type index);
-  bool ProcessIntersections(const cInt botY, const cInt topY);
-  void BuildIntersectList(const cInt botY, const cInt topY);
+  bool ProcessIntersections(const cInt topY);
+  void BuildIntersectList(const cInt topY);
   void ProcessIntersectList();
   void ProcessEdgesAtTopOfScanbeam(const cInt topY);
   void BuildResult(Paths& polys);
@@ -344,7 +341,7 @@ private:
   void FixupFirstLefts1(OutRec* OldOutRec, OutRec* NewOutRec);
   void FixupFirstLefts2(OutRec* OldOutRec, OutRec* NewOutRec);
 #ifdef use_xyz
-  void SetZ(IntPoint& pt, TEdge& e);
+  void SetZ(IntPoint& pt, TEdge& e1, TEdge& e2);
 #endif
 };
 //------------------------------------------------------------------------------

meta/15.04_to_2.0.txt

@@ -0,0 +1,203 @@
+This file is a conversion from the ENGINE settings of 15.04 to the ENGINE setting of 2.0
+
+This is NOT a conversion on the frontend internal setting names (15.04 has the dictionary of doom)
+
+
+autoCenter ?        ==> center_object OR machine_center_is_zero ??
+coolHeadLift        ==> cool_lift_head
+downSkinCount       ==> bottom_layers
+enableCombing       ==> retraction_combing
+enableOozeShield    ==> ooze_shield_enabled
+endCode             ==> machine_end_gcode
+extruderOffset[MAX_EXTRUDERS] = (machine_nozzle_offset_x, machine_nozzle_offset_y)
+extrusionWidth      ==> infill_line_width, skirt_line_width, support_line_width
+fanFullOnLayerNr    ==> cool_fan_full_layer
+fanSpeedMax         ==> cool_fan_speed_max
+fanSpeedMin         ==> cool_fan_speed_min
+filamentDiameter    ==> material_diameter
+filamentFlow        ==> material_flow
+fixHorrible         ==> meshfix_union_all AND/OR meshfix_union_all_remove_holes AND/OR meshfix_extensive_stitching AND/OR magic_mesh_surface_mode
+gcodeFlavor         ==> machine_gcode_flavor
+infillOverlap       ==> infill_overlap
+infillPattern       ==> infill_pattern
+infillSpeed         ==> speed_infill
+initialLayerSpeed   ==> speed_layer_0
+initialLayerThickness   ==> layer_height_0
+initialSpeedupLayers    ==> speed_slowdown_layers
+inset0Speed         ==> speed_wall_0
+insetCount          ==> wall_line_count
+insetXSpeed         ==> speed_wall_x
+layer0extrusionWidth    [ Doesn't exist anymore ]
+layerThickness      ==> layer_height
+matrix                  [ Doesn't exist anymore ]
+minimalExtrusionBeforeRetraction
+minimalFeedrate     ==> cool_min_speed
+minimalLayerTime    ==> cool_min_layer_time
+moveSpeed           ==> speed_travel
+multiVolumeOverlap  ==> multiple_mesh_overlap
+nozzleSize          ==> machine_nozzle_size
+objectPosition      ==> mesh_position_x, mesh_position_y, mesh_position_z
+objectSink              [ Doesn't exist in CuraEngine anymore ]
+perimeterBeforeInfill = not(infill_before_walls)
+postSwitchExtruderCode  ==> machine_extruder_start_code
+preSwitchExtruderCode   ==> machine_extruder_end_code
+printSpeed          ==> speed_prime_tower, speed_support_lines, speed_support_roof, skirt_speed
+raftAirGap          ==> raft_airgap
+raftAirGapLayer0        ?!?!?
+raftBaseLinewidth       ==> raft_base_line_width
+raftBaseSpeed           ==> raft_interface_speed, raft_base_speed
+raftBaseThickness       ==> raft_base_thickness
+raftFanSpeed            ==> raft_base_fan_speed, raft_interface_fan_speed, raft_surface_fan_speed
+raftInterfaceLineSpacing==> raft_interface_line_spacing
+raftInterfaceLinewidth  ==> raft_interface_line_width
+raftInterfaceThickness  ==> raft_interface_thickness
+raftLineSpacing         ==> raft_base_line_spacing
+raftMargin              ==> raft_margin
+raftSurfaceLayers       ==> raft_surface_layers
+raftSurfaceLineSpacing  ==> raft_surface_line_spacing
+raftSurfaceLinewidth    ==> raft_surface_line_width
+raftSurfaceSpeed        ==> raft_surface_speed
+raftSurfaceThickness    ==> raft_surface_thickness
+retractionAmount                ==> retraction_amount (set retraction_enable = true)
+retractionAmountExtruderSwitch  ==> switch_extruder_retraction_amount
+retractionAmountPrime           ==> retraction_extra_prime_amount
+retractionMinimalDistance       ==> retraction_extrusion_window ( set retraction_count_max = 1 )
+retractionSpeed                 ==> retraction_retract_speed (, retraction_prime_speed ?), switch_extruder_retraction_speed
+retractionZHop                  ==> retraction_hop
+simpleMode              ??!
+skinSpeed           ==> speed_topbottom
+skirtDistance       ==> skirt_gap
+skirtLineCount      ==> brim_line_count, skirt_line_count
+skirtMinLength      ==> skirt_minimal_length
+sparseInfillLineDistance    ==> infill_line_distance
+spiralizeMode   ==> magic_spiralize
+startCode       ==> machine_start_gcode
+supportAngle        ==> support_angle, support_enable=true if support_angle>0
+supportEverywhere   ==> support_type
+supportExtruder     ==> support_extruder_nr, support_extruder_nr_layer_0
+supportLineDistance ==> support_line_distance
+supportType         ==> support_pattern
+supportXYDistance   ==> support_xy_distance
+supportZDistance    ==> support_z_distance
+upSkinCount         ==> top_layers
+wipeTowerSize       ==> prime_tower_size
+
+
+
+
+
+NEW:
+adhesion_extruder_nr
+adhesion_type
+alternate_extra_perimeter
+coasting_enable
+coasting_min_volume_move
+coasting_min_volume_retract
+coasting_speed_move
+coasting_speed_retract
+coasting_volume_move
+coasting_volume_retract
+cool_min_layer_time_fan_speed_max
+draft_shield_dist
+draft_shield_height
+extruder_nr
+fill_perimeter_gaps
+infill_sparse_thickness
+infill_wipe_dist
+machine_depth
+machine_extruder_count
+machine_extruder_end_pos_abs
+machine_extruder_end_pos_x
+machine_extruder_end_pos_y
+machine_extruder_start_pos_abs
+machine_extruder_start_pos_x
+machine_extruder_start_pos_y
+machine_heated_bed
+machine_nozzle_cool_down_speed
+machine_nozzle_expansion_angle
+machine_nozzle_head_distance
+machine_nozzle_heat_up_speed
+machine_nozzle_tip_outer_diameter
+machine_print_temp_wait
+machine_use_extruder_offset_to_offset_coords
+machine_width
+magic_fuzzy_skin_enabled
+magic_fuzzy_skin_point_dist
+magic_fuzzy_skin_thickness
+material_bed_temperature
+material_bed_temp_prepend
+material_bed_temp_wait
+material_extrusion_cool_down_speed
+material_flow_dependent_temperature
+material_flow_temp_graph
+material_print_temperature
+material_print_temp_prepend
+material_print_temp_wait
+material_standby_temperature
+meshfix_keep_open_polygons
+ooze_shield_angle
+ooze_shield_dist
+prime_tower_dir_outward
+prime_tower_distance
+prime_tower_flow
+prime_tower_line_width
+prime_tower_position_x
+prime_tower_position_y
+prime_tower_wipe_enabled
+remove_overlapping_walls_0_enabled
+remove_overlapping_walls_x_enabled
+retraction_min_travel
+skin_alternate_rotation
+skin_line_width
+skin_no_small_gaps_heuristic
+skin_outline_count
+support_area_smoothing
+support_bottom_distance
+support_bottom_stair_step_height
+support_conical_angle
+support_conical_enabled
+support_conical_min_width
+support_connect_zigzags
+support_join_distance
+support_minimal_diameter
+support_offset
+support_roof_enable
+support_roof_extruder_nr
+support_roof_height
+support_roof_line_distance
+support_roof_line_width
+support_roof_pattern
+support_top_distance
+support_tower_diameter
+support_tower_roof_angle
+switch_extruder_prime_speed
+top_bottom_pattern
+travel_avoid_distance
+travel_avoid_other_parts
+travel_compensate_overlapping_walls_enabled
+wall_line_width_0
+wall_line_width_x
+wireframe_bottom_delay
+wireframe_drag_along
+wireframe_enabled
+wireframe_fall_down
+wireframe_flat_delay
+wireframe_flow_connection
+wireframe_flow_flat
+wireframe_height
+wireframe_nozzle_clearance
+wireframe_printspeed_bottom
+wireframe_printspeed_down
+wireframe_printspeed_flat
+wireframe_printspeed_up
+wireframe_roof_drag_along
+wireframe_roof_fall_down
+wireframe_roof_inset
+wireframe_roof_outer_delay
+wireframe_straight_before_down
+wireframe_strategy
+wireframe_top_delay
+wireframe_top_jump
+wireframe_up_half_speed
+xy_offset
+z_seam_type

meta/HOWTO.txt

@@ -0,0 +1,19 @@
+find engine setting literals
+
+
+cd ~/Development/CuraEngine/output/reflection/
+
+~/bin/substitute.pl y 'while(/getSetting\w+\("(\w+)"\)/gsm) { print "$1\n"; }' ../../src/ | sort | uniq > engineSettingLiterals.txt
+
+
+run setting inheritance reflection
+
+cd ~/Development/CuraEngine
+./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
+
+
+green block = used in engine
+red edge = inherit function only
+black edge = parent-child relation

resources/command_line_settings.json

@@ -0,0 +1,42 @@
+{
+    "version": 1, 
+    "name": "Command line setting defaults CuraEngine",
+    "author": "Ultimaker B.V.",
+    "categories": {
+        "command_line_settings": {
+            "label": "Command Line Settings",
+            "settings": {
+                "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": "boolean",
+                    "default": false
+                },
+                "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": "boolean",
+                    "default": true
+                },
+                "mesh_position_x": {
+                    "description": "Offset applied to the object in the x direction.",
+                    "type": "float",
+                    "default": 0
+                },
+                "mesh_position_y": {
+                    "description": "Offset applied to the object in the y direction.",
+                    "type": "float",
+                    "default": 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",
+                    "default": 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": "boolean",
+                    "default": false
+                }
+            }
+        }
+    }
+}

src/ExtruderTrain.cpp

@@ -0,0 +1,16 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#include "ExtruderTrain.h"
+
+namespace cura 
+{
+int ExtruderTrain::getExtruderNr()
+{
+    return extruder_nr;
+}
+ExtruderTrain::ExtruderTrain(SettingsBaseVirtual* settings, int extruder_nr)
+: SettingsBase(settings)
+, extruder_nr(extruder_nr)
+{
+}
+
+}//namespace cura

src/ExtruderTrain.h

@@ -1,7 +1,8 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
 #ifndef EXTRUDER_TRAIN_H
 #define EXTRUDER_TRAIN_H
 
-#include "settings.h"
+#include "settings/settings.h"
 
 namespace cura 
 {
@@ -10,13 +11,10 @@ class ExtruderTrain : public SettingsBase
 {
     int extruder_nr;
 public:
-    int getExtruderNr() { return extruder_nr; }
-    
-    ExtruderTrain(SettingsBaseVirtual* settings, int extruder_nr)
-    : SettingsBase(settings)
-    , extruder_nr(extruder_nr)
-    { }
-    
+    int getExtruderNr();
+
+    ExtruderTrain(SettingsBaseVirtual* settings, int extruder_nr);
+
 };
 
 }//namespace cura

src/FanSpeedLayerTime.h

@@ -0,0 +1,22 @@
+#ifndef FAN_SPEED_LAYER_TIME_H
+#define FAN_SPEED_LAYER_TIME_H
+
+#include "settings/settings.h"
+
+namespace cura 
+{
+
+struct FanSpeedLayerTimeSettings 
+{
+public:
+    double cool_min_layer_time;
+    double cool_min_layer_time_fan_speed_max;
+    double cool_fan_speed_min;
+    double cool_fan_speed_max;
+    double cool_min_speed;
+    int cool_fan_full_layer;
+};
+
+} // namespace cura
+
+#endif // FAN_SPEED_LAYER_TIME_H

src/FffGcodeWriter.h

@@ -5,6 +5,8 @@
 #include <fstream>
 #include "utils/gettime.h"
 #include "utils/logoutput.h"
+#include "utils/NoCopy.h"
+#include "utils/polygonUtils.h"
 #include "sliceDataStorage.h"
 #include "raft.h"
 #include "infill.h"
@@ -13,8 +15,13 @@
 #include "gcodePlanner.h"
 #include "gcodeExport.h"
 #include "commandSocket.h"
-#include "utils/polygonUtils.h"
 #include "PrimeTower.h"
+#include "FanSpeedLayerTime.h"
+#include "PrintFeature.h"
+
+
+#include "LayerPlanBuffer.h"
+
 
 namespace cura 
 {
@@ -26,46 +33,68 @@ namespace cura
  * 
  * The main function of this class is FffGcodeWriter::writeGCode().
  */
-class FffGcodeWriter : public SettingsMessenger
+class FffGcodeWriter : public SettingsMessenger, NoCopy
 {
     friend class FffProcessor; // cause WireFrame2Gcode uses the member [gcode] (TODO)
 private:
-    int max_object_height;
-    int meshgroup_number; //!< used for sequential printing of objects
+    int max_object_height; //!< The maximal height of all previously sliced meshgroups, used to avoid collision when moving to the next meshgroup to print.
+
+    /*
+     * Buffer for all layer plans (of type GCodePlanner)
+     * 
+     * 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.
+     */
+    LayerPlanBuffer layer_plan_buffer; 
+
+    /*!
+     * The class holding the current state of the gcode being written.
+     * 
+     * It holds information such as the last written position etc.
+     */
     GCodeExport gcode;
-    CommandSocket* command_socket;
+
+    /*!
+     * The gcode file to write to when using CuraEngine as command line tool.
+     */
     std::ofstream output_file;
-    
+
     /*!
      * 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.
      */
     int last_prime_tower_poly_printed[MAX_EXTRUDERS]; 
+
+    bool skirt_is_processed[MAX_EXTRUDERS]; //!< Whether the skirt polygons have been processed into planned paths for each extruder train
+
+    FanSpeedLayerTimeSettings fan_speed_layer_time_settings; //!< The settings used relating to minimal layer time and fan speeds.
+
+    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_)
+    , layer_plan_buffer(this, gcode)
+    , last_position_planned(no_point)
+    , current_extruder_planned(0) // changed somewhere early in FffGcodeWriter::writeGCode
+    , is_inside_mesh_layer_part(false)
     {
-        meshgroup_number = 1;
         max_object_height = 0;
-        command_socket = NULL;
-    }
-    void resetFileNumber()
-    {
-        meshgroup_number = 1;
+        for (unsigned int extruder_nr = 0; extruder_nr < MAX_EXTRUDERS; extruder_nr++)
+        {
+            skirt_is_processed[extruder_nr] = false;
+        }
     }
 
-    void setCommandSocket(CommandSocket* socket)
-    {
-        command_socket = socket;
-    }
-
-    void sendPolygons(PolygonType type, int layer_nr, Polygons& polygons, int line_width)
-    {
-        if (command_socket)
-            command_socket->sendPolygons(type, layer_nr, polygons, line_width);
-    }
-        
+    /*!
+     * Set the target to write gcode to: to a file.
+     * 
+     * Used when CuraEngine is used as command line tool.
+     * 
+     * \param filename The filename of the file to which to write the gcode.
+     */
     bool setTargetFile(const char* filename)
     {
         output_file.open(filename);
@@ -76,94 +105,136 @@ public:
         }
         return false;
     }
-    
+
+    /*!
+     * Set the target to write gcode to: an output stream.
+     * 
+     * Used when CuraEngine is NOT used as command line tool.
+     * 
+     * \param stream The stream to write gcode to.
+     */
     void setTargetStream(std::ostream* stream)
     {
         gcode.setOutputStream(stream);
     }
-    
-    double getTotalFilamentUsed(int e)
+
+    /*!
+     * Get the total extruded volume for a specific extruder in mm^3
+     * 
+     * Retractions and unretractions don't contribute to this.
+     * 
+     * \param extruder_nr The extruder number for which to get the total netto extruded volume
+     * \return total filament printed in mm^3
+     */
+    double getTotalFilamentUsed(int extruder_nr)
     {
-        return gcode.getTotalFilamentUsed(e);
+        return gcode.getTotalFilamentUsed(extruder_nr);
     }
 
+    /*!
+     * Get the total estimated print time in seconds
+     * 
+     * \return total print time in seconds
+     */
     double getTotalPrintTime()
     {
         return gcode.getTotalPrintTime();
     }
 
+    /*!
+     * Write all the gcode for the current meshgroup.
+     * This is the primary function of this class.
+     * 
+     * \param[in] storage The data storage from which to get the polygons to print and the areas to fill.
+     * \param timeKeeper The stop watch to see how long it takes for each of the stages in the slicing process.
+     */
     void writeGCode(SliceDataStorage& storage, TimeKeeper& timeKeeper);
-    
+
 private:
+    /*!
+     * Set the FffGcodeWriter::fan_speed_layer_time_settings by retrieving all settings from the global/per-meshgroup settings.
+     */
+    void setConfigFanSpeedLayerTime();
+
+    /*!
+     * Create and set the SliceDataStorage::coasting_config for each extruder.
+     * 
+     * \param[out] storage The data storage to which to save the configuration
+     */
     void setConfigCoasting(SliceDataStorage& storage);
 
-    //Setup the retraction parameters.
+    /*!
+     * Set the retraction config globally, per extruder and per mesh.
+     * 
+     * \param[out] storage The data storage to which to save the configurations
+     */
     void setConfigRetraction(SliceDataStorage& storage);
     
-    void setConfigSkirt(SliceDataStorage& storage, int layer_thickness);
-    
-    void setConfigSupport(SliceDataStorage& storage, int layer_thickness);
-    
-    void setConfigInsets(SliceMeshStorage& mesh, int layer_thickness);
-    
-    void setConfigSkin(SliceMeshStorage& mesh, int layer_thickness);
-    
-    void setConfigInfill(SliceMeshStorage& mesh, int layer_thickness);
+    /*!
+     * Initialize the GcodePathConfig config parameters which don't change over all layers, for each feature.
+     * 
+     * The features are: skirt, support and for each mesh: outer wall, inner walls, skin, infill (and combined infill)
+     * 
+     * \param[out] storage The data storage to which to save the configurations
+     */
+    void initConfigs(SliceDataStorage& storage);
     
     /*!
      * Set temperatures and perform initial priming.
-     * \param storage Input: where the slice data is stored.
+     * 
+     * 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.
      */
     void processStartingCode(SliceDataStorage& storage);
 
     /*!
-     * Move up and over the just printed model to print the next model.
-     * \param storage Input: where the slice data is stored.
+     * Move up and over the already printed meshgroups to print the next meshgroup.
+     * 
+     * \param[in] storage where the slice data is stored.
      */
     void processNextMeshGroupCode(SliceDataStorage& storage);
     
     /*!
-     * Add raft gcode.
-     * \param storage Input: where the slice data is stored.
-     * \param totalLayers The total number of layers.
+     * Add raft layer plans onto the FffGcodeWriter::layer_plan_buffer
+     * 
+     * \param[in] storage where the slice data is stored.
+     * \param total_layers The total number of layers.
      */
-    void processRaft(SliceDataStorage& storage, unsigned int totalLayers);
+    void processRaft(SliceDataStorage& storage, unsigned int total_layers);
     
     /*!
-     * Add a layer to the gcode.
-     * \param storage Input: where the slice data is stored.
+     * Convert the polygon data of a layer into a layer plan on the FffGcodeWriter::layer_plan_buffer
+     * 
+     * \param[in] storage where the slice data is stored.
      * \param layer_nr The index of the layer to write the gcode of.
-     * \param totalLayers The total number of layers.
+     * \param total_layers The total number of layers.
      * \param has_raft Whether a raft is used for this print.
      */
-    void processLayer(SliceDataStorage& storage, unsigned int layer_nr, unsigned int totalLayers, bool has_raft);
+    void processLayer(SliceDataStorage& storage, unsigned int layer_nr, unsigned int total_layers, bool has_raft);
     
     /*!
-     * Interpolate between the initial layer speeds and the eventual speeds.
-     * \param storage Input: where the slice data is stored.
-     * \param layer_nr The index of the layer to write the gcode of.
-     */
-    void processInitialLayersSpeedup(SliceDataStorage& storage, unsigned int layer_nr);
-    
-    /*!
-     * Add the skirt to the gcode.
-     * \param storage Input: where the slice data is stored.
+     * Add the skirt to the layer plan \p gcodeLayer.
+     * 
+     * \param[in] storage where the slice data is stored.
      * \param gcodeLayer The initial planning of the gcode of the layer.
      * \param extruder_nr The extrudewr train for which to process the skirt
      */
     void processSkirt(SliceDataStorage& storage, GCodePlanner& gcodeLayer, unsigned int extruder_nr);
     
     /*!
-     * Adds the ooze shield to the print.
-     * \param storage Input: where the slice data is stored.
+     * Adds the ooze shield to the layer plan \p gcodeLayer.
+     * 
+     * \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.
      */
     void processOozeShield(SliceDataStorage& storage, GCodePlanner& gcodeLayer, unsigned int layer_nr);
     
     /*!
-     * Adds the draft protection screen to the print.
-     * \param storage Input: where the slice data is stored.
+     * Adds the draft protection screen to the layer plan \p gcodeLayer.
+     * 
+     * \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.
      */
@@ -171,16 +242,18 @@ private:
     
     /*!
      * Calculate in which order to print the meshes.
-     * \param storage Input: where the slice data is stored.
+     * 
+     * \param[in] storage where the slice data is stored.
      * \param current_extruder The current extruder with which we last printed
      * \return A vector of mesh indices ordered on print order.
      */
     std::vector<unsigned int> calculateMeshOrder(SliceDataStorage& storage, int current_extruder);
         
     /*!
-     * Add a single layer from a single mesh-volume to the GCode in mesh surface mode.
-     * \param storage Input: where the slice data is stored.
-     * \param mesh The mesh to add to the gcode.
+     * 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 gcodeLayer The initial planning of the gcode of the layer.
      * \param layer_nr The index of the layer to write the gcode of.
      * 
@@ -188,9 +261,10 @@ private:
     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 GCode for mesh surface mode.
-     * \param storage Input: where the slice data is stored.
-     * \param mesh The mesh for which to add to the gcode.
+     * 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 gcodeLayer The initial planning of the gcode of the layer.
      * \param layer_nr The index of the layer to write the gcode of.
      * 
@@ -198,9 +272,10 @@ private:
     void addMeshOpenPolyLinesToGCode(SliceDataStorage& storage, SliceMeshStorage* mesh, GCodePlanner& gcode_layer, int layer_nr);
     
     /*!
-     * Add a single layer from a single mesh-volume to the GCode.
-     * \param storage Input: where the slice data is stored.
-     * \param mesh The mesh to add to the gcode.
+     * 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 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.
      * 
@@ -208,35 +283,36 @@ private:
     void addMeshLayerToGCode(SliceDataStorage& storage, SliceMeshStorage* mesh, GCodePlanner& gcodeLayer, int layer_nr);
     
     /*!
-     * Add thicker (multiple layers) sparse infill for a given part in a layer.
+     * 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 gcode.
+     * \param mesh The mesh for which to add to the layer plan \p gcodeLayer.
      * \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 fraction of the extrusion width by which the infill overlaps with the wall insets.
+     * \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(GCodePlanner& gcodeLayer, SliceMeshStorage* mesh, SliceLayerPart& part, unsigned int layer_nr, int infill_line_distance, double infill_overlap, int fillAngle, int extrusionWidth); 
+    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 gcode.
+     * \param mesh The mesh for which to add to the layer plan \p gcodeLayer.
      * \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 fraction of the extrusion width by which the infill overlaps with the wall insets.
+     * \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(GCodePlanner& gcodeLayer, SliceMeshStorage* mesh, SliceLayerPart& part, unsigned int layer_nr, int infill_line_distance, double infill_overlap, int fillAngle, int extrusionWidth);
+    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 gcode.
+     * \param mesh The mesh for which to add to the layer plan \p gcodeLayer.
      * \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
@@ -247,34 +323,34 @@ private:
     /*!
      * 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 gcode.
+     * \param mesh The mesh for which to add to the layer plan \p gcodeLayer.
      * \param part The part for which to create gcode
      * \param layer_nr The current layer number.
-     * \param infill_overlap The fraction of the extrusion width by which the infill overlaps with the wall insets.
+     * \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 processSkin(cura::GCodePlanner& gcode_layer, cura::SliceMeshStorage* mesh, cura::SliceLayerPart& part, unsigned int layer_nr, double infill_overlap, int infill_angle, int extrusion_width);
+    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 gcode of the current layer.
-     * \param storage Input: where the slice data is stored.
+     * 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.
      * \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 gcode, or after.
+     * \param before_rest Whether the function has been called before adding the rest to the layer plan \p gcodeLayer, or after.
      */
     void addSupportToGCode(SliceDataStorage& storage, GCodePlanner& gcodeLayer, int layer_nr, int extruder_nr_before, bool before_rest);
     /*!
-     * Add the support lines/walls to the gcode of the current layer.
-     * \param storage Input: where the slice data is stored.
+     * 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.
      */
-    void addSupportLinesToGCode(SliceDataStorage& storage, GCodePlanner& gcodeLayer, int layer_nr);
+    void addSupportInfillToGCode(SliceDataStorage& storage, GCodePlanner& gcodeLayer, int layer_nr);
     /*!
-     * Add the support roofs to the gcode of the current layer.
-     * \param storage Input: where the slice data is stored.
+     * 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.
      */
@@ -285,7 +361,7 @@ private:
      * 
      * On layer 0 this function adds the skirt for the nozzle it switches to, instead of the prime tower.
      * 
-     * \param storage Input: where the slice data is stored.
+     * \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.
      * \param extruder_nr The extruder to which to switch
@@ -294,21 +370,13 @@ private:
     
     /*!
      * Add the prime tower gcode for the current layer.
-     * \param storage Input: where the slice data is stored.
+     * \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.
      * \param prev_extruder The current extruder with which we last printed.
      */
     void addPrimeTower(SliceDataStorage& storage, GCodePlanner& gcodeLayer, int layer_nr, int prev_extruder);
     
-    /*!
-     * Finish the layer by applying speed corrections for minimal layer times and determine the fanSpeed.
-     * \param storage Input: 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.
-     */
-    void processFanSpeedAndMinimalLayerTime(SliceDataStorage& storage, GCodePlanner& gcodeLayer, unsigned int layer_nr);
-    
     /*!
      * Add the end gcode and set all temperatures to zero.
      */

src/FffPolygonGenerator.cpp

@@ -1,9 +1,7 @@
 #include "FffPolygonGenerator.h"
 
 #include <algorithm>
-#include <random> // for bulging effect?
-#include <functional> // for bugling?
-#include <cmath> // for bulging?
+#include <map> // multimap (ordered map allowing duplicate keys)
 
 #include "slicer.h"
 #include "utils/gettime.h"
@@ -12,13 +10,19 @@
 #include "support.h"
 #include "multiVolumes.h"
 #include "layerPart.h"
-#include "inset.h"
+#include "WallsComputation.h"
 #include "skirt.h"
 #include "skin.h"
 #include "infill.h"
 #include "raft.h"
 #include "debug.h"
-#include "Progress.h"
+#include "progress/Progress.h"
+#include "PrintFeature.h"
+#include "progress/ProgressEstimator.h"
+#include "progress/ProgressStageEstimator.h"
+#include "progress/ProgressEstimatorLinear.h"
+
+#include "utils/SVG.h" // debug
 
 namespace cura
 {
@@ -26,9 +30,6 @@ namespace cura
     
 bool FffPolygonGenerator::generateAreas(SliceDataStorage& storage, MeshGroup* meshgroup, TimeKeeper& timeKeeper)
 {
-    if (commandSocket)
-        commandSocket->beginSendSlicedObject();
-    
     if (!sliceModel(meshgroup, timeKeeper, storage)) 
     {
         return false;
@@ -41,21 +42,31 @@ bool FffPolygonGenerator::generateAreas(SliceDataStorage& storage, MeshGroup* me
 
 bool FffPolygonGenerator::sliceModel(MeshGroup* meshgroup, TimeKeeper& timeKeeper, SliceDataStorage& storage) /// slices the model
 {
-    Progress::messageProgressStage(Progress::Stage::SLICING, &timeKeeper, commandSocket);
+    Progress::messageProgressStage(Progress::Stage::SLICING, &timeKeeper);
     
     storage.model_min = meshgroup->min();
     storage.model_max = meshgroup->max();
     storage.model_size = storage.model_max - storage.model_min;
 
     log("Slicing model...\n");
-    int initial_layer_thickness = meshgroup->getSettingInMicrons("layer_height_0");
-    int layer_thickness = meshgroup->getSettingInMicrons("layer_height");
-    if (meshgroup->getSettingAsPlatformAdhesion("adhesion_type") == EPlatformAdhesion::RAFT) 
-    { 
-        initial_layer_thickness = layer_thickness; 
+    int initial_layer_thickness = getSettingInMicrons("layer_height_0");
+    if(initial_layer_thickness <= 0) //Initial layer height of 0 is not allowed. Negative layer height is nonsense.
+    {
+        logError("Initial layer height %i is disallowed.\n", initial_layer_thickness);
+        return false;
+    }
+    int layer_thickness = getSettingInMicrons("layer_height");
+    if(layer_thickness <= 0) //Layer height of 0 is not allowed. Negative layer height is nonsense.
+    {
+        logError("Layer height %i is disallowed.\n", layer_thickness);
+        return false;
     }
     int initial_slice_z = initial_layer_thickness - layer_thickness / 2;
     int layer_count = (storage.model_max.z - initial_slice_z) / layer_thickness + 1;
+    if(layer_count <= 0) //Model is shallower than layer_height_0, so not even the first layer is sliced. Return an empty model then.
+    {
+        return true; //This is NOT an error state!
+    }
 
     std::vector<Slicer*> slicerList;
     for(unsigned int mesh_idx = 0; mesh_idx < meshgroup->meshes.size(); mesh_idx++)
@@ -67,23 +78,21 @@ bool FffPolygonGenerator::sliceModel(MeshGroup* meshgroup, TimeKeeper& timeKeepe
         for(SlicerLayer& layer : slicer->layers)
         {
             //Reporting the outline here slows down the engine quite a bit, so only do so when debugging.
-            //sendPolygons("outline", layer_nr, layer.z, layer.polygonList);
-            //sendPolygons("openoutline", layer_nr, layer.openPolygonList);
+            sendPolygons("outline", layer_nr, layer.z, layer.polygonList);
+            sendPolygons("openoutline", layer_nr, layer.openPolygonList);
         }
         */
-        Progress::messageProgress(Progress::Stage::SLICING, mesh_idx + 1, meshgroup->meshes.size(), commandSocket);
+        Progress::messageProgress(Progress::Stage::SLICING, mesh_idx + 1, meshgroup->meshes.size());
     }
     
     log("Layer count: %i\n", layer_count);
 
     meshgroup->clear();///Clear the mesh face and vertex data, it is no longer needed after this point, and it saves a lot of memory.
 
-    Progress::messageProgressStage(Progress::Stage::PARTS, &timeKeeper, commandSocket);
-    
-    bulgeWalls(slicerList, meshgroup);
-    
+    Progress::messageProgressStage(Progress::Stage::PARTS, &timeKeeper);
     //carveMultipleVolumes(storage.meshes);
-    generateMultipleVolumesOverlap(slicerList, getSettingInMicrons("multiple_mesh_overlap"));
+    generateMultipleVolumesOverlap(slicerList);
+    // TODO!!! dont generate multi volume overlap with infill meshes!
     
     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++)
@@ -91,28 +100,32 @@ bool FffPolygonGenerator::sliceModel(MeshGroup* meshgroup, TimeKeeper& timeKeepe
         storage.meshes.emplace_back(&meshgroup->meshes[meshIdx]); // new mesh in storage had settings from the Mesh
         SliceMeshStorage& meshStorage = storage.meshes.back();
         Mesh& mesh = storage.meshgroup->meshes[meshIdx];
+        
+        
         createLayerParts(meshStorage, slicerList[meshIdx], mesh.getSettingBoolean("meshfix_union_all"), mesh.getSettingBoolean("meshfix_union_all_remove_holes"));
         delete slicerList[meshIdx];
 
-        bool has_raft = meshStorage.getSettingAsPlatformAdhesion("adhesion_type") == EPlatformAdhesion::RAFT;
+        bool has_raft = getSettingAsPlatformAdhesion("adhesion_type") == EPlatformAdhesion::RAFT;
         //Add the raft offset to each layer.
         for(unsigned int layer_nr=0; layer_nr<meshStorage.layers.size(); layer_nr++)
         {
             SliceLayer& layer = meshStorage.layers[layer_nr];
+            meshStorage.layers[layer_nr].printZ += 
+                getSettingInMicrons("layer_height_0")
+                - initial_slice_z;
             if (has_raft)
             {
+                ExtruderTrain* train = storage.meshgroup->getExtruderTrain(getSettingAsIndex("adhesion_extruder_nr"));
                 layer.printZ += 
-                    meshStorage.getSettingInMicrons("raft_base_thickness") 
-                    + meshStorage.getSettingInMicrons("raft_interface_thickness") 
-                    + meshStorage.getSettingAsCount("raft_surface_layers") * getSettingInMicrons("layer_height") //raft_surface_thickness") 
-                    + meshStorage.getSettingInMicrons("raft_airgap")
-                    - initial_slice_z;
-            }
-            else 
-            {
-                meshStorage.layers[layer_nr].printZ += 
-                    meshStorage.getSettingInMicrons("layer_height_0")
-                    - initial_slice_z;
+                    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)
+                {
+                    layer.printZ += train->getSettingInMicrons("layer_0_z_overlap"); // undo shifting down of first layer
+                }
             }
     
  
@@ -121,149 +134,338 @@ bool FffPolygonGenerator::sliceModel(MeshGroup* meshgroup, TimeKeeper& timeKeepe
                 meshStorage.layer_nr_max_filled_layer = layer_nr; // last set by the highest non-empty layer
             } 
                 
-            if (commandSocket)
+            if (CommandSocket::isInstantiated())
             {
-                commandSocket->sendLayerInfo(layer_nr, layer.printZ, layer_nr == 0 && !has_raft? meshStorage.getSettingInMicrons("layer_height_0") : meshStorage.getSettingInMicrons("layer_height"));
+                CommandSocket::getInstance()->sendLayerInfo(layer_nr, layer.printZ, layer_nr == 0? getSettingInMicrons("layer_height_0") : getSettingInMicrons("layer_height"));
             }
         }
         
-        Progress::messageProgress(Progress::Stage::PARTS, meshIdx + 1, slicerList.size(), commandSocket);
+        Progress::messageProgress(Progress::Stage::PARTS, meshIdx + 1, slicerList.size());
     }
-    
-    Progress::messageProgressStage(Progress::Stage::INSET, &timeKeeper, commandSocket);
     return true;
 }
 
 void FffPolygonGenerator::slices2polygons(SliceDataStorage& storage, TimeKeeper& time_keeper)
 {
-    // const 
-    unsigned int total_layers = storage.meshes.at(0).layers.size();
-    //layerparts2HTML(storage, "output/output.html");
-    for(unsigned int layer_number = 0; layer_number < total_layers; layer_number++)
+    // compute layer count and remove first empty layers
+    // there is no separate progress stage for removeEmptyFisrtLayer (TODO)
+    unsigned int total_layers = 0;
+    for (SliceMeshStorage& mesh : storage.meshes)
     {
-        processInsets(storage, layer_number);
-        
-        Progress::messageProgress(Progress::Stage::INSET, layer_number+1, total_layers, commandSocket);
+        if (!mesh.getSettingBoolean("infill_mesh"))
+        {
+            total_layers = std::max<unsigned int>(total_layers, mesh.layers.size());
+        }
     }
-    
-    removeEmptyFirstLayers(storage, getSettingInMicrons("layer_height"), total_layers);
-    
-    if (total_layers < 1)
+
+    // handle meshes
+    std::vector<double> mesh_timings;
+    for (unsigned int mesh_idx = 0; mesh_idx < storage.meshes.size(); mesh_idx++)
     {
-        log("Stopping process because there are no layers.\n");
+        mesh_timings.push_back(1.0); // TODO: have a more accurate estimate of the relative time it takes per mesh, based on the height and number of polygons
+    }
+    ProgressStageEstimator inset_skin_progress_estimate(mesh_timings);
+
+    Progress::messageProgressStage(Progress::Stage::INSET_SKIN, &time_keeper);
+    std::vector<unsigned int> mesh_order;
+    { // compute mesh order
+        std::multimap<int, unsigned int> order_to_mesh_indices;
+        for (unsigned int mesh_idx = 0; mesh_idx < storage.meshes.size(); mesh_idx++)
+        {
+            order_to_mesh_indices.emplace(storage.meshes[mesh_idx].getSettingAsIndex("infill_mesh_order"), mesh_idx);
+        }
+        for (std::pair<const int, unsigned int>& order_and_mesh_idx : order_to_mesh_indices)
+        {
+            mesh_order.push_back(order_and_mesh_idx.second);
+        }
+    }
+    for (unsigned int mesh_idx : mesh_order)
+    {
+        processBasicWallsSkinInfill(storage, mesh_idx, mesh_order, total_layers, inset_skin_progress_estimate);
+        Progress::messageProgress(Progress::Stage::INSET_SKIN, mesh_idx + 1, storage.meshes.size());
+    }
+    //layerparts2HTML(storage, "output/output.html");
+
+    // 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
+    removeEmptyFirstLayers(storage, getSettingInMicrons("layer_height"), total_layers); // changes total_layers!
+    if (total_layers == 0)
+    {
+        log("Stopping process because there are no non-empty layers.\n");
         return;
     }
+
+    Progress::messageProgressStage(Progress::Stage::SUPPORT, &time_keeper);  
+
+    AreaSupport::generateSupportAreas(storage, total_layers);
     
-    Progress::messageProgressStage(Progress::Stage::SUPPORT, &time_keeper, commandSocket);  
-            
-    AreaSupport::generateSupportAreas(storage, total_layers, commandSocket);
+    /*
     if (storage.support.generated)
     {
         for (unsigned int layer_idx = 0; layer_idx < total_layers; layer_idx++)
         {
             Polygons& support = storage.support.supportLayers[layer_idx].supportAreas;
-            sendPolygons(SupportType, layer_idx, support, getSettingInMicrons("support_line_width"));
+            if (CommandSocket::isInstantiated()) 
+            {
+                CommandSocket::getInstance()->sendPolygons(PrintFeatureType::Infill, layer_idx, support, 100); //getSettingInMicrons("support_line_width"));
+            }
         }
     }
+    */
+
+    // handle helpers
+    storage.primeTower.computePrimeTowerMax(storage);
+    storage.primeTower.generatePaths(storage, total_layers);
+
+    processOozeShield(storage, total_layers);
+
+    processDraftShield(storage, total_layers);
+
+    processPlatformAdhesion(storage);
     
-    Progress::messageProgressStage(Progress::Stage::SKIN, &time_keeper, commandSocket);
-    int mesh_max_bottom_layer_count = 0;
-    if (getSettingBoolean("magic_spiralize"))
+    // meshes post processing
+    for (SliceMeshStorage& mesh : storage.meshes)
     {
-        for(SliceMeshStorage& mesh : storage.meshes)
-        {
-            mesh_max_bottom_layer_count = std::max(mesh_max_bottom_layer_count, mesh.getSettingAsCount("bottom_layers"));
-        }
+        processDerivedWallsSkinInfill(mesh, total_layers);
+    }
+}
+
+void FffPolygonGenerator::processBasicWallsSkinInfill(SliceDataStorage& storage, unsigned int mesh_idx, std::vector<unsigned int>& mesh_order, size_t total_layers, ProgressStageEstimator& inset_skin_progress_estimate)
+{
+    
+    SliceMeshStorage& mesh = storage.meshes[mesh_idx];
+    if (mesh.getSettingBoolean("infill_mesh"))
+    {
+        processInfillMesh(storage, mesh_idx, mesh_order, total_layers);
+    }
+    
+    // TODO: make progress more accurate!!
+    // note: estimated time for     insets : skins = 22.953 : 48.858
+    std::vector<double> walls_vs_skin_timing({22.953, 48.858});
+    ProgressStageEstimator* mesh_inset_skin_progress_estimator = new ProgressStageEstimator(walls_vs_skin_timing);
+    
+    inset_skin_progress_estimate.nextStage(mesh_inset_skin_progress_estimator); // the stage of this function call
+    
+    ProgressEstimatorLinear* inset_estimator = new ProgressEstimatorLinear(total_layers);
+    mesh_inset_skin_progress_estimator->nextStage(inset_estimator);
+    
+    
+    // walls
+    for(unsigned int layer_number = 0; layer_number < total_layers; layer_number++)
+    {
+        processInsets(mesh, layer_number);
+        double progress = inset_skin_progress_estimate.progress(layer_number);
+        Progress::messageProgress(Progress::Stage::INSET_SKIN, progress * 100, 100);
+    }
+
+    ProgressEstimatorLinear* skin_estimator = new ProgressEstimatorLinear(total_layers);
+    mesh_inset_skin_progress_estimator->nextStage(skin_estimator);
+    
+    // skin & infill
+//     Progress::messageProgressStage(Progress::Stage::SKIN, &time_keeper);
+    int mesh_max_bottom_layer_count = 0;
+    if (mesh.getSettingBoolean("magic_spiralize"))
+    {
+        mesh_max_bottom_layer_count = std::max(mesh_max_bottom_layer_count, mesh.getSettingAsCount("bottom_layers"));
     }
     for(unsigned int layer_number = 0; layer_number < total_layers; layer_number++)
     {
-        if (!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.
+        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.
         {
-            processSkins(storage, layer_number);
-        }
-        Progress::messageProgress(Progress::Stage::SKIN, layer_number+1, total_layers, commandSocket);
-    }
-    
-    for(unsigned int layer_number = total_layers-1; layer_number > 0; layer_number--)
-    {
-        for(SliceMeshStorage& mesh : storage.meshes)
-            combineInfillLayers(layer_number, mesh, mesh.getSettingAsCount("infill_sparse_combine"));
-    }
-
-    storage.primeTower.computePrimeTowerMax(storage);
-    storage.primeTower.generatePaths(storage, total_layers);
-    
-    processOozeShield(storage, total_layers);
-        
-    processDraftShield(storage, total_layers);
-    
-    processPlatformAdhesion(storage);
-
-    
-    for(SliceMeshStorage& mesh : storage.meshes)
-    {
-        if (mesh.getSettingBoolean("magic_fuzzy_skin_enabled"))
-        {
-            processFuzzySkin(mesh);
+            processSkinsAndInfill(mesh, layer_number);
         }
+        double progress = inset_skin_progress_estimate.progress(layer_number);
+        Progress::messageProgress(Progress::Stage::INSET_SKIN, progress * 100, 100);
     }
 }
 
-void FffPolygonGenerator::processInsets(SliceDataStorage& storage, unsigned int layer_nr) 
+void FffPolygonGenerator::processInfillMesh(SliceDataStorage& storage, unsigned int mesh_idx, std::vector<unsigned int>& mesh_order, size_t total_layers)
 {
-    for(SliceMeshStorage& mesh : storage.meshes)
+    SliceMeshStorage& mesh = storage.meshes[mesh_idx];
+    for (unsigned int layer_idx = 0; layer_idx < mesh.layers.size(); layer_idx++)
     {
-        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 == 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; 
-            generateInsets(layer, mesh.getSettingInMicrons("machine_nozzle_size"), line_width_0, line_width_x, inset_count, mesh.getSettingBoolean("remove_overlapping_walls_0_enabled"), mesh.getSettingBoolean("remove_overlapping_walls_x_enabled"));
+        SliceLayer& layer = mesh.layers[layer_idx];
+        std::vector<PolygonsPart> new_parts;
+        Polygons new_open_polylines;
 
-            for(unsigned int partNr=0; partNr<layer->parts.size(); partNr++)
-            {
-                if (layer->parts[partNr].insets.size() > 0)
-                {
-                    sendPolygons(Inset0Type, layer_nr, layer->parts[partNr].insets[0], line_width_0);
-                    for(unsigned int inset=1; inset<layer->parts[partNr].insets.size(); inset++)
-                        sendPolygons(InsetXType, layer_nr, layer->parts[partNr].insets[inset], line_width_x);
-                }
-            }
-        }
-        else 
-        { // only send polygon data
-            SliceLayer* layer = &mesh.layers[layer_nr];
-            for(SliceLayerPart& part : layer->parts)
-            {
-                sendPolygons(Inset0Type, layer_nr, part.outline, mesh.getSettingInMicrons("wall_line_width_0"));
-            }
-        }
-        if (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") != ESurfaceMode::NORMAL)
+        for (unsigned int other_mesh_idx : mesh_order)
         {
-            for (PolygonRef polyline : layer->openPolyLines)
+            if (other_mesh_idx == mesh_idx)
             {
-                Polygons segments;
-                for (unsigned int point_idx = 1; point_idx < polyline.size(); point_idx++)
+                break; // all previous meshes have been processed
+            }
+            SliceMeshStorage& other_mesh = storage.meshes[other_mesh_idx];
+            if (layer_idx >= other_mesh.layers.size())
+            {
+                continue;
+            }
+
+            SliceLayer& other_layer = other_mesh.layers[layer_idx];
+
+            for (SliceLayerPart& part : layer.parts)
+            {
+                for (SliceLayerPart& other_part : other_layer.parts)
                 {
-                    PolygonRef segment = segments.newPoly();
-                    segment.add(polyline[point_idx-1]);
-                    segment.add(polyline[point_idx]);
+                    if (!part.boundaryBox.hit(other_part.boundaryBox))
+                    {
+                        continue;
+                    }
+                    Polygons& infill = other_part.infill_area;
+                    Polygons new_outline = part.outline.intersection(infill);
+                    if (new_outline.size() == 1)
+                    {
+                        PolygonsPart outline_part_here;
+                        outline_part_here.add(new_outline[0]);
+                        new_parts.push_back(outline_part_here);
+                    }
+                    else if (new_outline.size() > 1)
+                    {
+                        std::vector<PolygonsPart> new_parts_here = new_outline.splitIntoParts();
+                        for (PolygonsPart& new_part_here : new_parts_here)
+                        {
+                            new_parts.push_back(new_part_here);
+                        }
+                    }
+                    infill = infill.difference(part.outline);
+                    other_part.infill_area_per_combine.back() = infill;
                 }
-                sendPolygons(Inset0Type, layer_nr, segments, mesh.getSettingInMicrons("wall_line_width_0"));
+            }
+            if (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") != ESurfaceMode::NORMAL)
+            {
+                for (SliceLayerPart& other_part : other_layer.parts)
+                {
+                    Polygons& infill = other_part.infill_area;
+                    Polygons new_open_polylines_here = layer.openPolyLines.intersectPolylines(infill);
+                    new_open_polylines.add(new_open_polylines_here);
+                    if (layer_idx == 37)
+                    {
+                        Polygons wrong_line;
+                        { PolygonRef line = wrong_line.newPoly();
+                        line.emplace_back(130422,112525);
+                        line.emplace_back(130272,112525); }
+                        { PolygonRef line = wrong_line.newPoly();
+                        line.emplace_back(130422,112525);
+                        line.emplace_back(130272,112525); }
+                        { PolygonRef line = wrong_line.newPoly();
+                        line.emplace_back(132322,112525);
+                        line.emplace_back(130422,112525); }
+
+                        
+                        Polygons intersected = wrong_line.intersectPolylines(infill);
+                        {
+                            AABB aabb(infill);
+                            aabb.expand(MM2INT(5.0));
+                            SVG svg("debug_layer_37.html",aabb);
+                            svg.writeAreas(infill);
+                            svg.writeLines(layer.openPolyLines, SVG::Color::BLUE);
+                            svg.writeLines(new_open_polylines_here, SVG::Color::GREEN);
+//                             svg.writePoints(wrong_line, true, 1);
+                        }
+                        {
+                            AABB aabb(infill);
+                            aabb.expand(MM2INT(5.0));
+                            SVG svg("debug_layer_37_part.html",aabb);
+                            svg.writeAreas(infill);
+                            svg.writeLines(wrong_line, SVG::Color::BLUE);
+                            svg.writeLines(intersected, SVG::Color::GREEN);
+//                             svg.writePoints(wrong_line, true, 1);
+                        }
+                        {
+                            AABB aabb(infill);
+                            aabb.expand(MM2INT(5.0));
+                            SVG svg("debug_layer_37_polylines.html",aabb);
+                            svg.writeLines(layer.openPolyLines, SVG::Color::BLACK);
+//                             svg.writePoints(wrong_line, true, 1);
+                        }
+                        std::cerr << "start\n";
+                        for (PolygonRef poly : layer.openPolyLines)
+                        {
+                            std::cerr << "                        { PolygonRef line = wrong_line.newPoly();\n                        line.emplace_back" << poly[0] << ";\n                        line.emplace_back"<<poly[1]<<"; }" << std::endl;
+                        }
+                        for (PolygonRef poly : infill)
+                            for (Point& p : poly)
+                                std::cerr << " infill point " << p << std::endl;
+                        std::cerr << "written\n";
+                    }
+                    // TODO: Don't adjust infill area for open polylines? \/ 
+//                     infill = infill.difference(layer.openPolyLines.offsetPolyLine(mesh.getSettingInMicrons("wall_line_width") / 2));
+//                     other_part.infill_area_per_combine.back() = infill;
+                }
+            }
+        }
+        
+        layer.parts.clear();
+        for (PolygonsPart& part : new_parts)
+        {
+            layer.parts.emplace_back();
+            layer.parts.back().outline = part;
+            layer.parts.back().boundaryBox.calculate(part);
+        }
+        layer.openPolyLines = new_open_polylines;
+    }
+    
+}
+
+void FffPolygonGenerator::processDerivedWallsSkinInfill(SliceMeshStorage& mesh, size_t total_layers)
+{
+    // combine infill
+    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
+    if (mesh.getSettingBoolean("magic_fuzzy_skin_enabled"))
+    {
+        processFuzzyWalls(mesh);
+    }
+    if (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") == ESurfaceMode::SURFACE)
+    {
+        SliceLayer& layer = mesh.layers[1];
+                        {
+                            AABB aabb(layer.openPolyLines);
+                            aabb.expand(MM2INT(5.0));
+                            SVG svg("debug_layer_37_polylines.html",aabb);
+                            svg.writeLines(layer.openPolyLines, SVG::Color::BLACK);
+//                             svg.writePoints(wrong_line, true, 1);
+                        }
+    }
+}
+
+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 == 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; 
+        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, int layer_height, unsigned int totalLayers)
+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 < totalLayers; layer_idx++)
+    for (unsigned int layer_idx = 0; layer_idx < total_layers; layer_idx++)
     { 
         bool layer_is_empty = true;
         for (SliceMeshStorage& mesh : storage.meshes)
@@ -297,50 +499,35 @@ void FffPolygonGenerator::removeEmptyFirstLayers(SliceDataStorage& storage, int
                 layer.printZ -= n_empty_first_layers * layer_height;
             }
         }
-        totalLayers -= n_empty_first_layers;
+        total_layers -= n_empty_first_layers;
     }
 }
   
-void FffPolygonGenerator::processSkins(SliceDataStorage& storage, unsigned int layer_nr) 
+void FffPolygonGenerator::processSkinsAndInfill(SliceMeshStorage& mesh, unsigned int layer_nr) 
 {
-    for(SliceMeshStorage& mesh : storage.meshes)
+    if (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") == ESurfaceMode::SURFACE) 
+    { 
+        return;
+    }
+    
+    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 (mesh.getSettingInMicrons("infill_line_distance") > 0)
+//     TODO: only compute the area if there are any infill meshes to be computed
     {
-        if (mesh.getSettingAsSurfaceMode("magic_mesh_surface_mode") == ESurfaceMode::SURFACE) { continue; }
-        
-        int extrusionWidth = mesh.getSettingInMicrons("wall_line_width_x");
-        int extrusionWidth_infill = mesh.getSettingInMicrons("infill_line_width");
-        generateSkins(layer_nr, mesh, extrusionWidth, mesh.getSettingAsCount("bottom_layers"), mesh.getSettingAsCount("top_layers"), mesh.getSettingAsCount("skin_outline_count"), mesh.getSettingBoolean("remove_overlapping_walls_0_enabled"), mesh.getSettingBoolean("remove_overlapping_walls_x_enabled"));
-        if (mesh.getSettingInMicrons("infill_line_distance") > 0)
+        int infill_skin_overlap = 0;
+        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)
         {
-            int infill_skin_overlap = 0;
-            if (mesh.getSettingInMicrons("infill_line_distance") > mesh.getSettingInMicrons("infill_line_width") + 10)
-            {
-                infill_skin_overlap = extrusionWidth / 2;
-            }
-            generateInfill(layer_nr, mesh, extrusionWidth_infill, infill_skin_overlap);
-            if (mesh.getSettingString("fill_perimeter_gaps") == "Skin")
-            {
-                generatePerimeterGaps(layer_nr, mesh, extrusionWidth, mesh.getSettingAsCount("bottom_layers"), mesh.getSettingAsCount("top_layers"));
-            }
-            else if (mesh.getSettingString("fill_perimeter_gaps") == "Everywhere")
-            {
-                generatePerimeterGaps(layer_nr, mesh, extrusionWidth, 0, 0);
-            }
-        }
-
-        SliceLayer& layer = mesh.layers[layer_nr];
-        for(SliceLayerPart& part : layer.parts)
-        {
-//             sendPolygons(InfillType, layer_nr, part.infill_area[0], extrusionWidth_infill); // sends the outline, not the actual infill
-            for (SkinPart& skin_part : part.skin_parts)
-            {
-                sendPolygons(SkinType, layer_nr, skin_part.outline, extrusionWidth);
-            }
+            infill_skin_overlap = skin_extrusion_width / 2;
         }
+        generateInfill(layer_nr, mesh, innermost_wall_extrusion_width, infill_skin_overlap, wall_line_count);
     }
 }
 
-void FffPolygonGenerator::processOozeShield(SliceDataStorage& storage, unsigned int totalLayers)
+void FffPolygonGenerator::processOozeShield(SliceDataStorage& storage, unsigned int total_layers)
 {
     if (!getSettingBoolean("ooze_shield_enabled"))
     {
@@ -349,28 +536,28 @@ void FffPolygonGenerator::processOozeShield(SliceDataStorage& storage, unsigned
     
     int ooze_shield_dist = getSettingInMicrons("ooze_shield_dist");
     
-    for(unsigned int layer_nr=0; layer_nr<totalLayers; layer_nr++)
+    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));
     }
     
     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<totalLayers; layer_nr++)
+    for(unsigned int layer_nr=0; layer_nr<total_layers; layer_nr++)
     {
         storage.oozeShield[layer_nr] = storage.oozeShield[layer_nr].offset(-largest_printed_radius).offset(largest_printed_radius); 
     }
     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<totalLayers; layer_nr++)
+    for(unsigned int layer_nr=1; layer_nr<total_layers; layer_nr++)
     {
         storage.oozeShield[layer_nr] = storage.oozeShield[layer_nr].unionPolygons(storage.oozeShield[layer_nr-1].offset(-allowed_angle_offset));
     }
-    for(unsigned int layer_nr=totalLayers-1; layer_nr>0; layer_nr--)
+    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, unsigned int totalLayers)
+void FffPolygonGenerator::processDraftShield(SliceDataStorage& storage, unsigned int total_layers)
 {
     int draft_shield_height = getSettingInMicrons("draft_shield_height");
     int draft_shield_dist = getSettingInMicrons("draft_shield_dist");
@@ -387,7 +574,7 @@ void FffPolygonGenerator::processDraftShield(SliceDataStorage& storage, unsigned
     int layer_skip = 500 / layer_height + 1;
     
     Polygons& draft_shield = storage.draft_protection_shield;
-    for (unsigned int layer_nr = 0; layer_nr < totalLayers && layer_nr < max_screen_layer; 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));
     }
@@ -397,37 +584,42 @@ void FffPolygonGenerator::processDraftShield(SliceDataStorage& storage, unsigned
 
 void FffPolygonGenerator::processPlatformAdhesion(SliceDataStorage& storage)
 {
+    SettingsBaseVirtual* train = storage.meshgroup->getExtruderTrain(getSettingBoolean("adhesion_extruder_nr"));
     switch(getSettingAsPlatformAdhesion("adhesion_type"))
     {
     case EPlatformAdhesion::SKIRT:
-        if (getSettingInMicrons("draft_shield_height") == 0)
+        if (train->getSettingInMicrons("draft_shield_height") == 0)
         { // draft screen replaces skirt
-            generateSkirt(storage, getSettingInMicrons("skirt_gap"), getSettingAsCount("skirt_line_count"), getSettingInMicrons("skirt_minimal_length"));
+            generateSkirt(storage, train->getSettingInMicrons("skirt_gap"), train->getSettingAsCount("skirt_line_count"), train->getSettingInMicrons("skirt_minimal_length"));
         }
         break;
     case EPlatformAdhesion::BRIM:
-        generateSkirt(storage, 0, getSettingAsCount("brim_line_count"), getSettingInMicrons("skirt_minimal_length"));
+        generateSkirt(storage, 0, train->getSettingAsCount("brim_line_count"), train->getSettingInMicrons("skirt_minimal_length"));
         break;
     case EPlatformAdhesion::RAFT:
-        generateRaft(storage, getSettingInMicrons("raft_margin"));
+        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]);
-    sendPolygons(SkirtType, 0, skirt_sent, getSettingInMicrons("skirt_line_width"));
 }
 
 
-void FffPolygonGenerator::processFuzzySkin(SliceMeshStorage& mesh)
+void FffPolygonGenerator::processFuzzyWalls(SliceMeshStorage& mesh)
 {
+    if (mesh.getSettingAsCount("wall_line_count") == 0)
+    {
+        return;
+    }
     int64_t fuzziness = mesh.getSettingInMicrons("magic_fuzzy_skin_thickness");
     int64_t avg_dist_between_points = mesh.getSettingInMicrons("magic_fuzzy_skin_point_dist");
     int64_t min_dist_between_points = avg_dist_between_points * 3 / 4; // hardcoded: the point distance may vary between 3/4 and 5/4 the supplied value
     int64_t range_random_point_dist = avg_dist_between_points / 2;
-    for (SliceLayer& layer : mesh.layers)
+    for (unsigned int layer_nr = 0; layer_nr < mesh.layers.size(); layer_nr++)
     {
+        SliceLayer& layer = mesh.layers[layer_nr];
         for (SliceLayerPart& part : layer.parts)
         {
             Polygons results;
@@ -447,7 +639,7 @@ void FffPolygonGenerator::processFuzzySkin(SliceMeshStorage& mesh)
                     for (int64_t p0pa_dist = dist_left_over; p0pa_dist < p0p1_size; p0pa_dist += min_dist_between_points + rand() % range_random_point_dist)
                     {
                         int r = rand() % (fuzziness * 2) - fuzziness;
-                        Point perp_to_p0p1 = crossZ(p0p1);
+                        Point perp_to_p0p1 = turn90CCW(p0p1);
                         Point fuzz = normal(perp_to_p0p1, r);
                         Point pa = *p0 + normal(p0p1, p0pa_dist) + fuzz;
                         result.add(pa);
@@ -476,109 +668,5 @@ void FffPolygonGenerator::processFuzzySkin(SliceMeshStorage& mesh)
     }
 }
 
-void FffPolygonGenerator::bulgeWalls(std::vector< Slicer* > slicerList, MeshGroup* meshgroup)
-{
-    
-    assert(slicerList.size() == meshgroup->meshes.size());
-    for (unsigned int mesh_idx = 0; mesh_idx < slicerList.size(); mesh_idx++)
-    {
-        Slicer* slicer = slicerList[mesh_idx];
-        Mesh& mesh = meshgroup->meshes[mesh_idx];
-        
-        if (!mesh.getSettingBoolean("magic_bulge_walls"))
-        {
-//             continue; // TODO
-        }
-        
-        auto getBulging = [](Point xy, int z)
-        {
-            std::hash<int> hash_fn;
-            int cell_size = MM2INT(0.2);
-            int cell_dim = 5; // surrounding taken into account
-            double result = 0.0;
-            int bulging = MM2INT(10.0);
-            Point3 middle(xy.X / cell_size, xy.Y / cell_size, z / cell_size);
-            double total_weight = 0.0;
-            for (int x = middle.x - cell_dim; x < middle.x + cell_dim; x++)
-            {
-                for (int y = middle.y - cell_dim; y < middle.y + cell_dim; y++)
-                {
-                    for (int z = middle.z - cell_dim; z < middle.z + cell_dim; z++)
-                    {
-                        srand(x ^ (y << 8) ^ (z << 16)); // set seed
-                        int h = rand();
-//                         int h = hash_fn(x ^ (y << 8) ^ (z << 16));
-                        double r = (double(h % 200000 - 100000))/100000.0; // between -1 and 1
-                        double weight = sqrt(1.0 / (1.0 + static_cast<double>(((Point3(xy.X, xy.Y, z) - Point3(x,y,z)* cell_size)).vSize()) * 4));
-                        total_weight += weight;
-                        result += r * weight ;
-                    }
-                }
-            }
-            
-            return static_cast<int>(result / total_weight * bulging);
-//             return rand() % (bulging*2) - bulging;
-        };
-        
-        int64_t avg_dist_between_points = MM2INT(0.5); // mesh.getSettingInMicrons("magic_fuzzy_skin_point_dist");
-        int64_t min_dist_between_points = avg_dist_between_points * 3 / 4; // hardcoded: the point distance may vary between 3/4 and 5/4 the supplied value
-        int64_t range_random_point_dist = avg_dist_between_points / 2;
-        
-        int layer_height = mesh.getSettingInMicrons("layer_height");
-        
-        for (unsigned int layer_nr = 0; layer_nr < slicer->layers.size(); layer_nr++)
-        {
-            SlicerLayer& layer = slicer->layers[layer_nr];
-            Polygons& outlines = layer.polygonList;
-            Polygons results;
-            
-            int z_approx = layer_nr * layer_height;
-            
-            for (PolygonRef poly : outlines)
-            {
-                // generate points in between p0 and p1
-                PolygonRef result = results.newPoly();
-                
-                int64_t dist_left_over = rand() % (min_dist_between_points / 2); // the distance to be traversed on the line before making the first new point
-                Point* p0 = &poly.back();
-                for (Point& p1 : poly)
-                { // 'a' is the (next) new point between p0 and p1
-                    Point p0p1 = p1 - *p0;
-                    int64_t p0p1_size = vSize(p0p1);    
-                    int64_t dist_last_point = dist_left_over + p0p1_size * 2; // so that p0p1_size - dist_last_point evaulates to dist_left_over - p0p1_size
-                    for (int64_t p0pa_dist = dist_left_over; p0pa_dist < p0p1_size; p0pa_dist += min_dist_between_points + rand() % range_random_point_dist)
-                    {
-                        Point in_between = *p0 + normal(p0p1, p0pa_dist);
-                        int r = getBulging(in_between, z_approx);
-                        Point perp_to_p0p1 = crossZ(p0p1);
-                        Point fuzz = normal(perp_to_p0p1, r);
-                        Point pa = in_between + fuzz;
-                        result.add(pa);
-                        dist_last_point = p0pa_dist;
-                    }
-                    dist_left_over = p0p1_size - dist_last_point;
-                    
-                    p0 = &p1;
-                }
-                while (result.size() < 3 )
-                {
-                    unsigned int point_idx = poly.size() - 2;
-                    result.add(poly[point_idx]);
-                    if (point_idx == 0) { break; }
-                    point_idx--;
-                }
-                if (result.size() < 3)
-                {
-                    result.clear();
-                    for (Point& p : poly)
-                        result.add(p);
-                }
-            }
-            
-            outlines = results;
-        }
-    }
-}
-
 
 }//namespace cura

src/FffPolygonGenerator.h

@@ -4,16 +4,18 @@
 
 #include "MeshGroup.h"
 #include "utils/polygonUtils.h"
+#include "utils/NoCopy.h"
 #include "utils/gettime.h"
-#include "settings.h"
+#include "settings/settings.h"
 #include "sliceDataStorage.h"
 #include "commandSocket.h"
+#include "PrintFeature.h"
+#include "progress/ProgressEstimator.h"
+#include "progress/ProgressStageEstimator.h"
 
 namespace cura
 {
 
-class Slicer; // forward declaration
-    
 /*!
  * Primary stage in Fused Filament Fabrication processing: Polygons are generated.
  * The model is sliced and each slice consists of polygons representing the outlines: the boundaries between inside and outside the object.
@@ -23,28 +25,16 @@ class Slicer; // forward declaration
  * 
  * The main function of this class is FffPolygonGenerator::generateAreas().
  */
-class FffPolygonGenerator : public SettingsMessenger
+class FffPolygonGenerator : public SettingsMessenger, NoCopy
 {
-private:
-    CommandSocket* commandSocket;
 public:
     /*!
-     * Basic constructor; doesn't set the FffAreaGenerator::commandSocket .
+     * Basic constructor
      */
     FffPolygonGenerator(SettingsBase* settings_)
     : SettingsMessenger(settings_)
-    , commandSocket(nullptr)
     {
     }
-    
-    /*!
-     * Set the FffAreaGenerator::commandSocket
-     */
-    void setCommandSocket(CommandSocket* socket)
-    {
-        commandSocket = socket;
-    }
-    
 
     /*!
      * Slice the \p object, process the outline information into inset perimeter polygons, support area polygons, etc. 
@@ -56,17 +46,6 @@ public:
     bool generateAreas(SliceDataStorage& storage, MeshGroup* object, TimeKeeper& timeKeeper);
   
 private:
-    /*!
-     * Send polygons over the command socket, if there is one.
-     * \param type The type of polygon to send
-     * \param layer_nr The layer number at which the polygons occur
-     * \param polygons The polygons to be sent
-     */
-    void sendPolygons(PolygonType type, int layer_nr, Polygons& polygons, int line_width)
-    {
-        if (commandSocket)
-            commandSocket->sendPolygons(type, layer_nr, polygons, line_width);
-    }
     
     /*!
      * Slice the \p object and store the outlines in the \p storage.
@@ -87,42 +66,75 @@ private:
      */
     void slices2polygons(SliceDataStorage& storage, TimeKeeper& timeKeeper);
     
+    /*!
+     * Processes the outline information as stored in the \p storage: generates inset perimeter polygons, skin and infill
+     * 
+     * \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_idx The index of the mesh 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_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
+     * 
+     * \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_idx The index of the mesh 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_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, size_t total_layers);
+    
     /*!
      * Remove all bottom layers which are empty.
+     * 
+     * \warning Changes \p total_layers
+     * 
      * \param storage Input and Ouput parameter: stores all layers
      * \param layer_height The height of each layer
-     * \param totalLayers The total number of layers
+     * \param total_layers The total number of layers
      */
-    void removeEmptyFirstLayers(SliceDataStorage& storage, int layer_height, unsigned int totalLayers);
+    void removeEmptyFirstLayers(SliceDataStorage& storage, const int layer_height, unsigned int& total_layers);
     
     /*!
      * Generate the inset polygons which form the walls.
-     * \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 Input and Output parameter: fetches the outline information (see SliceLayerPart::outline) and generates the other reachable field of the \p storage
      * \param layer_nr The layer for which to generate the insets.
      */
-    void processInsets(SliceDataStorage& storage, unsigned int layer_nr);
+    void processInsets(SliceMeshStorage& mesh, unsigned int layer_nr);
 
     /*!
      * 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 totalLayers The total number of layers 
+     * \param total_layers The total number of layers 
      */
-    void processOozeShield(SliceDataStorage& storage, unsigned int totalLayers);
+    void processOozeShield(SliceDataStorage& storage, unsigned int total_layers);
     
     /*!
      * Generate the skin areas.
-     * \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 Input and Output parameter: fetches the outline information (see SliceLayerPart::outline) and generates the other reachable field of the \p storage
      * \param layer_nr The layer for which to generate the skin areas.
      */
-    void processSkins(SliceDataStorage& storage, unsigned int layer_nr); 
+    void processSkinsAndInfill(SliceMeshStorage& mesh, unsigned int layer_nr); 
 
     /*!
      * 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 totalLayers The total number of layers 
+     * \param total_layers The total number of layers 
      */
-    void processDraftShield(SliceDataStorage& storage, unsigned int totalLayers);
+    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
@@ -132,15 +144,12 @@ private:
     
     
     /*!
-     * Special mode: Make the outer wall 'fuzzy'
+     * Make the outer wall 'fuzzy'
      */
-    void processFuzzySkin(SliceMeshStorage& mesh);
+    void processFuzzyWalls(SliceMeshStorage& mesh);
     
     
-    /*!
-     * Special mode: bulge the outer walls
-     */
-    void bulgeWalls(std::vector< Slicer* > slicerList, MeshGroup* meshgroup);
+
     
 };
 }//namespace cura

src/FffProcessor.cpp

@@ -5,12 +5,25 @@ namespace cura
 
 FffProcessor FffProcessor::instance; // definition must be in cpp
 
+FffProcessor::FffProcessor()
+: polygon_generator(this)
+, gcode_writer(this)
+, meshgroup_number(0)
+{
+}
+
+int FffProcessor::getMeshgroupNr()
+{
+    return meshgroup_number;
+}
+
 
 std::string FffProcessor::getAllSettingsString(MeshGroup& meshgroup, bool first_meshgroup)
 {
     std::stringstream sstream;
     if (first_meshgroup)
     {
+        sstream << getAllLocalSettingsString(); // global settings
         sstream << " -g";
     }
     else 
@@ -26,7 +39,7 @@ std::string FffProcessor::getAllSettingsString(MeshGroup& meshgroup, bool first_
     for (unsigned int mesh_idx = 0; mesh_idx < meshgroup.meshes.size(); mesh_idx++)
     {
         Mesh& mesh = meshgroup.meshes[mesh_idx];
-        sstream << " -e" << mesh.getSettingAsCount("extruder_nr") << " -l \"" << mesh_idx << "\"" << mesh.getAllLocalSettingsString();
+        sstream << " -e" << mesh.getSettingAsIndex("extruder_nr") << " -l \"" << mesh_idx << "\"" << mesh.getAllLocalSettingsString();
     }
     sstream << "\n";
     return sstream.str();
@@ -57,23 +70,43 @@ bool FffProcessor::processFiles(const std::vector< std::string >& files)
 
 bool FffProcessor::processMeshGroup(MeshGroup* meshgroup)
 {
-    if (SHOW_ALL_SETTINGS) { logWarning(getAllSettingsString(*meshgroup, first_meshgroup).c_str()); }
+    if (SHOW_ALL_SETTINGS) { logWarning(getAllSettingsString(*meshgroup, meshgroup_number == 0).c_str()); }
     time_keeper.restart();
     if (!meshgroup)
         return false;
 
     TimeKeeper time_keeper_total;
+
+    polygon_generator.setParent(meshgroup);
+    gcode_writer.setParent(meshgroup);
+
+    bool empty = true;
+    for (Mesh& mesh : meshgroup->meshes)
+    {
+        if (!mesh.getSettingBoolean("infill_mesh"))
+        {
+            empty = false;
+        }
+    }
+    if (empty)
+    {
+        Progress::messageProgress(Progress::Stage::FINISH, 1, 1); // 100% on this meshgroup
+        log("Total time elapsed %5.2fs.\n", time_keeper_total.restart());
+
+        profile_string += getAllSettingsString(*meshgroup, meshgroup_number == 0);
+        return true;
+    }
     
     if (meshgroup->getSettingBoolean("wireframe_enabled"))
     {
         log("starting Neith Weaver...\n");
                     
         Weaver w(this);
-        w.weave(meshgroup, command_socket);
+        w.weave(meshgroup);
         
         log("starting Neith Gcode generation...\n");
         Wireframe2gcode gcoder(w, gcode_writer.gcode, this);
-        gcoder.writeGCode(command_socket);
+        gcoder.writeGCode();
         log("finished Neith Gcode generation...\n");
         
     } else 
@@ -84,17 +117,25 @@ bool FffProcessor::processMeshGroup(MeshGroup* meshgroup)
         {
             return false;
         }
-        gcode_writer.setCommandSocket(command_socket);
         
-        Progress::messageProgressStage(Progress::Stage::EXPORT, &time_keeper, command_socket);
+        Progress::messageProgressStage(Progress::Stage::EXPORT, &time_keeper);
         gcode_writer.writeGCode(storage, time_keeper);
     }
 
-    Progress::messageProgress(Progress::Stage::FINISH, 1, 1, command_socket); //Report the GUI that a file has been fully processed.
+    Progress::messageProgress(Progress::Stage::FINISH, 1, 1); // 100% on this meshgroup
+    if (CommandSocket::isInstantiated())
+    {
+        CommandSocket::getInstance()->flushGcode();
+        CommandSocket::getInstance()->sendLayerData();
+    }
     log("Total time elapsed %5.2fs.\n", time_keeper_total.restart());
 
-    profile_string += getAllSettingsString(*meshgroup, first_meshgroup);
-    first_meshgroup = false;
+    profile_string += getAllSettingsString(*meshgroup, meshgroup_number == 0);
+    meshgroup_number++;
+
+    polygon_generator.setParent(this); // otherwise consequent getSetting calls (e.g. for finalize) will refer to non-existent meshgroup
+    gcode_writer.setParent(this); // otherwise consequent getSetting calls (e.g. for finalize) will refer to non-existent meshgroup
+
     return true;
 }
 

src/FffProcessor.h

@@ -1,13 +1,13 @@
 #ifndef FFF_PROCESSOR_H
 #define FFF_PROCESSOR_H
 
-#include "settings.h"
+#include "settings/settings.h"
 #include "FffGcodeWriter.h"
 #include "FffPolygonGenerator.h"
 #include "commandSocket.h"
 #include "Weaver.h"
 #include "Wireframe2gcode.h"
-#include "Progress.h"
+#include "progress/Progress.h"
 #include "utils/gettime.h"
 #include "utils/NoCopy.h"
 
@@ -19,76 +19,152 @@ namespace cura {
 class FffProcessor : public SettingsBase , NoCopy
 {
 private:
+    /*!
+     * The FffProcessor used for the (current) slicing (The instance of this singleton)
+     */
     static FffProcessor instance; 
     
-    FffProcessor()
-    : polygon_generator(this)
-    , gcode_writer(this)
-    , first_meshgroup(true)
-    {
-        command_socket = NULL;
-    }
+    FffProcessor();
 public:
+    /*!
+     * Get the instance
+     * \return The instance
+     */
     static FffProcessor* getInstance() 
     { 
         return &instance; 
     }
-    
+
+    /*!
+     * Get the index of the meshgroup currently being processed, starting at zero.
+     */
+    int getMeshgroupNr();
+
 private:
+    /*!
+     * The polygon generator, which slices the models and generates all polygons to be printed and areas to be filled.
+     */
     FffPolygonGenerator polygon_generator;
+
+    /*!
+     * The gcode writer, which generates paths in layer plans in a buffer, which converts these paths into gcode commands.
+     */
     FffGcodeWriter gcode_writer;
-    CommandSocket* command_socket;
-    
-    bool first_meshgroup;
-    
+
+    /*!
+     * The index of the meshgroup currently being processed, starting at zero.
+     */
+    int meshgroup_number;
+
+    /*!
+     * A string containing all setting values passed to the engine in the format by which CuraEngine is called via the command line.
+     * 
+     * Used in debugging.
+     */
     std::string profile_string = "";
-    
+
+    /*!
+     * Get all settings for the current meshgroup in the format by which CuraEngine is called via the command line.
+     * 
+     * Also includes all global settings if this is the first meshgroup.
+     * 
+     * Used in debugging.
+     * 
+     * \param meshgroup The meshgroup for which to stringify all settings
+     * \param first_meshgroup Whether this is the first meshgroup and all global settigns should be included as well
+     */
     std::string getAllSettingsString(MeshGroup& meshgroup, bool first_meshgroup);
-    
+
 public:
+    /*!
+     * Get a string containing all setting values passed to the engine in the format by which CuraEngine is called via the command line.
+     * 
+     * \return A string containing all setting values passed to the engine in the format by which CuraEngine is called via the command line.
+     */
     std::string getProfileString() { return profile_string; }
-    
+
+    /*!
+     * The stop watch used to time how long the different stages take to compute.
+     */
     TimeKeeper time_keeper; // TODO: use singleton time keeper
-    
-    void resetFileNumber()
+
+    /*!
+     * Reset the meshgroup number to the first meshgroup to start a new slicing.
+     */
+    void resetMeshGroupNumber()
     {
-        gcode_writer.resetFileNumber();
+        meshgroup_number = 0;
     }
 
-    void setCommandSocket(CommandSocket* socket)
-    {
-        command_socket = socket;
-        gcode_writer.setCommandSocket(socket);
-        polygon_generator.setCommandSocket(socket);
-    }
-    
+    /*!
+     * Set the target to write gcode to: to a file.
+     * 
+     * Used when CuraEngine is used as command line tool.
+     * 
+     * \param filename The filename of the file to which to write the gcode.
+     */
     bool setTargetFile(const char* filename)
     {
         return gcode_writer.setTargetFile(filename);
     }
-    
+
+    /*!
+     * Set the target to write gcode to: an output stream.
+     * 
+     * Used when CuraEngine is NOT used as command line tool.
+     * 
+     * \param stream The stream to write gcode to.
+     */
     void setTargetStream(std::ostream* stream)
     {
         return gcode_writer.setTargetStream(stream);
     }
 
-    double getTotalFilamentUsed(int e)
+    /*!
+     * Get the total extruded volume for a specific extruder in mm^3
+     * 
+     * Retractions and unretractions don't contribute to this.
+     * 
+     * \param extruder_nr The extruder number for which to get the total netto extruded volume
+     * \return total filament printed in mm^3
+     */
+    double getTotalFilamentUsed(int extruder_nr)
     {
-        return gcode_writer.getTotalFilamentUsed(e);
+        return gcode_writer.getTotalFilamentUsed(extruder_nr);
     }
 
+    /*!
+     * Get the total estimated print time in seconds
+     * 
+     * \return total print time in seconds
+     */
     double getTotalPrintTime()
     {
         return gcode_writer.getTotalPrintTime();
     }
-    
+
+    /*!
+     * Add the end gcode and set all temperatures to zero.
+     */
     void finalize()
     {
         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.
+     * 
+     * \param meshgroup The meshgroup for which to generate gcode
+     * \return Whether this function succeeded
+     */
     bool processMeshGroup(MeshGroup* meshgroup);
 };
 

src/FlowTempGraph.h

@@ -0,0 +1,77 @@
+#ifndef FLOW_TEMP_GRAPH
+#define FLOW_TEMP_GRAPH
+
+#include <cassert>
+
+#include "utils/logoutput.h"
+
+namespace cura
+{
+
+/*!
+ * Class representing a graph matching a flow to a temperature.
+ * The graph generally consists of several linear line segments between points at which the temperature and flow are matched.
+ */
+class FlowTempGraph
+{
+public:
+    struct Datum
+    {
+        double flow; //!< The flow in mm^3/s
+        double temp; //!< The temperature in *C
+        Datum(double flow, double temp)
+        : flow(flow)
+        , temp(temp)
+        {}
+    };
+    std::vector<Datum> data; //!< The points of the graph between which the graph is linearly interpolated
+
+    FlowTempGraph()
+    {}
+    
+    /*!
+     * Get the temperature corresponding to a specific flow.
+     * 
+     * For flows outside of the chart, the temperature at the minimal or maximal flow is returned.
+     * When the graph is empty, the @p material_print_temperature is returned.
+     * 
+     * \param flow the flow in mm^3/s
+     * \param material_print_temperature The default printing temp (backward compatibility for when the graph fails)
+     * \return the corresponding temp
+     */
+    double getTemp(double flow, double material_print_temperature, bool flow_dependent_temperature)
+    {
+        if (!flow_dependent_temperature || data.size() == 0)
+        {
+            return material_print_temperature;
+        }
+        if (data.size() == 1)
+        {
+            return data.front().temp;
+        }
+        if (flow < data.front().flow)
+        {
+            logWarning("Warning! Flow too low!\n"); // TODO
+            return data.front().temp;
+        }
+        Datum* last_datum = &data.front();
+        for (unsigned int datum_idx = 1; datum_idx < data.size(); datum_idx++)
+        {
+            Datum& datum = data[datum_idx];
+            if (datum.flow >= flow)
+            {
+                return last_datum->temp + (datum.temp - last_datum->temp) * (flow - last_datum->flow) / (datum.flow - last_datum->flow);
+            }
+            last_datum = &datum;
+        }
+        
+        logWarning("Warning! Flow too high!\n"); // TODO
+        return data.back().temp;
+    };
+};
+
+
+
+} // namespace cura
+
+#endif // FLOW_TEMP_GRAPH

src/GCodePathConfig.cpp

@@ -0,0 +1,111 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+
+#include "utils/intpoint.h" // INT2MM
+#include "GCodePathConfig.h"
+
+namespace cura 
+{
+
+GCodePathConfig::BasicConfig::BasicConfig()
+: speed(0)
+, acceleration(0)
+, jerk(0)
+, line_width(0)
+, flow(100)
+{
+}
+
+
+GCodePathConfig::BasicConfig::BasicConfig(double speed, double acceleration, double jerk, int line_width, double flow)
+: speed(speed)
+, acceleration(acceleration)
+, jerk(jerk)
+, line_width(line_width)
+, flow(flow)
+{
+}
+
+void GCodePathConfig::BasicConfig::set(double speed, double acceleration, double jerk, int line_width, double flow)
+{
+    this->speed = speed;
+    this->acceleration = acceleration;
+    this->jerk = jerk;
+    this->line_width = line_width;
+    this->flow = flow;
+}
+
+
+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()
+{
+    return current_config.speed;
+}
+
+double GCodePathConfig::getAcceleration()
+{
+    return current_config.acceleration;
+}
+
+double GCodePathConfig::getJerk()
+{
+    return current_config.jerk;
+}
+
+int GCodePathConfig::getLineWidth()
+{
+    return current_config.line_width;
+}
+
+bool GCodePathConfig::isTravelPath()
+{
+    return current_config.line_width == 0;
+}
+
+double GCodePathConfig::getFlowPercentage()
+{
+    return current_config.flow;
+}
+
+void GCodePathConfig::calculateExtrusion()
+{
+    extrusion_mm3_per_mm = INT2MM(current_config.line_width) * INT2MM(layer_thickness) * double(current_config.flow) / 100.0;
+}
+
+
+}//namespace cura

src/GCodePathConfig.h

@@ -0,0 +1,112 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#ifndef G_CODE_PATH_CONFIG_H
+#define G_CODE_PATH_CONFIG_H
+
+#include "RetractionConfig.h"
+#include "PrintFeature.h"
+
+namespace cura 
+{
+
+/*!
+ * The GCodePathConfig is the configuration for moves/extrusion actions. This defines at which width the line is printed and at which speed.
+ */
+class GCodePathConfig
+{
+    friend class GCodePlannerTest;
+public:
+    /*!
+     * The path config settings which may change from layer to layer
+     */
+    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) (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
+    };
+private:
+    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:
+    const PrintFeatureType type; //!< name of the feature type
+
+    /*!
+     * Basic constructor.
+     */
+    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 !
+     * 
+     * \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(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();
+
+    /*!
+     * Get the movement speed in mm/s
+     */
+    double getSpeed();
+
+    /*!
+     * Get the current acceleration of this config
+     */
+    double getAcceleration();
+
+    /*!
+     * Get the current jerk of this config
+     */
+    double getJerk();
+
+    int getLineWidth();
+
+    bool isTravelPath();
+
+    double getFlowPercentage();
+
+private:
+    void calculateExtrusion();
+};
+
+
+}//namespace cura
+
+#endif // G_CODE_PATH_CONFIG_H

src/LayerPlanBuffer.cpp

@@ -0,0 +1,247 @@
+/** Copyright (C) 2015 Ultimaker - Released under terms of the AGPLv3 License */
+
+#include "LayerPlanBuffer.h"
+#include "gcodeExport.h"
+#include "utils/logoutput.h"
+#include "FffProcessor.h"
+
+namespace cura {
+
+
+
+void LayerPlanBuffer::flush()
+{
+    if (buffer.size() > 0)
+    {
+        insertPreheatCommands(); // insert preheat commands of the very last layer
+    }
+    while (!buffer.empty())
+    {
+        buffer.front().writeGCode(gcode);
+        if (CommandSocket::isInstantiated())
+        {
+            CommandSocket::getInstance()->flushGcode();
+        }
+        buffer.pop_front();
+    }
+    
+}
+
+void LayerPlanBuffer::insertPreheatCommand(ExtruderPlan& extruder_plan_before, double time_after_extruder_plan_start, int extruder, double temp)
+{
+    double acc_time = 0.0;
+    for (unsigned int path_idx = extruder_plan_before.paths.size() - 1; int(path_idx) != -1 ; path_idx--)
+    {
+        GCodePath& path = extruder_plan_before.paths[path_idx];
+        const double time_this_path = path.estimates.getTotalTime();
+        acc_time += time_this_path;
+        if (acc_time > time_after_extruder_plan_start)
+        {
+            const double time_before_path_end = acc_time - time_after_extruder_plan_start;
+            extruder_plan_before.insertCommand(path_idx, extruder, temp, false, time_this_path - time_before_path_end);
+            return;
+        }
+    }
+    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 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 = *extruder_plans[extruder_plan_before_idx];
+        if (extruder_plan.extruder == extruder)
+        {
+            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.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);
+    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);
+    }
+    warm_up.heating_time = warm_up.heating_time + extra_preheat_time;
+    return warm_up;
+    
+}
+
+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
+    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);
+}
+
+
+void LayerPlanBuffer::handleStandbyTemp(std::vector<ExtruderPlan*>& extruder_plans, unsigned int extruder_plan_idx, double standby_temp)
+{
+    ExtruderPlan& extruder_plan = *extruder_plans[extruder_plan_idx];
+    int extruder = extruder_plan.extruder;
+    for (unsigned int extruder_plan_before_idx = extruder_plan_idx - 2; int(extruder_plan_before_idx) >= 0; extruder_plan_before_idx--)
+    {
+        if (extruder_plans[extruder_plan_before_idx]->extruder == extruder)
+        {
+            extruder_plans[extruder_plan_before_idx + 1]->prev_extruder_standby_temp = standby_temp;
+            return;
+        }
+    }
+    logWarning("Warning: Couldn't find previous extruder plan so as to set the standby temperature. Inserting temp command in earliest available layer.\n");
+    ExtruderPlan& earliest_extruder_plan = *extruder_plans[0];
+    constexpr bool wait = false;
+    earliest_extruder_plan.insertCommand(0, extruder, standby_temp, wait);
+}
+
+void LayerPlanBuffer::insertPreheatCommand_multiExtrusion(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;
+    
+    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, required_temp);
+        return; // don't insert preheat command and just stay on printing temperature
+    }
+    else
+    {
+        handleStandbyTemp(extruder_plans, extruder_plan_idx, heating_time_and_from_temp.lowest_temperature);
+    }
+
+    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, required_temp);
+            return;
+        }
+        time_before_extruder_plan_to_insert -= time_here;
+    }
+    
+    // time_before_extruder_plan_to_insert falls before all plans in the buffer
+    extruder_plans[0]->insertCommand(0, extruder, required_temp, false); // insert preheat command at verfy beginning of buffer
+}
+
+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];
+    
+    int prev_extruder = prev_extruder_plan->extruder;
+    
+    if (prev_extruder != extruder)
+    { // set previous extruder to standby temperature
+        extruder_plan.prev_extruder_standby_temp = preheat_config.getStandbyTemp(prev_extruder);
+    }
+    
+    if (prev_extruder == extruder)
+    {
+        if (preheat_config.usesFlowDependentTemp(extruder))
+        {
+            insertPreheatCommand_singleExtrusion(*prev_extruder_plan, extruder, required_temp);
+        }
+    }
+    else 
+    {
+        insertPreheatCommand_multiExtrusion(extruder_plans, extruder_plan_idx);
+    }
+    
+}
+
+void LayerPlanBuffer::insertPreheatCommands()
+{
+    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;
+    }
+
+    std::vector<ExtruderPlan*> extruder_plans;
+    extruder_plans.reserve(buffer.size() * 2);
+    for (GCodePlanner& layer_plan : buffer)
+    {
+        for (ExtruderPlan& extr_plan : layer_plan.extruder_plans)
+        {
+            extruder_plans.push_back(&extr_plan);
+        }
+    }
+
+
+    // insert commands for all extruder plans on this layer
+    GCodePlanner& layer_plan = buffer.back();
+    for (unsigned int extruder_plan_idx = 0; extruder_plan_idx < layer_plan.extruder_plans.size(); extruder_plan_idx++)
+    {
+        ExtruderPlan& extruder_plan = layer_plan.extruder_plans[extruder_plan_idx];
+        double time = extruder_plan.estimates.getTotalUnretractedTime();
+        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; // 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
+            int extruder = extruder_plan.extruder;
+            for (int extruder_idx = 0; extruder_idx < getSettingAsCount("machine_extruder_count"); extruder_idx++)
+            { // set temperature of the first nozzle, turn other nozzles down
+                if (FffProcessor::getInstance()->getMeshgroupNr() == 0)
+                {
+                    // override values from GCodeExport::setInitialTemps
+                    // the first used extruder should be set to the required temp in the start gcode
+                    // see  FffGcodeWriter::processStartingCode
+                    if (extruder_idx == extruder)
+                    {
+                        gcode.setInitialTemp(extruder_idx, extruder_plan.required_temp);
+                    }
+                    else 
+                    {
+                        gcode.setInitialTemp(extruder_idx, preheat_config.getStandbyTemp(extruder_idx));
+                    }
+                }
+                else
+                {
+                    if (extruder_idx != extruder)
+                    { // TODO: do we need to do this?
+                        extruder_plan.prev_extruder_standby_temp = preheat_config.getStandbyTemp(extruder_idx);
+                    }
+                }
+            }
+            continue;
+        }
+
+        unsigned int overall_extruder_plan_idx = extruder_plans.size() - layer_plan.extruder_plans.size() + extruder_plan_idx;
+        insertPreheatCommand(extruder_plans, overall_extruder_plan_idx);
+    }
+}
+
+} // namespace cura

src/LayerPlanBuffer.h

@@ -0,0 +1,143 @@
+#ifndef LAYER_PLAN_BUFFER_H
+#define LAYER_PLAN_BUFFER_H
+
+#include <list>
+
+#include "settings/settings.h"
+#include "commandSocket.h"
+
+#include "gcodeExport.h"
+#include "gcodePlanner.h"
+#include "MeshGroup.h"
+
+#include "Preheat.h"
+
+namespace cura 
+{
+
+class LayerPlanBuffer : SettingsMessenger
+{
+    GCodeExport& gcode;
+    
+    Preheat preheat_config; //!< the nozzle and material temperature settings for each extruder train.
+    
+    static constexpr unsigned int buffer_size = 5; // should be as low as possible while still allowing enough time in the buffer to heat up from standby temp to printing temp // TODO: hardcoded value
+    // this value should be higher than 1, cause otherwise each layer is viewed as the first layer and no temp commands are inserted.
+
+    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.
+
+public:
+    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)
+    { }
+    
+    void setPreheatConfig(MeshGroup& settings)
+    {
+        preheat_config.setConfig(settings);
+    }
+    
+    /*!
+     * 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.
+     */
+    template<typename... Args>
+    GCodePlanner& emplace_back(Args&&... constructor_args)
+    {
+        if (buffer.size() > 0)
+        {
+            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)
+        {
+            buffer.front().writeGCode(gcode);
+            if (CommandSocket::isInstantiated())
+            {
+                CommandSocket::getInstance()->flushGcode();
+            }
+            buffer.pop_front();
+        }
+        return buffer.back();
+    }
+    
+    /*!
+     * Write all remaining layer plans (GCodePlanner) to gcode and empty the buffer.
+     */
+    void flush();
+    
+    /*!
+     * Insert the preheat command for @p extruder into @p extruder_plan_before
+     * 
+     * \param extruder_plan_before An extruder plan before the extruder plan for which the temperature is computed, in which to insert the preheat command
+     * \param time_before_extruder_plan_end The time before the end of the extruder plan, before which to insert the preheat command
+     * \param extruder The extruder for which to set the temperature
+     * \param temp The temperature of the preheat command
+     */
+    void insertPreheatCommand(ExtruderPlan& extruder_plan_before, double time_before_extruder_plan_end, int extruder, double temp);
+    
+    /*!
+     * Compute the time needed to preheat, based either on the time the extruder has been on standby 
+     * or based on the temp of the previous extruder plan which has the same extruder nr.
+     * 
+     * \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 find the preheat time needed
+     * \return the time needed to preheat and the temperature from which heating starts
+     */
+    Preheat::WarmUpResult timeBeforeExtruderPlanToInsert(std::vector<ExtruderPlan*>& extruder_plans, unsigned int extruder_plan_idx);
+    
+    /*!
+     * For two consecutive extruder plans of the same extruder (so on different layers), 
+     * preheat the extruder to the temperature corresponding to the average flow of the second extruder plan.
+     * 
+     * The preheat commands are inserted such that the middle of the temperature change coincides with the start of the next layer.
+     * 
+     * \param prev_extruder_plan The former extruder plan (of the former layer)
+     * \param extruder The extruder for which too set the temperature
+     * \param required_temp The required temperature for the second extruder plan
+     */
+    void insertPreheatCommand_singleExtrusion(ExtruderPlan& prev_extruder_plan, int extruder, double required_temp);
+    
+    /*!
+     * Insert the preheat command for an extruder plan which is preceded by an extruder plan with a different extruder.
+     * Find the time window in which this extruder hasn't been used
+     * and compute at what time the preheat command needs to be inserted.
+     * Then insert the preheat command in the right extruder plan.
+     * 
+     * \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 find the preheat time needed
+     */
+    void insertPreheatCommand_multiExtrusion(std::vector<ExtruderPlan*>& extruder_plans, unsigned int extruder_plan_idx);
+    
+    /*!
+     * Insert the preheat command for the extruder plan corersponding to @p extruder_plan_idx of the layer corresponding to @p layer_plan_idx.
+     * 
+     * \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 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 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]
+     * Set the prev_extruder_standby_temp in the next extruder plan
+     * 
+     * \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 before which to reconfigure the standby temperature
+     * \param standby_temp The temperature to which to cool down when the extruder is in standby mode.
+     */
+    void handleStandbyTemp(std::vector<ExtruderPlan*>& extruder_plans, unsigned int extruder_plan_idx, double standby_temp);
+};
+
+
+
+} // namespace cura
+
+#endif // LAYER_PLAN_BUFFER_H

src/MergeInfillLines.cpp

@@ -2,6 +2,8 @@
 
 #include <algorithm> // min
 
+#include "utils/linearAlg2D.h"
+
 namespace cura
 {
     
@@ -12,6 +14,7 @@ void MergeInfillLines::writeCompensatedMove(Point& to, double speed, GCodePath&
     double speed_mod = old_line_width / new_line_width_mm;
     double extrusion_mod = new_line_width_mm / old_line_width;
     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);
 }
     
@@ -20,10 +23,8 @@ bool MergeInfillLines::mergeInfillLines(double speed, unsigned int& path_idx)
     Point prev_middle;
     Point last_middle;
     int64_t line_width;
-    
-    MergeInfillLines merger(gcode, paths, travelConfig, nozzle_size);
-    
-    if (merger.isConvertible(path_idx, prev_middle, last_middle, line_width, false))
+
+    if (isConvertible(path_idx, prev_middle, last_middle, line_width, false))
     {
         //   path_idx + 3 is the index of the second extrusion move to be converted in combination with the first
         {
@@ -39,75 +40,150 @@ bool MergeInfillLines::mergeInfillLines(double speed, unsigned int& path_idx)
         }
         
         path_idx += 2;
-        for (; merger.isConvertible(path_idx, prev_middle, last_middle, line_width, true); path_idx += 2)
+        extruder_plan.handleInserts(path_idx, gcode);
+        for (; isConvertible(path_idx, prev_middle, last_middle, line_width, true); path_idx += 2)
         {
+            extruder_plan.handleInserts(path_idx, gcode);
             GCodePath& last_path = paths[path_idx + 3];
             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);
         return true;
     }
     return false;
 };
 
-bool MergeInfillLines::isConvertible(unsigned int path_idx_first_move, Point& first_middle, Point& second_middle, int64_t& line_width, bool use_second_middle_as_first)
+bool MergeInfillLines::isConvertible(unsigned int path_idx_first_move, Point& first_middle, Point& second_middle, int64_t& resulting_line_width, bool use_second_middle_as_first)
 {
-    int64_t max_line_width = nozzle_size * 3 / 2;
-    
-    
     unsigned int idx = path_idx_first_move;
-    if (idx + 3 > paths.size()-1) return false;
-    if (paths[idx+0].config != &travelConfig) return false;
-    if (paths[idx+1].points.size() > 1) return false;
-    if (paths[idx+1].config == &travelConfig) return false;
-//                 if (paths[idx+2].points.size() > 1) return false;
-    if (paths[idx+2].config != &travelConfig) return false;
-    if (paths[idx+3].points.size() > 1) return false;
-    if (paths[idx+3].config == &travelConfig) return false;
+    if (idx + 3 > paths.size()-1) 
+    {
+        return false;
+    }
+    if (   paths[idx+0].config != &travelConfig // must be travel
+        || paths[idx+1].points.size() > 1       // extrusion path is single line
+        || paths[idx+1].config == &travelConfig // must be extrusion
+//        || paths[idx+2].points.size() > 1       // travel must be direct
+        || paths[idx+2].config != &travelConfig // must be travel
+        || paths[idx+3].points.size() > 1       // extrusion path is single line
+        || paths[idx+3].config == &travelConfig // must be extrusion
+        || paths[idx+1].config != paths[idx+3].config // both extrusion moves should have the same config
+    )
+    {
+        return false;
+    }
+
+    if (!(paths[idx+1].config->type == PrintFeatureType::Infill || paths[idx+1].config->type == PrintFeatureType::Skin))
+    { // only (skin) infill lines can be merged (note that the second extrusion line config is already checked to be the same as the first in code above)
+        return false;
+    }
+
+    if (paths[idx+1].space_fill_type != SpaceFillType::Lines || paths[idx+3].space_fill_type != SpaceFillType::Lines)
+    { // both extrusion moves must be of lines space filling type!
+        return false;
+    }
+
+    int64_t line_width = paths[idx+1].config->getLineWidth();
     
     Point& a = paths[idx+0].points.back(); // first extruded line from
     Point& b = paths[idx+1].points.back(); // first extruded line to
     Point& c = paths[idx+2].points.back(); // second extruded line from
     Point& d = paths[idx+3].points.back(); // second extruded line to
+    
+    return isConvertible(a, b, c, d, line_width, first_middle, second_middle, resulting_line_width, use_second_middle_as_first);
+}
+
+bool MergeInfillLines::isConvertible(const Point& a, const Point& b, const Point& c, const Point& d, int64_t line_width, Point& first_middle, Point& second_middle, int64_t& resulting_line_width, bool use_second_middle_as_first)
+{
+    use_second_middle_as_first = false;
+    int64_t max_line_width = nozzle_size * 3 / 2;
+
     Point ab = b - a;
     Point cd = d - c;
-    
+
+    if (b == c)
+    {
+        return false; // the line segments are connected!
+    }
+
+    int64_t ab_size = vSize(ab);
+    int64_t cd_size = vSize(cd);
+
+    if (ab_size > nozzle_size * 5 || cd_size > nozzle_size * 5)
+    {
+        return false; // infill lines are too long; otherwise infill lines might be merged when the next infill line is coincidentally shorter like |, would become \ ...
+    }
+
+    // if the lines are in the same direction then abs( dot(ab,cd) / |ab| / |cd| ) == 1
     int64_t prod = dot(ab,cd);
-    if (std::abs(prod) + 400 < vSize(ab) * vSize(cd)) // 400 = 20*20, where 20 micron is the allowed inaccuracy in the dot product, introduced by the inaccurate point locations of a,b,c,d
+    if (std::abs(prod) + 400 < ab_size * cd_size) // 400 = 20*20, where 20 micron is the allowed inaccuracy in the dot product, introduced by the inaccurate point locations of a,b,c,d
+    {
         return false; // extrusion moves not in the same or opposite diraction
-    if (prod < 0) { ab = ab * -1; }
+    }
     
-    
-    Point infill_vector = (cd + ab) / 2;
-    
-    if (!shorterThen(infill_vector, 5 * nozzle_size)) return false; // infill lines too far apart
-                    
+    // make lines in the same direction by flipping one
+    if (prod < 0)
+    {
+        ab = ab * -1;
+    }
+    else if (prod == 0)
+    {
+        return false; // lines are orthogonal!
+    }
+    else if (b == d || a == c)
+    {
+        return false; // the line segments are connected!
+    }
+
     first_middle = (use_second_middle_as_first)?
                     second_middle :
                     (a + b) / 2;
     second_middle = (c + d) / 2;
     
-    Point dir_vector_perp = crossZ(second_middle - first_middle);
+    Point dir_vector_perp = turn90CCW(second_middle - first_middle);
     int64_t dir_vector_perp_length = vSize(dir_vector_perp); // == dir_vector_length
-    if (dir_vector_perp_length == 0) return false;
-    if (dir_vector_perp_length > 5 * nozzle_size) return false; // infill lines too far apart
-    
-    
-    line_width = std::abs( dot(dir_vector_perp, infill_vector) / dir_vector_perp_length );
-    if (line_width > max_line_width) return false; // combined lines would be too wide
-    if (line_width == 0) return false; // dot is zero, so lines are in each others extension, not next to eachother
-    
-    { // check whether the two lines are adjacent
-        Point ca = first_middle - c;
-        double ca_size = vSizeMM(ca);
-        double cd_size = vSizeMM(cd);
-        double prod = INT2MM(dot(ca, cd));
-        double fraction = prod / ( ca_size * cd_size );
-        int64_t line2line_dist = MM2INT(cd_size * std::sqrt(1.0 - fraction * fraction));
-        
-        if (line2line_dist + 20 > paths[idx+1].config->getLineWidth()) return false; // there is a gap between the two lines
+    if (dir_vector_perp_length == 0)
+    {
+        return false;
+    }
+    if (dir_vector_perp_length > 5 * nozzle_size)
+    {
+        return false; // infill lines too far apart
+    }
+
+    Point infill_vector = (cd + ab) / 2; // (similar to) average line / direction of the infill
+
+    // compute the resulting line width
+    resulting_line_width = std::abs( dot(dir_vector_perp, infill_vector) / dir_vector_perp_length );
+    if (resulting_line_width > max_line_width)
+    {
+        return false; // combined lines would be too wide
+    }
+    if (resulting_line_width == 0)
+    {
+        return false; // dot is zero, so lines are in each others extension, not next to eachother
+    }
+
+    // check whether two lines are adjacent (note: not 'line segments' but 'lines')
+    Point ac = c - first_middle;
+    Point infill_vector_perp = turn90CCW(infill_vector);
+    int64_t perp_proj = dot(ac, infill_vector_perp);
+    int64_t infill_vector_perp_length = vSize(infill_vector_perp);
+    if (std::abs(std::abs(perp_proj) / infill_vector_perp_length - line_width) > 20) // it should be the case that dot(ac, infill_vector_perp) / |infill_vector_perp| == line_width
+    {
+        return false; // lines are too far apart or too close together
     }
     
+    // check whether the two line segments are adjacent.
+    // full infill in a narrow area might result in line segments with arbitrary distance between them
+    // the more the narrow passage in the area gets aligned with the infill direction, the further apart the line segments will be
+    // however, distant line segments might also be due to different narrow passages, so we limit the distance between merged line segments.
+    if (!LinearAlg2D::lineSegmentsAreCloserThan(a, b, c, d, line_width * 2))
+    {
+        return false;
+    }
+
     return true;
 };
 

src/MergeInfillLines.h

@@ -4,6 +4,7 @@
 #include "utils/intpoint.h"
 #include "gcodeExport.h"
 #include "gcodePlanner.h"
+#include "GCodePathConfig.h"
 
 namespace cura
 {
@@ -12,22 +13,42 @@ class MergeInfillLines
 {
 //     void merge(Point& from, Point& p0, Point& p1);
     GCodeExport& gcode; //!<  Where to write the combined line to
+    int layer_nr; //!< The current layer number
     std::vector<GCodePath>& paths; //!< The paths currently under consideration
+    ExtruderPlan& extruder_plan; //!< The extruder plan of the paths currently under consideration
+    
     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
-    
-    
+
     /*!
      * 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
      * \param path_idx_first_move Index into MergeInfillLines::paths to the travel before the two extrusion moves udner consideration
      * \param first_middle Output parameter: the middle of the first extrusion move
      * \param second_middle Input/Output parameter: outputs the middle of the second extrusion move; inputs \p first_middle so we don't have to compute it
-     * \param line_width Output parameter: The width of the resulting combined line (the average length of the lines combined)
+     * \param resulting_line_width Output parameter: The width of the resulting combined line (the average length of the lines combined)
      * \param use_second_middle_as_first Whether to use \p second_middle as input parameter for \p first_middle
      * \return 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
      */
-    bool isConvertible(unsigned int path_idx_first_move, Point& first_middle, Point& second_middle, int64_t& line_width, bool use_second_middle_as_first);
-    
+    bool isConvertible(unsigned int path_idx_first_move, Point& first_middle, Point& second_middle, int64_t& resulting_line_width, bool use_second_middle_as_first = false);
+
+    /*!
+     * Whether the two consecutive extrusion paths (ab and cd) are convitrible to a single line segment.
+     * 
+     * Note: as an optimization the \p second_middle from the previous call to isConvertible can be used for \p first_middle, instead of recomputing it. 
+     * 
+     * \param a first from
+     * \param b first to
+     * \param c second from
+     * \param d second to
+     * \param line_width The line width of the moves
+     * \param first_middle Output parameter: the middle of the first extrusion move
+     * \param second_middle Input/Output parameter: outputs the middle of the second extrusion move; inputs \p first_middle so we don't have to compute it
+     * \param resulting_line_width Output parameter: The width of the resulting combined line (the average length of the lines combined)
+     * \param use_second_middle_as_first Whether to use \p second_middle as input parameter for \p first_middle
+     * \return 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
+     */
+    bool isConvertible(const Point& a, const Point& b, const Point& c, const Point& d, int64_t line_width, Point& first_middle, Point& second_middle, int64_t& resulting_line_width, bool use_second_middle_as_first = false);
+
     /*!
      * Write an extrusion move with compensated width and compensated speed so that the material flow will be the same.
      * 
@@ -41,8 +62,8 @@ public:
     /*!
      * Simple constructor only used by MergeInfillLines::isConvertible to easily convey the environment
      */
-    MergeInfillLines(GCodeExport& gcode, std::vector<GCodePath>& paths,  GCodePathConfig& travelConfig, int64_t nozzle_size) 
-    : gcode(gcode), paths(paths), travelConfig(travelConfig), nozzle_size(nozzle_size) { }
+    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.
@@ -58,6 +79,21 @@ public:
      */
     bool mergeInfillLines(double speed, unsigned int& path_idx);
     
+    /*!
+     * send a polygon through the command socket from the previous point to the given point
+     */
+    void sendPolygon(PrintFeatureType print_feature_type, Point from, Point to, int 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

src/MeshGroup.cpp

@@ -28,7 +28,120 @@ void* fgets_(char* ptr, size_t len, FILE* f)
     return nullptr;
 }
 
-bool loadMeshSTL_ascii(Mesh* mesh, const char* filename, FMatrix3x3& matrix)
+MeshGroup::MeshGroup(SettingsBaseVirtual* settings_base)
+: SettingsBase(settings_base)
+, extruder_count(-1)
+{}
+
+MeshGroup::~MeshGroup()
+{
+    for (unsigned int extruder = 0; extruder < MAX_EXTRUDERS; extruder++)
+    {
+        if (extruders[extruder])
+        {
+            delete extruders[extruder];
+        }
+    }
+}
+
+int MeshGroup::getExtruderCount()
+{
+    if (extruder_count == -1)
+    {
+        extruder_count = getSettingAsCount("machine_extruder_count");
+    }
+    return extruder_count;
+}
+
+ExtruderTrain* MeshGroup::createExtruderTrain(unsigned int extruder_nr)
+    {
+        if (!extruders[extruder_nr])
+        {
+            extruders[extruder_nr] = new ExtruderTrain(this, extruder_nr);
+        }
+        return extruders[extruder_nr];
+    }
+
+ExtruderTrain* MeshGroup::getExtruderTrain(unsigned int extruder_nr)
+{
+    assert(extruders[extruder_nr]);
+    return extruders[extruder_nr];
+}
+
+const ExtruderTrain* MeshGroup::getExtruderTrain(unsigned int extruder_nr) const
+{
+    assert(extruders[extruder_nr]);
+    return extruders[extruder_nr];
+}
+
+Point3 MeshGroup::min() const
+{
+    if (meshes.size() < 1)
+    {
+        return Point3(0, 0, 0);
+    }
+    Point3 ret = meshes[0].min();
+    for(unsigned int i=1; i<meshes.size(); i++)
+    {
+        Point3 v = meshes[i].min();
+        ret.x = std::min(ret.x, v.x);
+        ret.y = std::min(ret.y, v.y);
+        ret.z = std::min(ret.z, v.z);
+    }
+    return ret;
+}
+
+Point3 MeshGroup::max() const
+{
+    if (meshes.size() < 1)
+    {
+        return Point3(0, 0, 0);
+    }
+    Point3 ret = meshes[0].max();
+    for(unsigned int i=1; i<meshes.size(); i++)
+    {
+        Point3 v = meshes[i].max();
+        ret.x = std::max(ret.x, v.x);
+        ret.y = std::max(ret.y, v.y);
+        ret.z = std::max(ret.z, v.z);
+    }
+    return ret;
+}
+
+void MeshGroup::clear()
+{
+    for(Mesh& m : meshes)
+    {
+        m.clear();
+    }
+}
+
+void MeshGroup::finalize()
+{
+    //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"))
+    {
+        meshgroup_offset.x = getSettingInMicrons("machine_width") / 2;
+        meshgroup_offset.y = getSettingInMicrons("machine_depth") / 2;
+    }
+    
+    // If a mesh position was given, put the mesh at this position in 3D space. 
+    for(Mesh& mesh : meshes)
+    {
+        Point3 mesh_offset(mesh.getSettingInMicrons("mesh_position_x"), mesh.getSettingInMicrons("mesh_position_y"), mesh.getSettingInMicrons("mesh_position_z"));
+        if (mesh.getSettingBoolean("center_object"))
+        {
+            Point3 object_min = mesh.min();
+            Point3 object_max = mesh.max();
+            Point3 object_size = object_max - object_min;
+            mesh_offset += Point3(-object_min.x - object_size.x / 2, -object_min.y - object_size.y / 2, -object_min.z);
+        }
+        mesh.offset(mesh_offset + meshgroup_offset);
+    }
+}
+
+bool loadMeshSTL_ascii(Mesh* mesh, const char* filename, const FMatrix3x3& matrix)
 {
     FILE* f = fopen(filename, "rt");
     char buffer[1024];
@@ -61,29 +174,41 @@ bool loadMeshSTL_ascii(Mesh* mesh, const char* filename, FMatrix3x3& matrix)
     return true;
 }
 
-bool loadMeshSTL_binary(Mesh* mesh, const char* filename, FMatrix3x3& matrix)
+bool loadMeshSTL_binary(Mesh* mesh, const char* filename, const FMatrix3x3& matrix)
 {
     FILE* f = fopen(filename, "rb");
+
+    fseek(f, 0L, SEEK_END);
+    long long file_size = ftell(f); //The file size is the position of the cursor after seeking to the end.
+    rewind(f); //Seek back to start.
+    size_t face_count = (file_size - 80 - sizeof(uint32_t)) / 50; //Subtract the size of the header. Every face uses exactly 50 bytes.
+
     char buffer[80];
-    uint32_t faceCount;
     //Skip the header
     if (fread(buffer, 80, 1, f) != 1)
     {
         fclose(f);
         return false;
     }
-    //Read the face count
-    if (fread(&faceCount, sizeof(uint32_t), 1, f) != 1)
+
+    uint32_t reported_face_count;
+    //Read the face count. We'll use it as a sort of redundancy code to check for file corruption.
+    if (fread(&reported_face_count, sizeof(uint32_t), 1, f) != 1)
     {
         fclose(f);
         return false;
     }
+    if (reported_face_count != face_count)
+    {
+        logWarning("Face count reported by file (%s) is not equal to actual face count (%s). File could be corrupt!\n", std::to_string(reported_face_count).c_str(), std::to_string(face_count).c_str());
+    }
+
     //For each face read:
     //float(x,y,z) = normal, float(X,Y,Z)*3 = vertexes, uint16_t = flags
     // Every Face is 50 Bytes: Normal(3*float), Vertices(9*float), 2 Bytes Spacer
-    mesh->faces.reserve(faceCount);
-    mesh->vertices.reserve(faceCount);
-    for(unsigned int i=0;i<faceCount;i++)
+    mesh->faces.reserve(face_count);
+    mesh->vertices.reserve(face_count);
+    for (unsigned int i = 0; i < face_count; i++)
     {
         if (fread(buffer, 50, 1, f) != 1)
         {
@@ -102,13 +227,34 @@ bool loadMeshSTL_binary(Mesh* mesh, const char* filename, FMatrix3x3& matrix)
     return true;
 }
 
-bool loadMeshSTL(Mesh* mesh, const char* filename, FMatrix3x3& matrix)
+bool loadMeshSTL(Mesh* mesh, const char* filename, const FMatrix3x3& matrix)
 {
     FILE* f = fopen(filename, "r");
-    char buffer[6];
     if (f == nullptr)
+    {
         return false;
+    }
 
+    //Skip any whitespace at the beginning of the file.
+    unsigned long long num_whitespace = 0; //Number of whitespace characters.
+    unsigned char whitespace;
+    if (fread(&whitespace, 1, 1, f) != 1)
+    {
+        fclose(f);
+        return false;
+    }
+    while(isspace(whitespace))
+    {
+        num_whitespace++;
+        if (fread(&whitespace, 1, 1, f) != 1)
+        {
+            fclose(f);
+            return false;
+        }
+    }
+    fseek(f, num_whitespace, SEEK_SET); //Seek to the place after all whitespace (we may have just read too far).
+
+    char buffer[6];
     if (fread(buffer, 5, 1, f) != 1)
     {
         fclose(f);
@@ -135,22 +281,19 @@ bool loadMeshSTL(Mesh* mesh, const char* filename, FMatrix3x3& matrix)
     return loadMeshSTL_binary(mesh, filename, matrix);
 }
 
-bool loadMeshIntoMeshGroup(MeshGroup* meshgroup, const char* filename, FMatrix3x3& transformation, SettingsBaseVirtual* object_parent_settings)
+bool loadMeshIntoMeshGroup(MeshGroup* meshgroup, const char* filename, const FMatrix3x3& transformation, SettingsBaseVirtual* object_parent_settings)
 {
     const char* ext = strrchr(filename, '.');
     if (ext && (strcmp(ext, ".stl") == 0 || strcmp(ext, ".STL") == 0))
     {
-        if (object_parent_settings)
+        Mesh mesh = object_parent_settings ? Mesh(object_parent_settings) : Mesh(meshgroup); //If we have object_parent_settings, use them as parent settings. Otherwise, just use meshgroup.
+        if(loadMeshSTL(&mesh,filename,transformation)) //Load it! If successful...
         {
-            meshgroup->meshes.emplace_back(object_parent_settings); // make new mesh with [object_parent_settings] as parent settings object
+            meshgroup->meshes.push_back(mesh);
+            return true;
         }
-        else 
-        {
-            meshgroup->meshes.emplace_back(meshgroup); // make new mesh with [meshgroup] as parent settings object
-        }
-        return loadMeshSTL(&meshgroup->meshes[meshgroup->meshes.size()-1], filename, transformation);
     }
     return false;
 }
 
-}//namespace cura
+}//namespace cura

src/MeshGroup.h

@@ -2,6 +2,7 @@
 #ifndef MESH_GROUP_H
 #define MESH_GROUP_H
 
+#include "utils/NoCopy.h"
 #include "mesh.h"
 #include "ExtruderTrain.h"
 
@@ -14,112 +15,34 @@ namespace cura
  * One MeshGroup is a whole which is printed at once.
  * Generally there is one single MeshGroup, though when using one-at-a-time printing, multiple MeshGroups are processed consecutively.
  */
-class MeshGroup : public SettingsBase
+class MeshGroup : public SettingsBase, NoCopy
 {
     ExtruderTrain* extruders[MAX_EXTRUDERS] = {nullptr};
     int extruder_count;
 public:
-    int getExtruderCount()
-    {
-        if (extruder_count == -1)
-        {
-            extruder_count = getSettingAsCount("machine_extruder_count");
-        }
-        return extruder_count;
-    }
+    int getExtruderCount();
 
-    MeshGroup(SettingsBaseVirtual* settings_base) 
-    : SettingsBase(settings_base)
-    , extruder_count(-1) 
-    {}
+    MeshGroup(SettingsBaseVirtual* settings_base);
     
-    ~MeshGroup() 
-    {
-        for (unsigned int extruder = 0; extruder < MAX_EXTRUDERS; extruder++)
-        {
-            if (extruders[extruder])
-            {
-                delete extruders[extruder];
-            }
-        }
-    }
-    
-    ExtruderTrain* getExtruderTrain(unsigned int extruder_nr)
-    {
-        if (!extruders[extruder_nr])
-        {
-            extruders[extruder_nr] = new ExtruderTrain(this, extruder_nr);
-        }
-        return extruders[extruder_nr];
-    }
+    ~MeshGroup();
     
+    /*!
+     * Create a new extruder train for the @p extruder_nr, or return the one which already exists.
+     */
+    ExtruderTrain* createExtruderTrain(unsigned int extruder_nr);
+
+    ExtruderTrain* getExtruderTrain(unsigned int extruder_nr);
+
+    const ExtruderTrain* getExtruderTrain(unsigned int extruder_nr) const;
+
     std::vector<Mesh> meshes;
 
-    Point3 min() //! minimal corner of bounding box
-    {
-        if (meshes.size() < 1)
-        {
-            return Point3(0, 0, 0);
-        }
-        Point3 ret = meshes[0].min();
-        for(unsigned int i=1; i<meshes.size(); i++)
-        {
-            Point3 v = meshes[i].min();
-            ret.x = std::min(ret.x, v.x);
-            ret.y = std::min(ret.y, v.y);
-            ret.z = std::min(ret.z, v.z);
-        }
-        return ret;
-    }
-    Point3 max() //! maximal corner of bounding box
-    {
-        if (meshes.size() < 1)
-        {
-            return Point3(0, 0, 0);
-        }
-        Point3 ret = meshes[0].max();
-        for(unsigned int i=1; i<meshes.size(); i++)
-        {
-            Point3 v = meshes[i].max();
-            ret.x = std::max(ret.x, v.x);
-            ret.y = std::max(ret.y, v.y);
-            ret.z = std::max(ret.z, v.z);
-        }
-        return ret;
-    }
+    Point3 min() const; //! minimal corner of bounding box
+    Point3 max() const; //! maximal corner of bounding box
 
-    void clear()
-    {
-        for(Mesh& m : meshes)
-        {
-            m.clear();
-        }
-    }
+    void clear();
 
-    void finalize()
-    {
-        //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"))
-        {
-            meshgroup_offset.x = getSettingInMicrons("machine_width") / 2;
-            meshgroup_offset.y = getSettingInMicrons("machine_depth") / 2;
-        }
-        
-        // If a mesh position was given, put the mesh at this position in 3D space. 
-        for(Mesh& mesh : meshes)
-        {
-            Point3 mesh_offset(mesh.getSettingInMicrons("mesh_position_x"), mesh.getSettingInMicrons("mesh_position_y"), mesh.getSettingInMicrons("mesh_position_z"));
-            if (mesh.getSettingBoolean("center_object"))
-            {
-                Point3 object_min = mesh.min();
-                Point3 object_max = mesh.max();
-                Point3 object_size = object_max - object_min;
-                mesh_offset += Point3(-object_min.x - object_size.x / 2, -object_min.y - object_size.y / 2, -object_min.z);
-            }
-            mesh.offset(mesh_offset + meshgroup_offset);
-        }
-    }
+    void finalize();
 };
 
 /*!
@@ -131,7 +54,7 @@ public:
  * \param object_parent_settings (optional) The parent settings object of the new mesh. Defaults to \p meshgroup if none is given.
  * \return whether the file could be loaded
  */
-bool loadMeshIntoMeshGroup(MeshGroup* meshgroup, const char* filename, FMatrix3x3& transformation, SettingsBaseVirtual* object_parent_settings = nullptr);
+bool loadMeshIntoMeshGroup(MeshGroup* meshgroup, const char* filename, const FMatrix3x3& transformation, SettingsBaseVirtual* object_parent_settings = nullptr);
 
 }//namespace cura
 #endif//MESH_GROUP_H

src/Preheat.h

@@ -0,0 +1,219 @@
+#ifndef PREHEAT_H
+#define PREHEAT_H
+
+#include <cassert>
+#include <algorithm> // max
+
+#include "utils/logoutput.h"
+#include "MeshGroup.h"
+
+#include "FlowTempGraph.h"
+
+
+namespace cura 
+{
+
+
+
+/*!
+ * Class for computing heatup and cooldown times used for computing the time the printer needs to heat up to a printing temperature.
+ */
+class Preheat 
+{
+    /*!
+     * The nozzle and material temperature settings for an extruder train.
+     */
+    class Config
+    {
+    public:
+        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)
+        
+        bool flow_dependent_temperature; //!< Whether to make the temperature dependent on flow
+    
+        FlowTempGraph flow_temp_graph; //!< The graph linking flows to corresponding temperatures
+    };
+
+    std::vector<Config> config_per_extruder;//!< the nozzle and material temperature settings for each extruder train.
+public:
+    /*!
+     * The type of result when computing when to start heating up a nozzle before it's going to be used again.
+     */
+    struct WarmUpResult
+    {
+        double total_time_window; //!< The total time in which cooling and heating takes place.
+        double heating_time; //!< The total time needed to heat to the required temperature.
+        double lowest_temperature; //!< The lower temperature from which heating starts.
+    };
+
+    /*!
+     * Get the standby temperature of an extruder train
+     * \param extruder the extruder train for which to get the standby tmep
+     * \return the standby temp
+     */
+    double getStandbyTemp(int extruder)
+    {
+        return config_per_extruder[extruder].standby_temp;
+    }
+
+    /*!
+     * 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
+     * \return the time it takes to heat up one degree celsius
+     */
+    double getTimeToHeatup1Degree(int extruder)
+    {
+        return config_per_extruder[extruder].time_to_heatup_1_degree;
+    }
+
+    /*!
+     * Set the nozzle and material temperature settings for each extruder train.
+     */
+    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:
+    /*!
+     * 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
+     * \return The corresponding optimal temperature
+     */
+    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
+     * \param extruder The extruder for which to get the minimal time window
+     * \return the minimal time window of a specific extruder for letting an unused extruder cool down and warm up again
+     */
+    double getMinimalTimeWindow(unsigned int extruder)
+    {
+        return config_per_extruder[extruder].min_time_window;
+    }
+
+    /*!
+     * 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  \/    .
+     * 
+     * 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
+     * 
+     * \param window_time The time window within which the cooldown and heat up must take place.
+     * \param extruder The extruder used
+     * \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 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;
+    }
+    /*!
+     * 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.
+     * 
+     * 
+     * \param from_temp The temperature at which the nozzle was before
+     * \param extruder The extruder used
+     * \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)
+     */
+    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 
+
+#endif // PREHEAT_H

src/PrimeTower.cpp

@@ -5,6 +5,7 @@
 #include "gcodeExport.h"
 #include "gcodePlanner.h"
 #include "infill.h"
+#include "PrintFeature.h"
 
 namespace cura 
 {
@@ -16,20 +17,29 @@ PrimeTower::PrimeTower()
 
 
 
-void PrimeTower::setConfigs(MeshGroup* meshgroup, std::vector<RetractionConfig>& retraction_config_per_extruder, int layer_thickness)
+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++)
+    {
+        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::setConfigs(MeshGroup* meshgroup, int layer_thickness)
 {
     
     extruder_count = meshgroup->getSettingAsCount("machine_extruder_count");
     
     for (int extr = 0; extr < extruder_count; extr++)
     {
-        ExtruderTrain* train = meshgroup->getExtruderTrain(extr);
-        config_per_extruder.emplace_back(&retraction_config_per_extruder[extr], "WALL-INNER");// so that visualization in the old Cura still works (TODO)
-        GCodePathConfig& conf = config_per_extruder.back();
-        
-        conf.setSpeed(train->getSettingInMillimetersPerSecond("speed_prime_tower"));
-        conf.setLineWidth(train->getSettingInMicrons("prime_tower_line_width"));
-        conf.setFlow(train->getSettingInPercentage("prime_tower_flow"));
+        GCodePathConfig& conf = config_per_extruder[extr];
         conf.setLayerHeight(layer_thickness);
     }
 }
@@ -41,18 +51,19 @@ void PrimeTower::computePrimeTowerMax(SliceDataStorage& storage)
         
     extruder_count = storage.getSettingAsCount("machine_extruder_count");
     
-    int max_object_height_per_extruder[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
-        memset(max_object_height_per_extruder, -1, sizeof(max_object_height_per_extruder));
         for (SliceMeshStorage& mesh : storage.meshes)
         {
-            max_object_height_per_extruder[mesh.getSettingAsIndex("extruder_nr")] = 
-                std::max(   max_object_height_per_extruder[mesh.getSettingAsIndex("extruder_nr")]
+            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_extruder_nr = storage.getSettingAsIndex("support_extruder_nr"); // TODO: support extruder should be configurable per object
-        max_object_height_per_extruder[support_extruder_nr] = 
-        std::max(   max_object_height_per_extruder[support_extruder_nr]
+        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] = 
@@ -72,7 +83,7 @@ void PrimeTower::computePrimeTowerMax(SliceDataStorage& storage)
         for (int extruder_nr = 0; extruder_nr < extruder_count; extruder_nr++)
         {
             if (extruder_nr == extruder_max_object_height) { continue; }
-            if (max_object_height_per_extruder[extruder_nr] > max_object_height_per_extruder[extruder_second_max_object_height])
+            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;
             }
@@ -93,7 +104,7 @@ void PrimeTower::generateGroundpoly(SliceDataStorage& storage)
 {
     PolygonRef p = storage.primeTower.ground_poly.newPoly();
     int tower_size = storage.getSettingInMicrons("prime_tower_size");
-    int tower_distance = 0; //storage.getSettingInMicrons("prime_tower_distance");
+    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));
@@ -104,23 +115,21 @@ void PrimeTower::generateGroundpoly(SliceDataStorage& storage)
     storage.wipePoint = Point(x + tower_distance - tower_size / 2, y + tower_distance + tower_size / 2);   
 }
 
-void PrimeTower::generatePaths(SliceDataStorage& storage, unsigned int totalLayers)
+void PrimeTower::generatePaths(SliceDataStorage& storage, unsigned int total_layers)
 {
-    if (storage.max_object_height_second_to_last_extruder >= 0 
-//         && storage.getSettingInMicrons("prime_tower_distance") > 0 
-        && storage.getSettingInMicrons("prime_tower_size") > 0)
+    if (storage.max_object_height_second_to_last_extruder >= 0 && storage.getSettingBoolean("prime_tower_enable"))
     {
         generatePaths3(storage);
     }
 }
-void PrimeTower::generatePaths_OLD(SliceDataStorage& storage, unsigned int totalLayers)
+void PrimeTower::generatePaths_OLD(SliceDataStorage& storage, unsigned int total_layers)
 {
     
-    if (storage.max_object_height_second_to_last_extruder >= 0 && storage.getSettingInMicrons("prime_tower_distance") > 0 && storage.getSettingInMicrons("prime_tower_size") > 0)
+    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; //storage.getSettingInMicrons("prime_tower_distance");
+        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));
@@ -159,7 +168,7 @@ void PrimeTower::generatePaths3(SliceDataStorage& storage)
 {
         
     int n_patterns = 2; // alternating patterns between layers
-    double infill_overlap = 15; // so that it can't be zero
+    int infill_overlap = 60; // so that it can't be zero; EDIT: wtf?
     
     generateGroundpoly(storage);
     
@@ -170,7 +179,13 @@ void PrimeTower::generatePaths3(SliceDataStorage& storage)
         std::vector<Polygons>& patterns = patterns_per_extruder.back();
         for (int pattern_idx = 0; pattern_idx < n_patterns; pattern_idx++)
         {
-            generateLineInfill(ground_poly, -line_width/2, patterns[pattern_idx], line_width, line_width, infill_overlap, 45 + pattern_idx*90);
+            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_lines = patterns[pattern_idx];
+            Infill infill_comp(EFillMethod::LINES, ground_poly, outline_offset, line_width, line_distance, infill_overlap, fill_angle);
+            infill_comp.generate(result_polygons, result_lines);
         }
     }
 }
@@ -179,9 +194,7 @@ void PrimeTower::generatePaths3(SliceDataStorage& storage)
 
 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 (!( storage.max_object_height_second_to_last_extruder >= 0 
-//         && storage.getSettingInMicrons("prime_tower_distance") > 0 
-        && storage.getSettingInMicrons("prime_tower_size") > 0) )
+    if (!( storage.max_object_height_second_to_last_extruder >= 0 && storage.getSettingInMicrons("prime_tower_size") > 0) )
     {
         return;
     }
@@ -218,10 +231,15 @@ void PrimeTower::addToGcode3(SliceDataStorage& storage, GCodePlanner& gcodeLayer
     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);
+    gcodeLayer.addLinesByOptimizer(pattern, &config, SpaceFillType::Lines);
     
     last_prime_tower_poly_printed[new_extruder] = layer_nr;
-    
+
+    if (CommandSocket::isInstantiated())
+    {
+        CommandSocket::getInstance()->sendPolygons(PrintFeatureType::Support, layer_nr, pattern, config.getLineWidth());
+    }
+
     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));

src/PrimeTower.h

@@ -1,7 +1,7 @@
 #ifndef PRIME_TOWER_H
 #define PRIME_TOWER_H
 
-#include "gcodeExport.h" // GCodePathConfig
+#include "GCodePathConfig.h"
 #include "MeshGroup.h"
 #include "utils/polygon.h" // Polygons
 
@@ -26,7 +26,8 @@ private:
         
     };
 public:
-    void setConfigs(MeshGroup* configs, std::vector<RetractionConfig>& retraction_config_per_extruder, int layer_thickness);
+    void initConfigs(MeshGroup* meshgroup, std::vector<RetractionConfig>& retraction_config_per_extruder);
+    void setConfigs(MeshGroup* configs, int layer_thickness);
     
     Polygons ground_poly;
     
@@ -44,10 +45,10 @@ public:
      * Generate the area where the prime tower 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 totalLayers The total number of layers 
+     * \param total_layers The total number of layers 
      */
-    void generatePaths(SliceDataStorage& storage, unsigned int totalLayers);
-    void generatePaths_OLD(SliceDataStorage& storage, unsigned int totalLayers);
+    void generatePaths(SliceDataStorage& storage, unsigned int total_layers);
+    void generatePaths_OLD(SliceDataStorage& storage, unsigned int total_layers);
 
     void computePrimeTowerMax(SliceDataStorage& storage);
     

src/PrintFeature.h

@@ -4,24 +4,23 @@
 namespace cura
 {
 
-enum class EPrintFeature : unsigned int
+enum class PrintFeatureType
 {
-    OUTER_WALL,
-    INNER_WALLS,
-    INFILL,
-    SKIN,
-    HELPERS,
-    UNCLASSIFIED,
-    ENUM_COUNT
+    NoneType, // unused, but libArcus depends on it
+    OuterWall,
+    InnerWall,
+    Skin,
+    Support,
+    Skirt,
+    Infill,
+    SupportInfill,
+    MoveCombing,
+    MoveRetraction
 };
 
 
 
 
-
-
-
-
 } // namespace cura
 
 #endif // PRINT_FEATURE

src/RetractionConfig.h

@@ -0,0 +1,28 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#ifndef RETRACTION_CONFIG_H
+#define RETRACTION_CONFIG_H
+
+
+namespace cura 
+{
+
+/*!
+ * The retraction configuration used in the GCodePathConfig of each feature (and the travel config)
+ */
+class RetractionConfig
+{
+public:
+    double distance; //!< The distance retracted (in mm)
+    double speed; //!< The speed with which to retract (in mm/s)
+    double primeSpeed; //!< the speed with which to unretract (in mm/s)
+    double prime_volume; //!< the amount of material primed after unretracting (in mm^3)
+    int zHop; //!< the amount with which to lift the head during a retraction-travel
+    int retraction_min_travel_distance; //!< Minimal distance traversed to even consider retracting (in micron)
+    double retraction_extrusion_window; //!< Window of mm extruded filament in which to limit the amount of retractions
+    int retraction_count_max; //!< The maximum amount of retractions allowed to occur in the RetractionConfig::retraction_extrusion_window
+};
+
+
+}//namespace cura
+
+#endif // RETRACTION_CONFIG_H

src/SpaceFillType.h

@@ -0,0 +1,25 @@
+#ifndef SPACE_FILL_TYPE
+#define SPACE_FILL_TYPE
+
+
+namespace cura
+{
+
+/*!
+ * Enum class enumerating the strategies with which an area can be occupied with filament
+ * 
+ * The walls/perimeters are Polygons
+ * ZigZag infill is PolyLines, and so is following mesh surface mode for non-polygon surfaces
+ * Grid, Triangles and lines infill is Lines
+ */
+enum class SpaceFillType
+{
+    None,
+    Polygons,
+    PolyLines,
+    Lines
+};
+
+} // namespace cura
+
+#endif // SPACE_FILL_TYPE

src/WallsComputation.cpp

@@ -0,0 +1,79 @@
+/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
+#include "WallsComputation.h"
+#include "utils/polygonUtils.h"
+namespace cura {
+
+WallsComputation::WallsComputation(int wall_0_inset, int line_width_0, int line_width_x, int insetCount, bool recompute_outline_based_on_outer_wall)
+: wall_0_inset(wall_0_inset)
+, line_width_0(line_width_0)
+, line_width_x(line_width_x)
+, insetCount(insetCount)
+, recompute_outline_based_on_outer_wall(recompute_outline_based_on_outer_wall)
+{
+}
+
+void WallsComputation::generateInsets(SliceLayerPart* part)
+{
+    if (insetCount == 0)
+    {
+        part->insets.push_back(part->outline);
+        part->print_outline = part->outline;
+        return;
+    }
+    
+    for(int i=0; i<insetCount; i++)
+    {
+        part->insets.push_back(Polygons());
+        if (i == 0)
+        {
+            part->insets[0] = part->outline.offset(-line_width_0 / 2 - wall_0_inset);
+        } else if (i == 1)
+        {
+            part->insets[1] = part->insets[0].offset(-line_width_0 / 2 + wall_0_inset - line_width_x / 2);
+        } else
+        {
+            part->insets[i] = part->insets[i-1].offset(-line_width_x);
+        }
+        
+        
+        //Finally optimize all the polygons. Every point removed saves time in the long run.
+        part->insets[i].simplify();
+        if (i == 0)
+        {
+            if (recompute_outline_based_on_outer_wall)
+            {
+                part->print_outline = part->insets[0].offset(line_width_0 / 2);
+            }
+            else
+            {
+                part->print_outline = part->outline;
+            }
+        }
+        if (part->insets[i].size() < 1)
+        {
+            part->insets.pop_back();
+            break;
+        }
+    }
+}
+
+void WallsComputation::generateInsets(SliceLayer* layer)
+{
+    for(unsigned int partNr = 0; partNr < layer->parts.size(); partNr++)
+    {
+        generateInsets(&layer->parts[partNr]);
+    }
+    
+    //Remove the parts which did not generate an inset. As these parts are too small to print,
+    // and later code can now assume that there is always minimal 1 inset line.
+    for(unsigned int partNr = 0; partNr < layer->parts.size(); partNr++)
+    {
+        if (layer->parts[partNr].insets.size() < 1)
+        {
+            layer->parts.erase(layer->parts.begin() + partNr);
+            partNr -= 1;
+        }
+    }
+}
+
+}//namespace cura

src/WallsComputation.h

@@ -0,0 +1,69 @@
+/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
+#ifndef INSET_H
+#define INSET_H
+
+#include "sliceDataStorage.h"
+
+namespace cura 
+{
+
+/*!
+ * Function container for computing the outer walls / insets / perimeters polygons of a layer
+ */
+class WallsComputation
+{
+public:
+    /*!
+     * The offset applied to the outer wall
+     */
+    int wall_0_inset;
+    /*!
+     * line width of the outer wall
+     */
+    int line_width_0;
+    /*!
+     * line width of other walls
+     */
+    int line_width_x;
+    /*!
+     * The number of insets to to generate
+     */
+    int insetCount;
+    /*!
+     * Whether to compute a more accurate poly representation of the printed outlines, based on the outer wall
+     */
+    bool recompute_outline_based_on_outer_wall;
+
+    /*!
+     * Basic constructor initializing the parameters with which to perform the walls computation
+     * 
+     * \param wall_0_inset The offset applied to the outer wall
+     * \param line_width_0 line width of the outer wall
+     * \param line_width_x line width of other walls
+     * \param insetCount The number of insets to to generate
+     * \param recompute_outline_based_on_outer_wall Whether to compute a more accurate poly representation of the printed outlines, based on the outer wall
+     */
+    WallsComputation(int wall_0_inset, int line_width_0, int line_width_x, int insetCount, bool recompute_outline_based_on_outer_wall);
+
+    /*!
+     * Generates the insets / perimeters for all parts in a layer.
+     * 
+     * Note that the second inset gets offsetted by WallsComputation::line_width_0 instead of the first, 
+     * which leads to better results for a smaller WallsComputation::line_width_0 than WallsComputation::line_width_x and when printing the outer wall last.
+     * 
+     * \param layer The layer for which to generate the insets.
+     */ 
+    void generateInsets(SliceLayer* layer);
+
+private:
+    /*!
+     * Generates the insets / perimeters for a single layer part.
+     * 
+     * \param part The part for which to generate the insets.
+     */
+    void generateInsets(SliceLayerPart* part);
+
+};
+}//namespace cura
+
+#endif//INSET_H

src/Weaver.cpp

@@ -4,13 +4,14 @@
 #include <fstream> // debug IO
 #include <unistd.h>
 
-#include "Progress.h"
+#include "progress/Progress.h"
 #include "weaveDataStorage.h"
+#include "PrintFeature.h"
 
 namespace cura 
 {
 
-void Weaver::weave(MeshGroup* meshgroup, CommandSocket* commandSocket)
+void Weaver::weave(MeshGroup* meshgroup)
 {   
     wireFrame.meshgroup = meshgroup;
     
@@ -28,14 +29,13 @@ void Weaver::weave(MeshGroup* meshgroup, CommandSocket* commandSocket)
         slicerList.push_back(slicer);
     }
 
-    
     int starting_layer_idx;
     { // find first non-empty layer
         for (starting_layer_idx = 0; starting_layer_idx < layer_count; starting_layer_idx++)
         {
             Polygons parts;
             for (cura::Slicer* slicer : slicerList)
-                parts.add(slicer->layers[starting_layer_idx].polygonList);  
+                parts.add(slicer->layers[starting_layer_idx].polygons);  
             
             if (parts.size() > 0)
                 break;
@@ -51,12 +51,19 @@ void Weaver::weave(MeshGroup* meshgroup, CommandSocket* commandSocket)
     {
         int starting_z = -1;
         for (cura::Slicer* slicer : slicerList)
-            wireFrame.bottom_outline.add(slicer->layers[starting_layer_idx].polygonList);
+            wireFrame.bottom_outline.add(slicer->layers[starting_layer_idx].polygons);
         
-        if (commandSocket)
-            commandSocket->sendPolygons(Inset0Type, 0, wireFrame.bottom_outline, 1);
+        if (CommandSocket::isInstantiated())
+            CommandSocket::getInstance()->sendPolygons(PrintFeatureType::OuterWall, 0, wireFrame.bottom_outline, 1);
         
-        wireFrame.z_bottom = slicerList[0]->layers[starting_layer_idx].z;
+        if (slicerList.empty()) //Wait, there is nothing to slice.
+        {
+            wireFrame.z_bottom = 0;
+        }
+        else
+        {
+            wireFrame.z_bottom = slicerList[0]->layers[starting_layer_idx].z;
+        }
         
         Point starting_point_in_layer;
         if (wireFrame.bottom_outline.size() > 0)
@@ -64,23 +71,24 @@ void Weaver::weave(MeshGroup* meshgroup, CommandSocket* commandSocket)
         else 
             starting_point_in_layer = (Point(0,0) + meshgroup->max() + meshgroup->min()) / 2;
         
-        Progress::messageProgressStage(Progress::Stage::INSET, nullptr, commandSocket);
+        Progress::messageProgressStage(Progress::Stage::INSET_SKIN, nullptr);
         for (int layer_idx = starting_layer_idx + 1; layer_idx < layer_count; layer_idx++)
         {
-            Progress::messageProgress(Progress::Stage::INSET, layer_idx+1, layer_count, commandSocket); // abuse the progress system of the normal mode of CuraEngine
+            Progress::messageProgress(Progress::Stage::INSET_SKIN, layer_idx+1, layer_count); // abuse the progress system of the normal mode of CuraEngine
             
             Polygons parts1;
             for (cura::Slicer* slicer : slicerList)
-                parts1.add(slicer->layers[layer_idx].polygonList);
+                parts1.add(slicer->layers[layer_idx].polygons);
 
             
             Polygons chainified;
 
             chainify_polygons(parts1, starting_point_in_layer, chainified, false);
             
-            if (commandSocket)
-                commandSocket->sendPolygons(Inset0Type, 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;
@@ -101,10 +109,10 @@ void Weaver::weave(MeshGroup* meshgroup, CommandSocket* commandSocket)
     {
         Polygons* lower_top_parts = &wireFrame.bottom_outline;
         
-        Progress::messageProgressStage(Progress::Stage::SKIN, nullptr, commandSocket);
+        Progress::messageProgressStage(Progress::Stage::SUPPORT, nullptr);
         for (unsigned int layer_idx = 0; layer_idx < wireFrame.layers.size(); layer_idx++)
         {
-            Progress::messageProgress(Progress::Stage::SKIN, layer_idx+1, wireFrame.layers.size(), commandSocket); // abuse the progress system of the normal mode of CuraEngine
+            Progress::messageProgress(Progress::Stage::SUPPORT, layer_idx+1, wireFrame.layers.size()); // abuse the progress system of the normal mode of CuraEngine
             
             WeaveLayer& layer = wireFrame.layers[layer_idx];
             
@@ -136,16 +144,21 @@ void Weaver::weave(MeshGroup* meshgroup, CommandSocket* commandSocket)
 
 
     { // roofs:
-        
-        WeaveLayer& top_layer = wireFrame.layers.back();
-        Polygons to_be_supported; // empty for the top layer
-        fillRoofs(top_layer.supported, to_be_supported, -1, top_layer.z1, top_layer.roofs);
+        if (!wireFrame.layers.empty()) //If there are no layers, create no roof.
+        {
+            WeaveLayer& top_layer = wireFrame.layers.back();
+            Polygons to_be_supported; // empty for the top layer
+            fillRoofs(top_layer.supported, to_be_supported, -1, top_layer.z1, top_layer.roofs);
+        }
     }
     
     
     { // bottom:
-        Polygons to_be_supported; // is empty for the bottom layer, cause the order of insets doesn't really matter (in a sense everything is to be supported)
-        fillRoofs(wireFrame.bottom_outline, to_be_supported, -1, wireFrame.layers.front().z0, wireFrame.bottom_infill);
+        if (!wireFrame.layers.empty()) //If there are no layers, create no bottom.
+        {
+            Polygons to_be_supported; // is empty for the bottom layer, cause the order of insets doesn't really matter (in a sense everything is to be supported)
+            fillRoofs(wireFrame.bottom_outline, to_be_supported, -1, wireFrame.layers.front().z0, wireFrame.bottom_infill);
+        }
     }
     
 }
@@ -390,9 +403,9 @@ void Weaver::chainify_polygons(Polygons& parts1, Point start_close_to, Polygons&
         bool found = true;
         int idx = 0;
         
-        for (Point upper_point = upperPart[closestInPoly.pos]; found; upper_point = next_upper.location)
+        for (Point upper_point = upperPart[closestInPoly.point_idx]; found; upper_point = next_upper.location)
         {
-            found = PolygonUtils::getNextPointWithDistance(upper_point, nozzle_top_diameter, upperPart, idx, closestInPoly.pos, next_upper);
+            found = PolygonUtils::getNextPointWithDistance(upper_point, nozzle_top_diameter, upperPart, idx, closestInPoly.point_idx, next_upper);
 
             
             if (!found) 

src/Weaver.h

@@ -3,11 +3,12 @@
 
 #include "weaveDataStorage.h"
 #include "commandSocket.h"
-#include "settings.h"
+#include "settings/settings.h"
 
 #include "MeshGroup.h"
 #include "slicer.h"
 
+#include "utils/NoCopy.h"
 #include "utils/polygon.h"
 #include "utils/polygonUtils.h"
 
@@ -19,7 +20,7 @@ namespace cura
 /*!
  * The main weaver / WirePrint / wireframe printing class, which computes the basic paths to be followed.
  */
-class Weaver : public SettingsMessenger
+class Weaver : public SettingsMessenger, NoCopy
 {
     friend class Wireframe2gcode;
 private:
@@ -60,9 +61,8 @@ public:
      * Creates a wireframe for the model consisting of horizontal 'flat' parts and connections between consecutive flat parts consisting of UP moves and diagonally DOWN moves.
      * 
      * \param objects The objects for which to create a wireframe print
-     * \param commandSocket the commandSocket
      */
-    void weave(MeshGroup* objects, CommandSocket* commandSocket);
+    void weave(MeshGroup* objects);
     
 
 private:

src/Wireframe2gcode.cpp

@@ -4,7 +4,7 @@
 #include <fstream> // debug IO
 
 #include "weaveDataStorage.h"
-#include "Progress.h"
+#include "progress/Progress.h"
 
 #include "pathOrderOptimizer.h" // for skirt
 
@@ -12,24 +12,34 @@ namespace cura
 {
 
 
-void Wireframe2gcode::writeGCode(CommandSocket* commandSocket)
+void Wireframe2gcode::writeGCode()
 {
 
     gcode.preSetup(wireFrame.meshgroup);
     
-    if (commandSocket)
-        commandSocket->beginGCode();
+    gcode.setInitialTemps(wireFrame.meshgroup);
     
-    processStartingCode(commandSocket);
+    if (CommandSocket::getInstance())
+        CommandSocket::getInstance()->beginGCode();
     
-    int maxObjectHeight = wireFrame.layers.back().z1;
+    processStartingCode();
     
-    processSkirt(commandSocket);
+    int maxObjectHeight;
+    if (wireFrame.layers.empty())
+    {
+        maxObjectHeight = 0;
+    }
+    else
+    {
+        maxObjectHeight = wireFrame.layers.back().z1;
+    }
+    
+    processSkirt();
     
             
-    unsigned int totalLayers = wireFrame.layers.size();
+    unsigned int total_layers = wireFrame.layers.size();
     gcode.writeLayerComment(0);
-    gcode.writeTypeComment("SKIRT");
+    gcode.writeTypeComment(PrintFeatureType::Skirt);
 
     gcode.setZ(initial_layer_thickness);
     
@@ -68,10 +78,10 @@ void Wireframe2gcode::writeGCode(CommandSocket* commandSocket)
                         gcode.writeMove(segment.to, speedBottom, extrusion_per_mm_flat); 
                 }
             );
-    Progress::messageProgressStage(Progress::Stage::EXPORT, nullptr, commandSocket);
+    Progress::messageProgressStage(Progress::Stage::EXPORT, nullptr);
     for (unsigned int layer_nr = 0; layer_nr < wireFrame.layers.size(); layer_nr++)
     {
-        Progress::messageProgress(Progress::Stage::EXPORT, layer_nr+1, totalLayers, commandSocket); // abuse the progress system of the normal mode of CuraEngine
+        Progress::messageProgress(Progress::Stage::EXPORT, layer_nr+1, total_layers); // abuse the progress system of the normal mode of CuraEngine
         
         WeaveLayer& layer = wireFrame.layers[layer_nr];
         
@@ -88,7 +98,7 @@ void Wireframe2gcode::writeGCode(CommandSocket* commandSocket)
        
             if (part.connection.segments.size() == 0) continue;
             
-            gcode.writeTypeComment("SUPPORT"); // connection
+            gcode.writeTypeComment(PrintFeatureType::Support); // connection
             {
                 if (vSize2(gcode.getPositionXY() - part.connection.from) > connectionHeight)
                 {
@@ -104,7 +114,7 @@ void Wireframe2gcode::writeGCode(CommandSocket* commandSocket)
             
             
             
-            gcode.writeTypeComment("WALL-OUTER"); // top
+            gcode.writeTypeComment(PrintFeatureType::OuterWall); // top
             {
                 for (unsigned int segment_idx = 0; segment_idx < part.connection.segments.size(); segment_idx++)
                 {
@@ -157,13 +167,7 @@ void Wireframe2gcode::writeGCode(CommandSocket* commandSocket)
     
     gcode.writeFanCommand(0);
 
-    finalize(maxObjectHeight);
-    
-    if (commandSocket)
-    {
-        commandSocket->sendGCodeLayer();
-        commandSocket->endSendSlicedObject();
-    }
+    finalize();
 }
 
     
@@ -231,11 +235,14 @@ void Wireframe2gcode::strategy_retract(WeaveLayer& layer, WeaveConnectionPart& p
     
     RetractionConfig retraction_config;
     // TODO: get these from the settings!
-    retraction_config.amount = 500; //INT2MM(getSettingInt("retraction_amount"))
-    retraction_config.primeAmount = 0;//INT2MM(getSettingInt("retractionPrime
+    retraction_config.distance = 500; //INT2MM(getSettingInt("retraction_amount"))
+    retraction_config.prime_volume = 0;//INT2MM(getSettingInt("retractionPrime
     retraction_config.speed = 20; // 40;
     retraction_config.primeSpeed = 15; // 30;
     retraction_config.zHop = 0; //getSettingInt("retraction_hop");
+    retraction_config.retraction_count_max = getSettingAsCount("retraction_count_max");
+    retraction_config.retraction_extrusion_window = getSettingInMillimeters("retraction_extrusion_window");
+    retraction_config.retraction_min_travel_distance = getSettingInMicrons("retraction_min_travel");
 
     double top_retract_pause = 2.0;
     int retract_hop_dist = 1000;
@@ -399,7 +406,7 @@ void Wireframe2gcode::writeFill(std::vector<WeaveRoofPart>& infill_insets, Polyg
 {
         
     // bottom:
-    gcode.writeTypeComment("FILL");
+    gcode.writeTypeComment(PrintFeatureType::Infill);
     for (unsigned int inset_idx = 0; inset_idx < infill_insets.size(); inset_idx++)
     {
         WeaveRoofPart& inset = infill_insets[inset_idx];
@@ -410,7 +417,7 @@ void Wireframe2gcode::writeFill(std::vector<WeaveRoofPart>& infill_insets, Polyg
             WeaveConnectionPart& inset_part = inset.connections[inset_part_nr];
             std::vector<WeaveConnectionSegment>& segments = inset_part.connection.segments;
             
-            gcode.writeTypeComment("SUPPORT"); // connection
+            gcode.writeTypeComment(PrintFeatureType::Support); // connection
             if (segments.size() == 0) continue;
             Point3 first_extrusion_from = inset_part.connection.from;
             unsigned int first_segment_idx;
@@ -426,7 +433,7 @@ void Wireframe2gcode::writeFill(std::vector<WeaveRoofPart>& infill_insets, Polyg
                 connectionHandler(*this, inset, inset_part, segment_idx);
             }
             
-            gcode.writeTypeComment("WALL-INNER"); // top
+            gcode.writeTypeComment(PrintFeatureType::InnerWall); // top
             for (unsigned int segment_idx = 0; segment_idx < segments.size(); segment_idx++)
             {
                 WeaveConnectionSegment& segment = segments[segment_idx];
@@ -440,7 +447,7 @@ void Wireframe2gcode::writeFill(std::vector<WeaveRoofPart>& infill_insets, Polyg
         
     }
     
-    gcode.writeTypeComment("WALL-OUTER"); // outer perimeter of the flat parts
+    gcode.writeTypeComment(PrintFeatureType::OuterWall); // outer perimeter of the flat parts
     for (PolygonRef poly : roof_outlines)
     {
         writeMoveWithRetract(poly[poly.size() - 1]);
@@ -473,8 +480,8 @@ void Wireframe2gcode::writeMoveWithRetract(Point to)
 Wireframe2gcode::Wireframe2gcode(Weaver& weaver, GCodeExport& gcode, SettingsBase* settings_base) 
 : SettingsMessenger(settings_base) 
 , gcode(gcode)
+, wireFrame(weaver.wireFrame)
 {
-    wireFrame = weaver.wireFrame;
     initial_layer_thickness = getSettingInMicrons("layer_height_0");
     connectionHeight = getSettingInMicrons("wireframe_height"); 
     roof_inset = getSettingInMicrons("wireframe_roof_inset"); 
@@ -529,33 +536,42 @@ Wireframe2gcode::Wireframe2gcode(Weaver& weaver, GCodeExport& gcode, SettingsBas
     roof_outer_delay = getSettingInSeconds("wireframe_roof_outer_delay");
     
     
-    standard_retraction_config.amount = INT2MM(getSettingInMicrons("retraction_amount"));
-    standard_retraction_config.primeAmount = INT2MM(getSettingInMicrons("retraction_extra_prime_amount"));
+    standard_retraction_config.distance = getSettingInMillimeters("retraction_amount");
+    standard_retraction_config.prime_volume = getSettingInCubicMillimeters("retraction_extra_prime_amount");
     standard_retraction_config.speed = getSettingInMillimetersPerSecond("retraction_retract_speed");
     standard_retraction_config.primeSpeed = getSettingInMillimetersPerSecond("retraction_prime_speed");
     standard_retraction_config.zHop = getSettingInMicrons("retraction_hop");
-
-
+    standard_retraction_config.retraction_count_max = getSettingAsCount("retraction_count_max");
+    standard_retraction_config.retraction_extrusion_window = getSettingInMillimeters("retraction_extrusion_window");
+    standard_retraction_config.retraction_min_travel_distance = getSettingInMicrons("retraction_min_travel");
 }
 
-void Wireframe2gcode::processStartingCode(CommandSocket* command_socket)
+void Wireframe2gcode::processStartingCode()
 {
-    if (gcode.getFlavor() == EGCodeFlavor::ULTIGCODE)
+    if (!CommandSocket::isInstantiated())
     {
-        if (!command_socket)
-        {
-            gcode.writeCode(";FLAVOR:UltiGCode\n;TIME:666\n;MATERIAL:666\n;MATERIAL2:-1\n");
-        }
+        gcode.writeCode(gcode.getFileHeader().c_str());
     }
     else 
     {
-        if (getSettingBoolean("machine_heated_bed") && getSettingInDegreeCelsius("material_bed_temperature") > 0)
-            gcode.writeBedTemperatureCommand(getSettingInDegreeCelsius("material_bed_temperature"), true);
-        
-        if (getSettingInDegreeCelsius("material_print_temperature") > 0)
+        if (getSettingBoolean("material_bed_temp_prepend"))
         {
-            gcode.writeTemperatureCommand(getSettingAsIndex("extruder_nr"), getSettingInDegreeCelsius("material_print_temperature"));
-            gcode.writeTemperatureCommand(getSettingAsIndex("extruder_nr"), getSettingInDegreeCelsius("material_print_temperature"), true);
+            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"))
+        {
+            if (getSettingInDegreeCelsius("material_print_temperature") > 0)
+            {
+                gcode.writeTemperatureCommand(getSettingAsIndex("extruder_nr"), getSettingInDegreeCelsius("material_print_temperature"));
+                if (getSettingBoolean("machine_print_temp_wait"))
+                {
+                    gcode.writeTemperatureCommand(getSettingAsIndex("extruder_nr"), getSettingInDegreeCelsius("material_print_temperature"), true);
+                }
+            }
         }
         
     }
@@ -572,30 +588,34 @@ void Wireframe2gcode::processStartingCode(CommandSocket* command_socket)
 }
 
 
-void Wireframe2gcode::processSkirt(CommandSocket* commandSocket)
+void Wireframe2gcode::processSkirt()
 {
+    if (wireFrame.bottom_outline.size() == 0) //If we have no layers, don't create a skirt either.
+    {
+        return;
+    }
     Polygons skirt = wireFrame.bottom_outline.offset(100000+5000).offset(-100000);
-    PathOrderOptimizer order(gcode.getStartPositionXY());
+    PathOrderOptimizer order(Point(INT32_MIN, INT32_MIN));
     order.addPolygons(skirt);
     order.optimize();
     
-    for (unsigned int poly_idx = 0; poly_idx < skirt.size(); poly_idx++)
+    for (unsigned int poly_order_idx = 0; poly_order_idx < skirt.size(); poly_order_idx++)
     {
-        unsigned int actual_poly_idx = order.polyOrder[poly_idx];
-        PolygonRef poly = skirt[actual_poly_idx];
-        gcode.writeMove(poly[order.polyStart[actual_poly_idx]], getSettingInMillimetersPerSecond("speed_travel"), 0);
+        unsigned int poly_idx = order.polyOrder[poly_order_idx];
+        PolygonRef poly = skirt[poly_idx];
+        gcode.writeMove(poly[order.polyStart[poly_idx]], getSettingInMillimetersPerSecond("speed_travel"), 0);
         for (unsigned int point_idx = 0; point_idx < poly.size(); point_idx++)
         {
-            Point& p = poly[(point_idx + order.polyStart[actual_poly_idx] + 1) % poly.size()];
+            Point& p = poly[(point_idx + order.polyStart[poly_idx] + 1) % poly.size()];
             gcode.writeMove(p, getSettingInMillimetersPerSecond("skirt_speed"), getSettingInMillimetersPerSecond("skirt_line_width"));
         }
     }
 }
 
 
-void Wireframe2gcode::finalize(int maxObjectHeight)
+void Wireframe2gcode::finalize()
 {
-    gcode.finalize(maxObjectHeight, getSettingInMillimetersPerSecond("speed_travel"), getSettingString("machine_end_gcode").c_str());
+    gcode.finalize(getSettingString("machine_end_gcode").c_str());
     for(int e=0; e<getSettingAsCount("machine_extruder_count"); e++)
         gcode.writeTemperatureCommand(e, 0, false);
 }

src/Wireframe2gcode.h

@@ -4,9 +4,11 @@
 
 #include <functional> // passing function pointer or lambda as argument to a function
 
+#include "utils/NoCopy.h"
+
 #include "weaveDataStorage.h"
 #include "commandSocket.h"
-#include "settings.h"
+#include "settings/settings.h"
 
 #include "MeshGroup.h"
 #include "slicer.h"
@@ -22,7 +24,7 @@ namespace cura
 /*!
  * Export class for exporting wireframe print gcode / weaver gcode / wireprint gcode.
  */
-class Wireframe2gcode : public SettingsMessenger
+class Wireframe2gcode : public SettingsMessenger, NoCopy
 {
 private:
     static const int STRATEGY_COMPENSATE = 0;
@@ -69,26 +71,26 @@ public:
     
     Wireframe2gcode(Weaver& weaver, GCodeExport& gcode, SettingsBase* settings_base);
     
-    void writeGCode(CommandSocket* commandSocket);
+    void writeGCode();
 
 
 private:
-    WireFrame wireFrame;
+    WireFrame& wireFrame;
     
     /*!
      * Startup gcode: nozzle temp up, retraction settings, bed temp
      */
-    void processStartingCode(CommandSocket* command_socket);
+    void processStartingCode();
     
     /*!
      * Lay down a skirt
      */
-    void processSkirt(CommandSocket* commandSocket);
+    void processSkirt();
     
     /*!
      * End gcode: nozzle temp down
      */
-    void finalize(int maxObjectHeight);
+    void finalize();
     
     void writeFill(std::vector<WeaveRoofPart>& infill_insets, Polygons& outlines
         , std::function<void (Wireframe2gcode& thiss, WeaveRoofPart& inset, WeaveConnectionPart& part, unsigned int segment_idx)> connectionHandler

src/comb.cpp

@@ -1,385 +0,0 @@
-/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
-#include "comb.h"
-
-#include <algorithm>
-
-#include "utils/polygonUtils.h"
-#include "sliceDataStorage.h"
-
-namespace cura {
-
-bool Comb::moveInsideBoundary(Point* p, int distance)
-{
-    return PolygonUtils::moveInside(boundary_inside, *p, distance) != NO_INDEX;
-}
-
-Polygons Comb::getLayerSecondWalls()
-{
-    Polygons layer_walls;
-    for (SliceMeshStorage& mesh : storage.meshes)
-    {
-        for (SliceLayerPart& part : mesh.layers[layer_nr].parts)
-        {
-            if (part.insets.size() >= 2)
-            {
-                layer_walls.add(part.insets[1]);
-            }
-            else 
-            {
-                layer_walls.add(part.outline.offset(-offset_from_outlines));
-            }
-        }
-    }
-    return layer_walls;
-}
-  
-// 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;
-}
-  
-Comb::Comb(SliceDataStorage& storage, unsigned int layer_nr, 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
-, max_moveInside_distance2(offset_from_outlines * 2 * offset_from_outlines * 2)
-, offset_from_outlines_outside(travel_avoid_distance)
-, avoid_other_parts(travel_avoid_other_parts)
-// , boundary_inside( boundary.offset(-offset_from_outlines) ) // TODO: make inside boundary configurable?
-, boundary_inside( getLayerSecondWalls() )
-, boundary_outside(nullptr)
-, partsView_inside( boundary_inside.splitIntoPartsView() ) // !! changes the order of boundary_inside !!
-{
-}
-
-Comb::~Comb()
-{
-    if (boundary_outside)
-        delete boundary_outside;
-}
-
-bool Comb::calc(Point startPoint, Point endPoint, CombPaths& combPaths, bool startInside, bool endInside)
-{
-    if (shorterThen(endPoint - startPoint, max_comb_distance_ignored))
-    {
-        return true;
-    }
-    
-
-    
-    //Move start and end point inside the comb boundary
-    unsigned int start_inside_poly = NO_INDEX;
-    if (startInside) 
-    {
-        start_inside_poly = PolygonUtils::moveInside(boundary_inside, startPoint, offset_extra_start_end, max_moveInside_distance2);
-        if (!inside(start_inside_poly) || start_inside_poly == NO_INDEX)
-        {
-            if (start_inside_poly != NO_INDEX)
-            { // if not yet inside because of overshoot, try again
-                start_inside_poly = PolygonUtils::moveInside(boundary_inside, startPoint, offset_extra_start_end, max_moveInside_distance2);
-            }
-            if (start_inside_poly == NO_INDEX)    //If we fail to move the point inside the comb boundary we need to retract.
-            {
-                startInside = false;
-            }
-        }
-    }
-    unsigned int end_inside_poly = NO_INDEX;
-    if (endInside)
-    {
-        end_inside_poly = PolygonUtils::moveInside(boundary_inside, endPoint, offset_extra_start_end, max_moveInside_distance2);
-        if (!inside(endPoint) || end_inside_poly == NO_INDEX)
-        {
-            if (end_inside_poly != NO_INDEX)
-            { // if not yet inside because of overshoot, try again
-                end_inside_poly = PolygonUtils::moveInside(boundary_inside, endPoint, offset_extra_start_end, max_moveInside_distance2);
-            }
-            if (end_inside_poly == NO_INDEX)    //If we fail to move the point inside the comb boundary we need to retract.
-            {
-                endInside = false;
-            }
-        }
-    }
-
-    
-    unsigned int start_part_boundary_poly_idx;
-    unsigned int end_part_boundary_poly_idx;
-    unsigned int start_part_idx =   (start_inside_poly == NO_INDEX)?    NO_INDEX : partsView_inside.getPartContaining(start_inside_poly, &start_part_boundary_poly_idx);
-    unsigned int end_part_idx =     (end_inside_poly == NO_INDEX)?      NO_INDEX : partsView_inside.getPartContaining(end_inside_poly, &end_part_boundary_poly_idx);
-    
-    if (startInside && endInside && start_part_idx == end_part_idx)
-    { // normal combing within part
-        PolygonsPart part = partsView_inside.assemblePart(start_part_idx);
-        combPaths.emplace_back();
-        LinePolygonsCrossings::comb(part, startPoint, endPoint, combPaths.back(), -offset_dist_to_get_from_on_the_polygon_to_outside);
-        return true;
-    }
-    else 
-    { // comb inside part to edge (if needed) >> move through air avoiding other parts >> comb inside end part upto the endpoint (if needed) 
-        Point middle_from;
-        Point middle_to;
-        
-        if (startInside && endInside)
-        {
-            ClosestPolygonPoint middle_from_cp = PolygonUtils::findClosest(endPoint, boundary_inside[start_part_boundary_poly_idx]);
-            ClosestPolygonPoint middle_to_cp = PolygonUtils::findClosest(middle_from_cp.location, boundary_inside[end_part_boundary_poly_idx]);
-//             walkToNearestSmallestConnection(middle_from_cp, middle_to_cp); // TODO: perform this optimization?
-            middle_from = middle_from_cp.location;
-            middle_to = middle_to_cp.location;
-        }
-        else 
-        {
-            if (!startInside && !endInside) 
-            { 
-                middle_from = startPoint; 
-                middle_to = endPoint; 
-            }
-            else if (!startInside && endInside)
-            {
-                middle_from = startPoint;
-                ClosestPolygonPoint middle_to_cp = PolygonUtils::findClosest(middle_from, boundary_inside[end_part_boundary_poly_idx]);
-                middle_to = middle_to_cp.location;
-            }
-            else if (startInside && !endInside)
-            {
-                middle_to = endPoint;
-                ClosestPolygonPoint middle_from_cp = PolygonUtils::findClosest(middle_to, boundary_inside[start_part_boundary_poly_idx]);
-                middle_from = middle_from_cp.location;
-            }
-        }
-        
-        if (startInside)
-        {
-            // start to boundary
-            PolygonsPart part_begin = partsView_inside.assemblePart(start_part_idx); // comb through the starting part only
-            combPaths.emplace_back();
-            LinePolygonsCrossings::comb(part_begin, startPoint, middle_from, combPaths.back(), -offset_dist_to_get_from_on_the_polygon_to_outside);
-        }
-        
-        // throught air from boundary to boundary
-        if (avoid_other_parts)
-        {
-            Polygons& middle = *getBoundaryOutside(); // comb through all air, since generally the outside consists of a single part
-            Point from_outside = middle_from;
-            if (startInside || middle.inside(from_outside, true))
-            { // move outside
-                PolygonUtils::moveInside(middle, from_outside, -offset_extra_start_end, max_moveInside_distance2);
-            }
-            Point to_outside = middle_to;
-            if (endInside || middle.inside(to_outside, true))
-            { // move outside
-                PolygonUtils::moveInside(middle, to_outside, -offset_extra_start_end, max_moveInside_distance2);
-            }
-            combPaths.emplace_back();
-            combPaths.back().throughAir = true;
-            if ( vSize(middle_from - middle_to) < vSize(middle_from - from_outside) + vSize(middle_to - to_outside) )
-            { // via outside is a detour
-                combPaths.back().push_back(middle_from);
-                combPaths.back().push_back(middle_to);
-            }
-            else
-            {
-                LinePolygonsCrossings::comb(middle, from_outside, to_outside, combPaths.back(), offset_dist_to_get_from_on_the_polygon_to_outside);
-            }
-        }
-        else 
-        { // directly through air (not avoiding other parts)
-            combPaths.emplace_back();
-            combPaths.back().throughAir = true;
-            combPaths.back().cross_boundary = true; // TODO: calculate whether we cross a boundary!
-            combPaths.back().push_back(middle_from);
-            combPaths.back().push_back(middle_to);
-        }
-        
-        if (endInside)
-        {
-            // boundary to end
-            PolygonsPart part_end = partsView_inside.assemblePart(end_part_idx); // comb through end part only
-            combPaths.emplace_back();
-            LinePolygonsCrossings::comb(part_end, middle_to, endPoint, combPaths.back(), -offset_dist_to_get_from_on_the_polygon_to_outside);
-        }
-        
-        return true;
-    }
-}
-
-void LinePolygonsCrossings::calcScanlineCrossings()
-{
-    
-    min_crossing_idx = NO_INDEX;
-    max_crossing_idx = NO_INDEX;
-        
-    for(unsigned int poly_idx = 0; poly_idx < boundary.size(); poly_idx++)
-    {
-        PolyCrossings minMax(poly_idx); 
-        PolygonRef poly = boundary[poly_idx];
-        Point p0 = transformation_matrix.apply(poly.back());
-        for(unsigned int point_idx = 0; point_idx < poly.size(); point_idx++)
-        {
-            Point p1 = transformation_matrix.apply(poly[point_idx]);
-            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)
-                {
-                    if (x < minMax.min.x) { minMax.min.x = x; minMax.min.point_idx = point_idx; }
-                    if (x > minMax.max.x) { minMax.max.x = x; minMax.max.point_idx = point_idx; }
-                }
-            }
-            p0 = p1;
-        }
-        
-        if (minMax.min.point_idx != NO_INDEX)
-        { // then also max.point_idx != -1
-            if (min_crossing_idx == NO_INDEX || minMax.min.x < crossings[min_crossing_idx].min.x) { min_crossing_idx = crossings.size(); }
-            if (max_crossing_idx == NO_INDEX || minMax.max.x > crossings[max_crossing_idx].max.x) { max_crossing_idx = crossings.size(); }
-            crossings.push_back(minMax);
-        }
-        
-    }
-}
-
-
-bool LinePolygonsCrossings::lineSegmentCollidesWithBoundary()
-{
-    Point diff = endPoint - startPoint;
-
-    transformation_matrix = PointMatrix(diff);
-    transformed_startPoint = transformation_matrix.apply(startPoint);
-    transformed_endPoint = transformation_matrix.apply(endPoint);
-
-    for(PolygonRef poly : boundary)
-    {
-        Point p0 = transformation_matrix.apply(poly.back());
-        for(Point p1_ : poly)
-        {
-            Point p1 = transformation_matrix.apply(p1_);
-            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;
-        }
-    }
-    
-    return false;
-}
-
-
-void LinePolygonsCrossings::getCombingPath(CombPath& combPath)
-{
-    if (shorterThen(endPoint - startPoint, Comb::max_comb_distance_ignored) || !lineSegmentCollidesWithBoundary())
-    {
-        //We're not crossing any boundaries. So skip the comb generation.
-        combPath.push_back(startPoint); 
-        combPath.push_back(endPoint); 
-        return; 
-    }
-    
-    calcScanlineCrossings();
-    
-    CombPath basicPath;
-    getBasicCombingPath(basicPath);
-    optimizePath(basicPath, combPath);
-}
-
-
-void LinePolygonsCrossings::getBasicCombingPath(CombPath& combPath) 
-{
-    for (PolyCrossings* crossing = getNextPolygonAlongScanline(transformed_startPoint.X)
-        ; crossing != nullptr
-        ; crossing = getNextPolygonAlongScanline(crossing->max.x))
-    {
-        getBasicCombingPath(*crossing, combPath);
-    }
-    combPath.push_back(endPoint);
-}
-
-void LinePolygonsCrossings::getBasicCombingPath(PolyCrossings& polyCrossings, CombPath& combPath) 
-{
-    PolygonRef poly = boundary[polyCrossings.poly_idx];
-    combPath.push_back(transformation_matrix.unapply(Point(polyCrossings.min.x, 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
-        for(unsigned int point_idx = polyCrossings.min.point_idx
-            ; point_idx != polyCrossings.max.point_idx
-            ; point_idx = (point_idx < poly.size() - 1) ? (point_idx + 1) : (0))
-        {
-            combPath.push_back(PolygonUtils::getBoundaryPointWithOffset(poly, point_idx, dist_to_move_boundary_point_outside));
-        }
-    }
-    else
-    { // follow the path in the opposite direction of the winding order of the boundary polygon
-        unsigned int min_idx = (polyCrossings.min.point_idx == 0)? poly.size() - 1: polyCrossings.min.point_idx - 1;
-        unsigned int max_idx = (polyCrossings.max.point_idx == 0)? poly.size() - 1: polyCrossings.max.point_idx - 1;
-        
-        for(unsigned int point_idx = min_idx; point_idx != max_idx; point_idx = (point_idx > 0) ? (point_idx - 1) : (poly.size() - 1))
-        {
-            combPath.push_back(PolygonUtils::getBoundaryPointWithOffset(poly, point_idx, dist_to_move_boundary_point_outside));
-        }
-    }
-    combPath.push_back(transformation_matrix.unapply(Point(polyCrossings.max.x, transformed_startPoint.Y))); 
-}
-
-
-
-LinePolygonsCrossings::PolyCrossings* LinePolygonsCrossings::getNextPolygonAlongScanline(int64_t x)
-{
-    PolyCrossings* ret = nullptr;
-    for(PolyCrossings& crossing : crossings)
-    {
-        if (crossing.min.x > x && (ret == nullptr || crossing.min.x < ret->min.x) )
-        {
-            ret = &crossing;
-        }
-    }
-    return ret;
-}
-
-bool LinePolygonsCrossings::optimizePath(CombPath& comb_path, CombPath& optimized_comb_path) 
-{   
-    optimized_comb_path.push_back(startPoint);
-    for(unsigned int point_idx = 1; point_idx<comb_path.size(); point_idx++)
-    {
-        Point& current_point = optimized_comb_path.back();
-        if (PolygonUtils::polygonCollidesWithlineSegment(boundary, current_point, comb_path[point_idx]))
-        {
-            if (PolygonUtils::polygonCollidesWithlineSegment(boundary, current_point, comb_path[point_idx - 1]))
-            {
-                comb_path.cross_boundary = true;
-            }
-            optimized_comb_path.push_back(comb_path[point_idx - 1]);
-        }
-        else 
-        {
-            // : dont add the newest point
-            
-            // 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(boundary, optimized_comb_path[optimized_comb_path.size() - 2], comb_path[point_idx]))
-                {
-                    break;
-                }
-                else 
-                {
-                    optimized_comb_path.pop_back();
-                }
-            }
-        }
-    }
-    return true;
-}
-
-}//namespace cura

src/commandSocket.cpp

@@ -1,150 +1,291 @@
 #include "utils/logoutput.h"
 #include "commandSocket.h"
 #include "FffProcessor.h"
-#include "Progress.h"
+#include "progress/Progress.h"
 
 #include <thread>
 #include <cinttypes>
 
+#ifdef ARCUS
 #include <Arcus/Socket.h>
+#include <Arcus/SocketListener.h>
+#include <Arcus/Error.h>
+#endif
+
+#include <string> // stoi
 
 #ifdef _WIN32
 #include <windows.h>
 #endif
 
+#include "settings/SettingRegistry.h" // loadExtruderJSONsettings
+
+#define DEBUG_OUTPUT_OBJECT_STL_THROUGH_CERR(x) 
+
+// std::cerr << x;
+
 namespace cura {
 
 #define BYTES_PER_FLOAT 4
 #define FLOATS_PER_VECTOR 3
 #define VECTORS_PER_FACE 3
-    
+
+CommandSocket* CommandSocket::instance = nullptr; // instantiate instance
+
+#ifdef ARCUS
+class Listener : public Arcus::SocketListener
+{
+public:
+    void stateChanged(Arcus::SocketState::SocketState newState) override
+    {
+    }
+
+    void messageReceived() override
+    {
+    }
+
+    void error(const Arcus::Error & error) override
+    {
+        if (error.getErrorCode() == Arcus::ErrorCode::Debug)
+        {
+            log("%s\n", error.toString().c_str());
+        }
+        else
+        {
+            logError("%s\n", error.toString().c_str());
+        }
+    }
+};
+
 class CommandSocket::Private
 {
 public:
     Private()
         : socket(nullptr)
         , object_count(0)
-        , current_sliced_object(nullptr)
         , sliced_objects(0)
+        , current_layer_count(0)
+        , current_layer_offset(0)
     { }
 
-    cura::proto::Layer* getLayerById(int id);
+    std::shared_ptr<cura::proto::Layer> getLayerById(int id);
 
     Arcus::Socket* socket;
     
     // Number of objects that need to be sliced
     int object_count;
-    
-    // Message that holds a list of sliced objects
-    std::shared_ptr<cura::proto::SlicedObjectList> sliced_object_list;
-    
-    // Message that holds the currently sliced object (to be added to sliced_object_list)
-    cura::proto::SlicedObject* current_sliced_object;
-    
+
     // Number of sliced objects for this sliced object list
     int sliced_objects;
-    
-    // Ids of the sliced objects
-    std::vector<int64_t> object_ids;
+
+    // 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;
+
+    std::unordered_map<int, std::shared_ptr<cura::proto::Layer>> sliced_layers;
 };
+#endif
 
 CommandSocket::CommandSocket()
-    : d(new Private)
+#ifdef ARCUS
+    : private_data(new Private)
+#endif
 {
-    FffProcessor::getInstance()->setCommandSocket(this);
+#ifdef ARCUS
+#endif
 }
 
+CommandSocket* CommandSocket::getInstance()
+{
+    return instance;
+}
+
+void CommandSocket::instantiate()
+{
+    instance = new CommandSocket();
+}
+
+bool CommandSocket::isInstantiated()
+{
+    return instance != nullptr;
+}
+
+
 void CommandSocket::connect(const std::string& ip, int port)
 {
-    d->socket = new Arcus::Socket();
-    //d->socket->registerMessageType(1, &Cura::ObjectList::default_instance());
-    d->socket->registerMessageType(1, &cura::proto::Slice::default_instance());
-    d->socket->registerMessageType(2, &cura::proto::SlicedObjectList::default_instance());
-    d->socket->registerMessageType(3, &cura::proto::Progress::default_instance());
-    d->socket->registerMessageType(4, &cura::proto::GCodeLayer::default_instance());
-    d->socket->registerMessageType(5, &cura::proto::ObjectPrintTime::default_instance());
-    d->socket->registerMessageType(6, &cura::proto::SettingList::default_instance());
-    d->socket->registerMessageType(7, &cura::proto::GCodePrefix::default_instance());
+#ifdef ARCUS
+    private_data->socket = new Arcus::Socket();
+    private_data->socket->addListener(new Listener());
 
-    d->socket->connect(ip, 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::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->connect(ip, port);
+
+    log("Connecting to %s:%i\n", ip.c_str(), port);
+
+    while(private_data->socket->getState() != Arcus::SocketState::Connected && private_data->socket->getState() != Arcus::SocketState::Error)
+    {
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    }
+
+    log("Connected to %s:%i\n", ip.c_str(), port);
+    
+    bool slice_another_time = true;
     
     // Start & continue listening as long as socket is not closed and there is no error.
-    while(d->socket->state() != Arcus::SocketState::Closed && d->socket->state() != Arcus::SocketState::Error)
+    while(private_data->socket->getState() != Arcus::SocketState::Closed && private_data->socket->getState() != Arcus::SocketState::Error && slice_another_time)
     {
-        //If there is an object to slice, do so.
-        if(d->objects_to_slice.size())
-        {
-            for(auto object : d->objects_to_slice)
-            {
-                FffProcessor::getInstance()->processMeshGroup(object.get());
-            }
-            d->objects_to_slice.clear();
-            sendPrintTime();
-            //TODO: Support all-at-once/one-at-a-time printing
-            //d->processor->processModel(d->object_to_slice.get());
-            //d->object_to_slice.reset();
-            //d->processor->resetFileNumber();
-
-            //sendPrintTime();
-        }
-        
         // Actually start handling messages.
-        Arcus::MessagePtr message = d->socket->takeNextMessage();
+        Arcus::MessagePtr message = private_data->socket->takeNextMessage();
+
+        /*
+         * handle a message which consists purely of a SettingList
         cura::proto::SettingList* setting_list = dynamic_cast<cura::proto::SettingList*>(message.get());
-        if(setting_list)
+        if (setting_list)
         {
             handleSettingList(setting_list);
         }
+        */
 
-        /*cura::proto::ObjectList* object_list = dynamic_cast<cura::proto::ObjectList*>(message.get());
-        if(object_list)
+        /*
+         * handle a message which consists purely of an ObjectList
+        cura::proto::ObjectList* object_list = dynamic_cast<cura::proto::ObjectList*>(message.get());
+        if (object_list)
         {
             handleObjectList(object_list);
-        }*/
-        
-        cura::proto::Slice* slice = dynamic_cast<cura::proto::Slice*>(message.get());
-        if(slice)
+        }
+        */
+
+        // Handle the main Slice message
+        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)
         {
-            // Reset object counts
-            d->object_count = 0;
-            d->object_ids.clear();
-            for(auto object : slice->object_lists())
+            const cura::proto::SettingList& global_settings = slice->global_settings();
+            for (auto setting : global_settings.settings())
             {
-                handleObjectList(&object);
+                FffProcessor::getInstance()->setSetting(setting.name(), setting.value());
+            }
+            // Reset object counts
+            private_data->object_count = 0;
+            for (auto object : slice->object_lists())
+            {
+                handleObjectList(&object, slice->extruders());
             }
         }
 
-        std::this_thread::sleep_for(std::chrono::milliseconds(250));
-
-        if(!d->socket->errorString().empty()) 
+        //If there is an object to slice, do so.
+        if (private_data->objects_to_slice.size())
         {
-            logError("%s\n", d->socket->errorString().data());
-            d->socket->clearError();
+            FffProcessor::getInstance()->resetMeshGroupNumber();
+            for (auto object : private_data->objects_to_slice)
+            {
+                if (!FffProcessor::getInstance()->processMeshGroup(object.get()))
+                {
+                    logError("Slicing mesh group failed!");
+                }
+            }
+            private_data->objects_to_slice.clear();
+            FffProcessor::getInstance()->finalize();
+            flushGcode();
+            sendPrintTimeMaterialEstimates();
+            sendFinishedSlicing();
+            slice_another_time = false; // TODO: remove this when multiple slicing with CuraEngine is safe
+            //TODO: Support all-at-once/one-at-a-time printing
+            //private_data->processor->processModel(private_data->object_to_slice.get());
+            //private_data->object_to_slice.reset();
+            //private_data->processor->resetFileNumber();
+
+            //sendPrintTimeMaterialEstimates();
         }
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(250));
     }
+    log("Closing connection\n");
+    private_data->socket->close();
+#endif
 }
 
-void CommandSocket::handleObjectList(cura::proto::ObjectList* list)
+#ifdef ARCUS
+void CommandSocket::handleObjectList(cura::proto::ObjectList* list, const google::protobuf::RepeatedPtrField<cura::proto::Extruder> settings_per_extruder_train)
 {
-    FMatrix3x3 matrix;
-    //d->object_count = 0;
-    //d->object_ids.clear();
-    d->objects_to_slice.push_back(std::make_shared<MeshGroup>(FffProcessor::getInstance()));
-    MeshGroup* object_to_slice = d->objects_to_slice.back().get();
-    for(auto object : list->objects())
+    if (list->objects_size() <= 0)
     {
-        object_to_slice->meshes.push_back(object_to_slice); //Construct a new mesh (with object_to_slice as settings parent object) and put it into MeshGroup's mesh list.
-        Mesh& mesh = object_to_slice->meshes.back();
+        return;
+    }
 
+    FMatrix3x3 matrix;
+    //private_data->object_count = 0;
+    //private_data->object_ids.clear();
+    private_data->objects_to_slice.push_back(std::make_shared<MeshGroup>(FffProcessor::getInstance()));
+    MeshGroup* meshgroup = private_data->objects_to_slice.back().get();
+
+    // load meshgroup settings
+    for (auto setting : list->settings())
+    {
+        meshgroup->setSetting(setting.name(), setting.value());
+    }
+
+    { // 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
+            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->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());
+            }
+        }
+    }
+
+    for (auto object : list->objects())
+    {
         int bytes_per_face = BYTES_PER_FLOAT * FLOATS_PER_VECTOR * VECTORS_PER_FACE;
         int face_count = object.vertices().size() / bytes_per_face;
-        for(int i = 0; i < face_count; ++i)
+
+        if (face_count <= 0)
+        {
+            logWarning("Got an empty mesh, ignoring it!");
+            continue;
+        }
+        DEBUG_OUTPUT_OBJECT_STL_THROUGH_CERR("solid Cura_out\n");
+
+        // Check to which extruder train this object belongs
+        int extruder_train_nr = 0; // assume extruder 0 if setting wasn't supplied
+        for (auto setting : object.settings())
+        {
+            if (setting.name() == "extruder_nr")
+            {
+                extruder_train_nr = std::stoi(setting.value());
+                break;
+            }
+        }
+        SettingsBase* extruder_train = meshgroup->getExtruderTrain(extruder_train_nr);
+
+        meshgroup->meshes.push_back(extruder_train); //Construct a new mesh (with the corresponding extruder train as settings parent object) and put it into MeshGroup's mesh list.
+        Mesh& mesh = meshgroup->meshes.back();
+
+        for (int i = 0; i < face_count; ++i)
         {
             //TODO: Apply matrix
             std::string data = object.vertices().substr(i * bytes_per_face, bytes_per_face);
@@ -155,74 +296,68 @@ void CommandSocket::handleObjectList(cura::proto::ObjectList* list)
             verts[1] = matrix.apply(float_vertices[1]);
             verts[2] = matrix.apply(float_vertices[2]);
             mesh.addFace(verts[0], verts[1], verts[2]);
-        }
 
-        for(auto setting : object.settings())
+            DEBUG_OUTPUT_OBJECT_STL_THROUGH_CERR("  facet normal -1 0 0\n");
+            DEBUG_OUTPUT_OBJECT_STL_THROUGH_CERR("    outer loop\n");
+            DEBUG_OUTPUT_OBJECT_STL_THROUGH_CERR("      vertex "<<INT2MM(verts[0].x) <<" " << INT2MM(verts[0].y) <<" " << INT2MM(verts[0].z) << "\n");
+            DEBUG_OUTPUT_OBJECT_STL_THROUGH_CERR("      vertex "<<INT2MM(verts[1].x) <<" " << INT2MM(verts[1].y) <<" " << INT2MM(verts[1].z) << "\n");
+            DEBUG_OUTPUT_OBJECT_STL_THROUGH_CERR("      vertex "<<INT2MM(verts[2].x) <<" " << INT2MM(verts[2].y) <<" " << INT2MM(verts[2].z) << "\n");
+            DEBUG_OUTPUT_OBJECT_STL_THROUGH_CERR("    endloop\n");
+            DEBUG_OUTPUT_OBJECT_STL_THROUGH_CERR("  endfacet\n");
+        }
+        DEBUG_OUTPUT_OBJECT_STL_THROUGH_CERR("endsolid Cura_out\n");
+
+        for (auto setting : object.settings())
         {
             mesh.setSetting(setting.name(), setting.value());
         }
 
-        d->object_ids.push_back(object.id());
         mesh.finish();
     }
 
-    for(auto setting : list->settings())
-    {
-        object_to_slice->setSetting(setting.name(), setting.value());
-    }
-
-    d->object_count++;
-    object_to_slice->finalize();
-}
-
-void CommandSocket::handleSettingList(cura::proto::SettingList* list)
-{
-    for(auto setting : list->settings())
-    {
-        FffProcessor::getInstance()->setSetting(setting.name(), setting.value());
-    }
+    private_data->object_count++;
+    meshgroup->finalize();
 }
+#endif
 
 void CommandSocket::sendLayerInfo(int layer_nr, int32_t z, int32_t height)
 {
-    if(!d->current_sliced_object)
-    {
-        return;
-    }
-    
-    cura::proto::Layer* layer = d->getLayerById(layer_nr);
+#ifdef ARCUS
+    std::shared_ptr<cura::proto::Layer> layer = private_data->getLayerById(layer_nr);
     layer->set_height(z);
     layer->set_thickness(height);
+#endif
 }
 
-void CommandSocket::sendPolygons(PolygonType type, int layer_nr, Polygons& polygons, int line_width)
+void CommandSocket::sendPolygons(PrintFeatureType type, int layer_nr, Polygons& polygons, int line_width)
 {
-    if(!d->current_sliced_object)
-        return;
-    
+#ifdef ARCUS
     if (polygons.size() == 0)
         return;
 
-    cura::proto::Layer* layer = d->getLayerById(layer_nr);
+    std::shared_ptr<cura::proto::Layer> proto_layer = private_data->getLayerById(layer_nr);
 
-    for(unsigned int i = 0; i < polygons.size(); ++i)
+    for (unsigned int i = 0; i < polygons.size(); ++i)
     {
-        cura::proto::Polygon* p = layer->add_polygons();
+        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::sendProgress(float amount)
 {
+#ifdef ARCUS
     auto message = std::make_shared<cura::proto::Progress>();
-    amount /= d->object_count;
-    amount += d->sliced_objects * (1. / d->object_count);
+    amount /= private_data->object_count;
+    amount += private_data->sliced_objects * (1. / private_data->object_count);
     message->set_amount(amount);
-    d->socket->sendMessage(message);
+    private_data->socket->sendMessage(message);
+#endif
 }
 
 void CommandSocket::sendProgressStage(Progress::Stage stage)
@@ -230,12 +365,23 @@ void CommandSocket::sendProgressStage(Progress::Stage stage)
     // TODO
 }
 
-void CommandSocket::sendPrintTime()
+void CommandSocket::sendPrintTimeMaterialEstimates()
 {
-    auto message = std::make_shared<cura::proto::ObjectPrintTime>();
+#ifdef ARCUS
+    auto message = std::make_shared<cura::proto::PrintTimeMaterialEstimates>();
+
     message->set_time(FffProcessor::getInstance()->getTotalPrintTime());
-    message->set_material_amount(FffProcessor::getInstance()->getTotalFilamentUsed(0));
-    d->socket->sendMessage(message);
+    int num_extruders = FffProcessor::getInstance()->getSettingAsCount("machine_extruder_count");
+    for (int extruder_nr (0); extruder_nr < num_extruders; ++extruder_nr)
+    {
+        cura::proto::MaterialEstimates* material_message = message->add_materialestimates();
+
+        material_message->set_id(extruder_nr);
+        material_message->set_material_amount(FffProcessor::getInstance()->getTotalFilamentUsed(extruder_nr));
+    }
+
+    private_data->socket->sendMessage(message);
+#endif
 }
 
 void CommandSocket::sendPrintMaterialForObject(int index, int extruder_nr, float print_time)
@@ -247,68 +393,88 @@ void CommandSocket::sendPrintMaterialForObject(int index, int extruder_nr, float
 //     socket.sendFloat32(print_time);
 }
 
-void CommandSocket::beginSendSlicedObject()
+void CommandSocket::sendLayerData()
 {
-    if(!d->sliced_object_list)
-    {
-        d->sliced_object_list = std::make_shared<cura::proto::SlicedObjectList>();
-    }
+#ifdef ARCUS
+#endif
+#ifdef ARCUS
+    private_data->sliced_objects++;
+    private_data->current_layer_offset = private_data->current_layer_count;
+    log("End sliced object called. Sending ", private_data->current_layer_count, " layers.");
 
-    d->current_sliced_object = d->sliced_object_list->add_objects();
-    d->current_sliced_object->set_id(d->object_ids[d->sliced_objects]);
+    if (private_data->sliced_objects >= private_data->object_count)
+    {
+        for (std::pair<const int, std::shared_ptr<cura::proto::Layer>> entry : private_data->sliced_layers) //Note: This is in no particular order!
+        {
+            private_data->socket->sendMessage(entry.second); //Send the actual layers.
+        }
+        private_data->sliced_objects = 0;
+        private_data->current_layer_count = 0;
+        private_data->current_layer_offset = 0;
+        private_data->sliced_layers.clear();
+        auto done_message = std::make_shared<cura::proto::SlicingFinished>();
+        private_data->socket->sendMessage(done_message);
+    }
+#endif
 }
 
-void CommandSocket::endSendSlicedObject()
+void CommandSocket::sendFinishedSlicing()
 {
-    d->sliced_objects++;
-    std::cout << "End sliced object called. sliced objects " << d->sliced_objects << " object count: " << d->object_count << std::endl;
-    if(d->sliced_objects >= d->object_count)
-    {
-        d->socket->sendMessage(d->sliced_object_list);
-        d->sliced_objects = 0;
-        d->sliced_object_list.reset();
-        d->current_sliced_object = nullptr;
-    }
+#ifdef ARCUS
+    std::shared_ptr<cura::proto::SlicingFinished> done_message = std::make_shared<cura::proto::SlicingFinished>();
+    private_data->socket->sendMessage(done_message);
+#endif
 }
 
 void CommandSocket::beginGCode()
 {
-    FffProcessor::getInstance()->setTargetStream(&d->gcode_output_stream);
+#ifdef ARCUS
+    FffProcessor::getInstance()->setTargetStream(&private_data->gcode_output_stream);
+#endif
 }
 
-void CommandSocket::sendGCodeLayer()
+void CommandSocket::flushGcode()
 {
+#ifdef ARCUS
     auto message = std::make_shared<cura::proto::GCodeLayer>();
-    message->set_id(d->object_ids[0]);
-    message->set_data(d->gcode_output_stream.str());
-    d->socket->sendMessage(message);
+    message->set_data(private_data->gcode_output_stream.str());
+    private_data->socket->sendMessage(message);
     
-    d->gcode_output_stream.str("");
+    private_data->gcode_output_stream.str("");
+#endif
 }
 
 void CommandSocket::sendGCodePrefix(std::string prefix)
 {
+#ifdef ARCUS
     auto message = std::make_shared<cura::proto::GCodePrefix>();
     message->set_data(prefix);
-    d->socket->sendMessage(message);
+    private_data->socket->sendMessage(message);
+#endif
 }
 
-cura::proto::Layer* CommandSocket::Private::getLayerById(int id)
+#ifdef ARCUS
+std::shared_ptr<cura::proto::Layer> CommandSocket::Private::getLayerById(int id)
 {
-    auto itr = std::find_if(current_sliced_object->mutable_layers()->begin(), current_sliced_object->mutable_layers()->end(), [id](cura::proto::Layer& l) { return l.id() == id; });
+    id += current_layer_offset;
 
-    cura::proto::Layer* layer = nullptr;
-    if(itr != current_sliced_object->mutable_layers()->end())
+    auto itr = sliced_layers.find(id);
+
+    std::shared_ptr<cura::proto::Layer> layer;
+    if (itr != sliced_layers.end())
     {
-        layer = &(*itr);
+        layer = itr->second;
     }
     else
     {
-        layer = current_sliced_object->add_layers();
+        layer = std::make_shared<cura::proto::Layer>();
         layer->set_id(id);
+        current_layer_count++;
+        sliced_layers[id] = layer;
     }
 
     return layer;
 }
+#endif
 
 }//namespace cura

src/commandSocket.h

@@ -3,20 +3,33 @@
 
 #include "utils/socket.h"
 #include "utils/polygon.h"
-#include "settings.h"
-#include "Progress.h"
+#include "settings/settings.h"
+#include "progress/Progress.h"
+#include "PrintFeature.h"
 
 #include <memory>
 
+#ifdef ARCUS
 #include "Cura.pb.h"
+#endif
 
-namespace cura {
-
+namespace cura
+{
 
 class CommandSocket
 {
+private:
+    static CommandSocket* instance; //!< May be a nullptr in case it hasn't been instantiated.
+
+    CommandSocket(); //!< The single constructor is known only privately, since this class is similar to a singleton class (except the single object doesn't need to be instantiated)
+
 public:
-    CommandSocket();
+    static CommandSocket* getInstance(); //!< Get the CommandSocket instance, or nullptr if it hasn't been instantiated.
+
+    static void instantiate(); //!< Instantiate the CommandSocket.
+
+    static bool isInstantiated(); //!< Check whether the singleton is instantiated
+
     /*!
      * Connect with the GUI
      * This creates and initialises the arcus socket and then continues listening for messages. 
@@ -24,29 +37,35 @@ public:
      * \param port int of the port to connect with.
      */
     void connect(const std::string& ip, int port);
-    
+
+#ifdef ARCUS
     /*! 
      * Handler for ObjectList message. 
      * Loads all objects from the message and starts the slicing process
+     * 
+     * Also handles meshgroup settings and extruder settings.
+     * 
+     * \param[in] list The list of objects to slice
+     * \param[in] settings_per_extruder_train The extruder train settings to load into the meshgroup
      */
-    void handleObjectList(cura::proto::ObjectList* list);
-    
-    /*! 
-     * Handler for SettingList message. 
-     * This simply sets all the settings by using key value pair
-     */
-    void handleSettingList(cura::proto::SettingList* list);
+    void handleObjectList(cura::proto::ObjectList* list, const google::protobuf::RepeatedPtrField<cura::proto::Extruder> settings_per_extruder_train);
+#endif
     
     /*!
-     * Does nothing at the moment 
+     * Send info on a layer to be displayed by the forntend: set the z and the thickness of the layer.
      */
     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::PolygonType type, int layer_nr, cura::Polygons& polygons, int line_width);
-    
+    void sendPolygons(cura::PrintFeatureType type, int layer_nr, cura::Polygons& polygons, int line_width);
+
+    /*! 
+     * 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, cura::Polygons& polygons, int line_width);
+
     /*! 
      * Send progress to GUI
      */
@@ -60,23 +79,42 @@ public:
     /*!
      * Send time estimate of how long print would take.
      */
-    void sendPrintTime();
+    void sendPrintTimeMaterialEstimates();
     
     /*!
      * Does nothing at the moment
      */
     void sendPrintMaterialForObject(int index, int extruder_nr, float material_amount);
+    
+    /*!
+     * Send the sliced layer data to the GUI.
+     *
+     * The GUI may use this to visualise the g-code, so that the user can
+     * inspect the result of slicing.
+     */
+    void sendLayerData();
 
-    void beginSendSlicedObject();
-    void endSendSlicedObject();
+    /*!
+     * \brief Sends a message to indicate that all the slicing is done.
+     *
+     * This should indicate that no more data (g-code, prefix/postfix, metadata
+     * or otherwise) should be sent any more regarding the latest slice job.
+     */
+    void sendFinishedSlicing();
 
     void beginGCode();
-    void sendGCodeLayer();
+    
+    /*!
+     * Flush the gcode in gcode_output_stream into a message queued in the socket.
+     */
+    void flushGcode();
     void sendGCodePrefix(std::string prefix);
 
+#ifdef ARCUS
 private:
     class Private;
-    const std::unique_ptr<Private> d;
+    const std::unique_ptr<Private> private_data;
+#endif
 };
 
 }//namespace cura

src/gcodeExport.h

@@ -6,170 +6,169 @@
 #include <deque> // for extrusionAmountAtPreviousRetractions
 #include <sstream> // for stream.str()
 
-#include "settings.h"
+#include "settings/settings.h"
 #include "utils/intpoint.h"
+#include "utils/NoCopy.h"
 #include "timeEstimate.h"
 #include "MeshGroup.h"
-#include "PrintFeature.h"
+#include "commandSocket.h"
+#include "RetractionConfig.h"
 
 namespace cura {
 
+/*!
+ * Coasting configuration used during printing.
+ * Can differ per extruder.
+ * 
+ * Might be used in the future to have different coasting per feature, e.g. outer wall only.
+ */
 struct CoastingConfig
 {
-    bool coasting_enable; 
-    double coasting_volume_move; 
-    double coasting_speed_move; 
-    double coasting_min_volume_move; 
-
-    double coasting_volume_retract;
-    double coasting_speed_retract;
-    double coasting_min_volume_retract;
-};
-    
-class RetractionConfig
-{
-public:
-    double amount; //!< The amount retracted
-    double speed; //!< The speed with which to retract
-    double primeSpeed; //!< the speed with which to unretract
-    double primeAmount; //!< the amount of material primed after unretracting
-    int zHop; //!< the amount with which to lift the head during a retraction-travel
-    int retraction_min_travel_distance; //!< 
-    double retraction_extrusion_window;
-    int retraction_count_max;
+    bool coasting_enable; //!< Whether coasting is enabled on the extruder to which this config is attached 
+    double coasting_volume; //!< The volume leeked when printing without feeding
+    double coasting_speed; //!< A modifier (0-1) on the last used travel speed to move slower during coasting
+    double coasting_min_volume;  //!< The minimal volume printed to build up enough pressure to leek the coasting_volume
 };
 
-//The GCodePathConfig is the configuration for moves/extrusion actions. This defines at which width the line is printed and at which speed.
-class GCodePathConfig
-{
-private:
-    double speed; //!< movement speed
-    int line_width; //!< width of the line extruded
-    double flow; //!< extrusion flow in %
-    int layer_thickness; //!< layer height
-    double extrusion_mm3_per_mm;//!< mm^3 filament moved per mm line extruded
-public:
-    const char* name;
-    bool spiralize;
-    RetractionConfig *const retraction_config;
-    
-    // GCodePathConfig() : speed(0), line_width(0), extrusion_mm3_per_mm(0.0), name(nullptr), spiralize(false), retraction_config(nullptr) {}
-    GCodePathConfig(RetractionConfig* retraction_config, const char* name) : speed(0), line_width(0), extrusion_mm3_per_mm(0.0), name(name), spiralize(false), retraction_config(retraction_config) {}
-    
-    void setSpeed(double speed)
-    {
-        this->speed = speed;
-    }
-    
-    void setLineWidth(int line_width)
-    {
-        this->line_width = line_width;
-        calculateExtrusion();
-    }
-    
-    void setLayerHeight(int layer_height)
-    {
-        this->layer_thickness = layer_height;
-        calculateExtrusion();
-    }
-
-    void setFlow(double flow)
-    {
-        this->flow = flow;
-        calculateExtrusion();
-    }
-    
-    void smoothSpeed(double min_speed, int layer_nr, double max_speed_layer) 
-    {
-        speed = (speed*layer_nr)/max_speed_layer + (min_speed*(max_speed_layer-layer_nr)/max_speed_layer);
-    }
-    
-    double getExtrusionMM3perMM()
-    {
-        return extrusion_mm3_per_mm;
-    }
-    
-    double getSpeed()
-    {
-        return speed;
-    }
-    
-    int getLineWidth()
-    {
-        return line_width;
-    }
-
-private:
-    void calculateExtrusion()
-    {
-        extrusion_mm3_per_mm = INT2MM(line_width) * INT2MM(layer_thickness) * double(flow) / 100.0;
-    }
-};
 
 //The GCodeExport class writes the actual GCode. This is the only class that knows how GCode looks and feels.
 //  Any customizations on GCodes flavors are done in this class.
-class GCodeExport
+class GCodeExport : public NoCopy
 {
 private:
     struct ExtruderTrainAttributes
     {
+        Point3 prime_pos; //!< The location this nozzle is primed before printing
+        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 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;
         std::string start_code;
         std::string end_code;
         double filament_area; //!< in mm^2 for non-volumetric, cylindrical filament
 
-        double extruderSwitchRetraction;
-        int extruderSwitchRetractionSpeed;
-        int extruderSwitchPrimeSpeed;
-        
         double totalFilament; //!< total filament used per extruder in mm^3
         int currentTemperature;
-        
+        int initial_temp; //!< Temperature this nozzle needs to be at the start of the print.
+
+        double retraction_e_amount_current; //!< The current retracted amount (in mm or mm^3), or zero(i.e. false) if it is not currently retracted (positive values mean retracted amount, so negative impact on E values)
+        double retraction_e_amount_at_e_start; //!< The ExtruderTrainAttributes::retraction_amount_current value at E0, i.e. the offset (in mm or mm^3) from E0 to the situation where the filament is at the tip of the nozzle.
+
+        double prime_volume; //!< Amount of material (in mm^3) to be primed after an unretration (due to oozing and/or coasting)
+        double last_retraction_prime_speed; //!< The last prime speed (in mm/s) of the to-be-primed amount
+
+        std::deque<double> extruded_volume_at_previous_n_retractions; // in mm^3
+
         ExtruderTrainAttributes()
-        : nozzle_offset(0,0)
+        : prime_pos(0, 0, 0)
+        , prime_pos_is_abs(false)
+        , is_primed(false)
+        , is_used(false)
+        , nozzle_offset(0,0)
         , extruderCharacter(0)
         , start_code("")
         , end_code("")
         , filament_area(0)
-        , extruderSwitchRetraction(0.0)
-        , extruderSwitchRetractionSpeed(0)
-        , extruderSwitchPrimeSpeed(0)
         , totalFilament(0)
         , currentTemperature(0)
+        , initial_temp(0)
+        , retraction_e_amount_current(0.0)
+        , retraction_e_amount_at_e_start(0.0)
+        , prime_volume(0.0)
+        , last_retraction_prime_speed(0.0)
         { }
     };
     ExtruderTrainAttributes extruder_attr[MAX_EXTRUDERS];
+    unsigned int extruder_count;
     bool use_extruder_offset_to_offset_coords;
-    
-    std::ostream* output_stream;
-    double extrusion_amount; // in mm or mm^3
-    std::deque<double> extrusion_amount_at_previous_n_retractions; // in mm or mm^3
-    Point3 currentPosition;
-    Point3 startPosition;
-    double currentSpeed;
-    int zPos;
-    bool isRetracted;
-    bool isZHopped;
+    Point3 machine_dimensions;
+    std::string machine_name;
+
+    std::ostream* output_stream;
+    std::string new_line;
+
+    double current_e_value; //!< The last E value written to gcode (in mm or mm^3)
+    Point3 currentPosition;
+    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)
+
+    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)
 
-    double last_coasted_amount_mm3; //!< The coasted amount of filament to be primed on the first next extrusion. (same type as GCodeExport::extrusion_amount)
-    double retractionPrimeSpeed;
     int current_extruder;
     int currentFanSpeed;
     EGCodeFlavor flavor;
 
-    double totalPrintTime;
-    double total_print_time_per_feature[(unsigned int)EPrintFeature::ENUM_COUNT];
+    double totalPrintTime; //!< The total estimated print time in seconds
     TimeEstimateCalculator estimateCalculator;
     
     bool is_volumatric;
+    bool firmware_retract; //!< whether retractions are done in the firmware, or hardcoded in E values.
+
+    unsigned int layer_nr; //!< for sending travel data
+
+    int initial_bed_temp; //!< bed temperature at the beginning of the print.
+protected:
+    /*!
+     * Convert an E value to a value in mm (if it wasn't already in mm) for the current extruder.
+     * 
+     * E values are either in mm or in mm^3
+     * The current extruder is used to determine the filament area to make the conversion.
+     * 
+     * \param e the value to convert
+     * \return the value converted to mm
+     */
+    double eToMm(double e);
+
+    /*!
+     * Convert a volume value to an E value (which might be volumetric as well) for the current extruder.
+     * 
+     * E values are either in mm or in mm^3
+     * The current extruder is used to determine the filament area to make the conversion.
+     * 
+     * \param mm3 the value to convert
+     * \return the value converted to mm or mm3 depending on whether the E axis is volumetric
+     */
+    double mm3ToE(double mm3);
+
+    /*!
+     * Convert a distance value to an E value (which might be linear/distance based as well) for the current extruder.
+     * 
+     * E values are either in mm or in mm^3
+     * The current extruder is used to determine the filament area to make the conversion.
+     * 
+     * \param mm the value to convert
+     * \return the value converted to mm or mm3 depending on whether the E axis is volumetric
+     */
+    double mmToE(double mm);
+
 public:
     
     GCodeExport();
     ~GCodeExport();
+
+    /*!
+     * Get the gcode file header (e.g. ";FLAVOR:UltiGCode\n")
+     * 
+     * \param print_time The total print time in seconds of the whole gcode (if known)
+     * \param filament_used The total mm^3 filament used for each extruder or a vector of the wrong size of unknown
+     * \param mat_ids The material ids for each material.
+     * \return The string representing the file header
+     */
+    std::string getFileHeader(const double* print_time = nullptr, const std::vector<double>& filament_used = std::vector<double>(), const std::vector<int16_t>& mat_ids = std::vector<int16_t>());
+
+    void setLayerNr(unsigned int layer_nr);
     
     void setOutputStream(std::ostream* stream);
-    
+
+    bool getExtruderIsUsed(int extruder_nr); //!< Returns whether the extruder with the given index is used up until the current meshgroup
+
+    int getNozzleSize(int extruder_nr);
+
     Point getExtruderOffset(int id);
     
     Point getGcodePos(int64_t x, int64_t y, int extruder_train);
@@ -179,38 +178,61 @@ public:
     
     void setZ(int z);
     
-    void setLastCoastedAmountMM3(double last_coasted_amount) { this->last_coasted_amount_mm3 = last_coasted_amount; }
+    void addLastCoastedVolume(double last_coasted_volume) 
+    {
+        extruder_attr[current_extruder].prime_volume += last_coasted_volume; 
+    }
     
     Point3 getPosition();
     
     Point getPositionXY();
-    
-    void resetStartPosition();
-
-    Point getStartPositionXY();
 
     int getPositionZ();
 
     int getExtruderNr();
     
     void setFilamentDiameter(unsigned int n, int diameter);
-    double getFilamentArea(unsigned int extruder);
     
-    double getExtrusionAmountMM3(unsigned int extruder);
-    
-    double getTotalFilamentUsed(int e);
+    double getCurrentExtrudedVolume();
 
+    /*!
+     * Get the total extruded volume for a specific extruder in mm^3
+     * 
+     * Retractions and unretractions don't contribute to this.
+     * 
+     * \param extruder_nr The extruder number for which to get the total netto extruded volume
+     * \return total filament printed in mm^3
+     */
+    double getTotalFilamentUsed(int extruder_nr);
+
+    /*!
+     * Get the total estimated print time in seconds
+     * 
+     * \return total print time in seconds
+     */
     double getTotalPrintTime();
-    double getTotalPrintTime(EPrintFeature print_feature);
-    void updateTotalPrintTime(EPrintFeature print_feature = EPrintFeature::UNCLASSIFIED);
+    void updateTotalPrintTime();
     void resetTotalPrintTimeAndFilament();
     
     void writeComment(std::string comment);
-    void writeTypeComment(const char* type);
+    void writeTypeComment(PrintFeatureType type);
+
+    /*!
+     * Write a comment saying what (estimated) time has passed up to this point
+     * 
+     * \param time The time passed up till this point
+     */
+    void writeTimeComment(const double time);
     void writeLayerComment(int layer_nr);
+    void writeLayerCountComment(int layer_count);
     
     void writeLine(const char* line);
     
+    /*!
+     * Reset the current_e_value to prevent too high E values.
+     * 
+     * The current extruded volume is added to the current extruder_attr.
+     */
     void resetExtrusionValue();
     
     void writeDelay(double timeAmount);
@@ -220,44 +242,103 @@ public:
     void writeMove(Point3 p, double speed, double extrusion_per_mm);
 private:
     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_per_mm);
 public:
-    void writeRetraction(RetractionConfig* config, bool force=false);
-    
-    void writeRetraction_extruderSwitch();
-    
-    void switchExtruder(int newExtruder);
-    
+    void writeRetraction(RetractionConfig* config, bool force = false, bool extruder_switch = false);
+
+    /*!
+     * Start a z hop with the given \p hop_height
+     * 
+     * \param hop_height The height to move above the current layer
+     */
+    void writeZhopStart(int hop_height);
+
+    /*!
+     * Start the new_extruder: 
+     * - set new extruder
+     * - zero E value
+     * - write extruder start gcode
+     * 
+     * \param new_extruder The extruder to start with
+     */
+    void startExtruder(int new_extruder);
+
+    /*!
+     * Switch to the new_extruder: 
+     * - perform neccesary retractions
+     * - fiddle with E-values
+     * - write extruder end gcode
+     * - set new extruder
+     * - write extruder start gcode
+     * 
+     * \param new_extruder The extruder to switch to
+     * \param retraction_config_old_extruder The extruder switch retraction config of the old extruder, to perform the extruder switch retraction with.
+     */
+    void switchExtruder(int new_extruder, const RetractionConfig& retraction_config_old_extruder);
+
     void writeCode(const char* str);
     
+    /*!
+     * Write the gcode for priming the current extruder train so that it can be used.
+     * 
+     * \param travel_speed The travel speed when priming involves a movement
+     */
+    void writePrimeTrain(double travel_speed);
+    
     void writeFanCommand(double speed);
     
     void writeTemperatureCommand(int extruder, double temperature, bool wait = false);
     void writeBedTemperatureCommand(double temperature, bool wait = false);
-    
-    void preSetup(MeshGroup* settings)
-    {
-        for(int n=0; n<settings->getSettingAsCount("machine_extruder_count"); n++)
-        {
-            ExtruderTrain* train = settings->getExtruderTrain(n);
-            setFilamentDiameter(n, train->getSettingInMicrons("material_diameter")); 
-            
-            extruder_attr[n].nozzle_offset = Point(train->getSettingInMicrons("machine_nozzle_offset_x"), train->getSettingInMicrons("machine_nozzle_offset_y"));
-            
-            extruder_attr[n].start_code = train->getSettingString("machine_extruder_start_code");
-            extruder_attr[n].end_code = train->getSettingString("machine_extruder_end_code");
-            
-            extruder_attr[n].extruderSwitchRetraction = INT2MM(train->getSettingInMicrons("switch_extruder_retraction_amount")); 
-            extruder_attr[n].extruderSwitchRetractionSpeed = train->getSettingInMillimetersPerSecond("switch_extruder_retraction_speed");
-            extruder_attr[n].extruderSwitchPrimeSpeed = train->getSettingInMillimetersPerSecond("switch_extruder_prime_speed");
-        }
 
-        setFlavor(settings->getSettingAsGCodeFlavor("machine_gcode_flavor"));
-        use_extruder_offset_to_offset_coords = settings->getSettingBoolean("machine_use_extruder_offset_to_offset_coords");
-    }
-    void finalize(int maxObjectHeight, double moveSpeed, const char* endCode);
-    
+    /*!
+     * Write the command for setting the acceleration to a specific value
+     */
+    void writeAcceleration(double acceleration);
+
+    /*!
+     * Write the command for setting the jerk to a specific value
+     */
+    void writeJerk(double jerk);
+
+    /*!
+     * Set member variables using the settings in \p settings
+     * 
+     * \param settings The meshgroup to get the global bed temp from and to get the extruder trains from which to get the nozzle temperatures
+     */
+    void preSetup(const MeshGroup* settings);
+
+    /*!
+     * Handle the initial (bed/nozzle) temperatures before any gcode is processed.
+     * These temperatures are set in the pre-print setup in the firmware.
+     * 
+     * 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
+     */
+    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
+     * 
+     * \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
+     */
+    void setInitialTemp(int extruder_nr, double temp);
+
+    /*!
+     * Finish the gcode: turn fans off, write end gcode and flush all gcode left in the buffer.
+     * 
+     * \param endCode The end gcode to be appended at the very end.
+     */
+    void finalize(const char* endCode);
+
 };
 
 }
 
 #endif//GCODEEXPORT_H
+

src/gcodePlanner.h

@@ -4,57 +4,386 @@
 #include <vector>
 
 #include "gcodeExport.h"
-#include "comb.h"
+#include "pathPlanning/Comb.h"
 #include "utils/polygon.h"
 #include "utils/logoutput.h"
 #include "wallOverlap.h"
+#include "commandSocket.h"
+#include "FanSpeedLayerTime.h"
+#include "SpaceFillType.h"
+#include "GCodePathConfig.h"
 
+#include "utils/optional.h"
 
 namespace cura 
 {
 
 class SliceDataStorage;
 
+/*!
+ * 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 GCodePlanner; // 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 GCodePlanner;
+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. 
-    int extruder; //!< The extruder used for this 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;
+    }
 };
 
+/*!
+ * An extruder plan contains all planned paths (GCodePath) pertaining to a single extruder train.
+ * 
+ * It allows for temperature command inserts which can be inserted in between paths.
+ */
+class ExtruderPlan
+{
+public:
+    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 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.
+
+    /*!
+     * Simple contructor.
+     * 
+     * \warning Doesn't set the required temperature yet.
+     * 
+     * \param extruder The extruder number for which this object is a plan.
+     */
+    ExtruderPlan(int extruder)
+    : extruder(extruder)
+    , required_temp(-1)
+    {
+    }
+
+    /*!
+     * Add a new Insert, constructed with the given arguments
+     * 
+     * \see NozzleTempInsert
+     * 
+     * \param contructor_args The arguments for the constructor of an insert 
+     */
+    template<typename... Args>
+    void insertCommand(Args&&... contructor_args)
+    {
+        inserts.emplace_back(contructor_args...);
+    }
+
+    /*!
+     * Insert the inserts into gcode which should be inserted before \p path_idx
+     * 
+     * \param path_idx The index into ExtruderPlan::paths which is currently being consider for temperature command insertion
+     * \param gcode The gcode exporter to which to write the temperature command.
+     */
+    void handleInserts(unsigned int& path_idx, GCodeExport& gcode)
+    {
+        while ( ! inserts.empty() && path_idx >= inserts.front().path_idx)
+        { // handle the Insert to be inserted before this path_idx (and all inserts not handled yet)
+            inserts.front().write(gcode);
+            inserts.pop_front();
+        }
+    }
+
+    /*!
+     * Insert all remaining temp inserts into gcode, to be called at the end of an extruder plan
+     * 
+     * Inserts temperature commands which should be inserted _after_ the last path.
+     * Also inserts all temperatures which should have been inserted earlier,
+     * but for which ExtruderPlan::handleInserts hasn't been called correctly.
+     * 
+     * \param gcode The gcode exporter to which to write the temperature command.
+     */
+    void handleAllRemainingInserts(GCodeExport& gcode)
+    { 
+        while ( ! inserts.empty() )
+        { // handle the Insert to be inserted before this path_idx (and all inserts not handled yet)
+            NozzleTempInsert& insert = inserts.front();
+            assert(insert.path_idx == paths.size());
+            insert.write(gcode);
+            inserts.pop_front();
+        }
+    }
+};
+
+class LayerPlanBuffer; // forward declaration to prevent circular dependency
+
 /*! 
  * 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 GCodePlanner is also knows as a 'layer plan'.
+ * 
  */
-class GCodePlanner
+class GCodePlanner : public NoCopy
 {
+    friend class LayerPlanBuffer;
+    friend class GCodePlannerTest;
 private:
-    GCodeExport& gcode;
-    SliceDataStorage& storage;
+    SliceDataStorage& storage; //!< The polygon data obtained from FffPolygonProcessor
 
-    Point lastPosition;
-    std::vector<GCodePath> paths;
+    int layer_nr; //!< The layer number of this layer plan
     
-    bool was_combing;
-    bool is_going_to_comb;
+    int z; 
+    
+    int layer_thickness;
+    
+    Point start_position;
+    Point lastPosition;
+    
+    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
+    SettingsBaseVirtual* last_planned_extruder_setting_base; //!< The setting base of the last planned extruder.
+    bool was_inside; //!< Whether the last planned (extrusion) move was inside a layer part
+    bool is_inside; //!< Whether the destination of the next planned travel move is inside a layer part
+    Polygons comb_boundary_inside; //!< The boundary within which to comb, or to move into when performing a retraction.
     Comb* comb;
 
-    RetractionConfig* last_retraction_config;
-    
-    GCodePathConfig travelConfig; //!< The config used for travel moves (only the speed and retraction config are set!)
+    FanSpeedLayerTimeSettings& fan_speed_layer_time_settings;
+
     double extrudeSpeedFactor;
-    double travelSpeedFactor; // TODO: remove this unused var?
-    int currentExtruder;
+    double travelSpeedFactor;
+    
+    double fan_speed;
     
     double extraTime;
     double totalPrintTime;
@@ -65,10 +394,12 @@ private:
      * 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 GCodePlanner::paths
      */
-    GCodePath* getLatestPathWithConfig(GCodePathConfig* config, float flow = 1.0);
+    GCodePath* getLatestPathWithConfig(GCodePathConfig* config, SpaceFillType space_fill_type, float flow = 1.0, bool spiralize = false);
     
     /*!
      * Force GCodePlanner::getLatestPathWithConfig to return a new path.
@@ -82,26 +413,83 @@ private:
      */
     void forceNewPathStart();
 public:
-    /*
+    /*!
      * 
      * \param travel_avoid_other_parts Whether to avoid other layer parts when travaeling through air.
      * \param travel_avoid_distance The distance by which to avoid other layer parts when traveling through air.
+     * \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.
      */
-    GCodePlanner(GCodeExport& gcode, SliceDataStorage& storage, RetractionConfig* retraction_config_travel, double travelSpeed, bool retraction_combing, unsigned int layer_nr, int64_t comb_boundary_offset, bool travel_avoid_other_parts, int64_t travel_avoid_distance);
+    GCodePlanner(SliceDataStorage& storage, unsigned int layer_nr, int z, int layer_height, Point last_position, int current_extruder, bool is_inside_mesh, FanSpeedLayerTimeSettings& fan_speed_layer_time_settings, CombingMode combing_mode, int64_t comb_boundary_offset, bool travel_avoid_other_parts, int64_t travel_avoid_distance);
     ~GCodePlanner();
 
-    void setCombing(bool going_to_comb);
+    /*!
+     * Get the settings base of the last extruder planned.
+     * \return the settings base of the last extruder planned.
+     */
+    SettingsBaseVirtual* getLastPlannedExtruderTrainSettings();
+private:
+    /*!
+     * Compute the boundary within which to comb, or to move into when performing a retraction.
+     * \param combing_mode Whether combing is enabled and full or within infill only.
+     * \return the comb_boundary_inside
+     */
+    Polygons computeCombBoundaryInside(CombingMode combing_mode);
+
+public:
+    int getLayerNr()
+    {
+        return layer_nr;
+    }
+    
+    Point getLastPosition()
+    {
+        return lastPosition;
+    }
+
+    /*!
+     * return whether the last position planned was inside the mesh (used in combing)
+     */
+    bool getIsInsideMesh()
+    {
+        return was_inside;
+    }
+    /*!
+     * send a polygon through the command socket from the previous point to the given point
+     */
+    void sendPolygon(PrintFeatureType print_feature_type, Point from, Point to, int 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);
+        }
+    }
+
+    /*!
+    * Set whether the next destination is inside a layer part or not.
+    * 
+    * Features like infill, walls, skin etc. are considered inside.
+    * Features like prime tower and support are considered outside.
+    */
+    void setIsInside(bool going_to_comb);
     
     bool setExtruder(int extruder);
 
+    /*!
+     * Get the last planned extruder.
+     */
     int getExtruder()
     {
-        return currentExtruder;
+        return extruder_plans.back().extruder;
     }
 
     void setExtrudeSpeedFactor(double speedFactor)
     {
-        if (speedFactor < 1) speedFactor = 1.0;
         this->extrudeSpeedFactor = speedFactor;
     }
     double getExtrudeSpeedFactor()
@@ -117,16 +505,12 @@ public:
     {
         return this->travelSpeedFactor;
     }
-
-    /*!
-     * Whether the current retracted path is to be an extruder switch retraction.
-     * This function is used to avoid a G10 S1 after a G10.
-     * 
-     * \param path_idx The index of the current retracted path 
-     * \return Whether the path should be an extgruder switch retracted path
-     */
-    bool makeRetractSwitchRetract(unsigned int path_idx);
-
+    
+    void setFanSpeed(double _fan_speed)
+    {
+        fan_speed = _fan_speed;
+    }
+    
     /*!
      * Add a travel path to a certain point, retract if needed and when avoiding boundary crossings:
      * avoiding obstacles and comb along the boundary of parts.
@@ -144,75 +528,122 @@ public:
      * \param path (optional) The travel path to which to add the point \p p
      */
     void addTravel_simple(Point p, GCodePath* path = nullptr);
-    
-    void addExtrusionMove(Point p, GCodePathConfig* config, float flow = 1.0);
 
-    void addPolygon(PolygonRef polygon, int startIdx, GCodePathConfig* config, WallOverlapComputation* wall_overlap_computation = nullptr);
+    /*!
+     * Add an extrusion move to a certain point, optionally with a different flow than the one in the \p config.
+     * 
+     * \param p The point to extrude to
+     * \param config The config with which to extrude
+     * \param space_fill_type Of what space filling type this extrusion move is a part
+     * \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, GCodePathConfig* config, SpaceFillType space_fill_type, float flow = 1.0, bool spiralize = false);
 
-    void addPolygonsByOptimizer(Polygons& polygons, GCodePathConfig* config, WallOverlapComputation* wall_overlap_computation = nullptr, EZSeamType z_seam_type = EZSeamType::SHORTEST);
+    /*!
+     * Add polygon to the gcode starting at vertex \p startIdx
+     * \param polygon The polygon
+     * \param startIdx The index of the starting vertex of the \p polygon
+     * \param config The config with which to print the polygon lines
+     * \param wall_overlap_computation The wall overlap compensation calculator for each given segment (optionally nullptr)
+     * \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(PolygonRef polygon, int startIdx, GCodePathConfig* config, WallOverlapComputation* wall_overlap_computation = nullptr, bool spiralize = false);
+
+    /*!
+     * Add polygons to the gcode with optimized order.
+     * 
+     * When \p spiralize is true, each polygon will gradually increase from a z corresponding to this layer to the z corresponding to the next layer.
+     * Doing this for each polygon means there is a chance for the print head to crash into already printed parts,
+     * but doing it for the last polygon only would mean you are printing half of the layer in non-spiralize mode,
+     * while each layer starts with a different part.
+     * Two towers would result in alternating spiralize and non-spiralize layers.
+     * 
+     * \param polygons The polygons
+     * \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 spiralize Whether to gradually increase the z height from the normal layer height to the height of the next layer over each polygon printed
+     */
+    void addPolygonsByOptimizer(Polygons& polygons, GCodePathConfig* config, WallOverlapComputation* wall_overlap_computation = nullptr, EZSeamType z_seam_type = EZSeamType::SHORTEST, bool spiralize = false);
 
     /*!
      * Add lines to the gcode with optimized order.
      * \param polygons The lines
      * \param config The config of the lines
+     * \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(Polygons& polygons, GCodePathConfig* config, int wipe_dist = 0);
+    void addLinesByOptimizer(Polygons& polygons, GCodePathConfig* config, SpaceFillType space_fill_type, int wipe_dist = 0);
 
+    /*!
+     * Compute naive time estimates (without accountign for slow down at corners etc.) and naive material estimates (without accounting for MergeInfillLines)
+     * and store them in each ExtruderPlan and each GCodePath.
+     * 
+     * \return the total estimates of this layer
+     */
+    TimeMaterialEstimates computeNaiveTimeEstimates();
+    
     void forceMinimalLayerTime(double minTime, double minimalSpeed, double travelTime, double extrusionTime);
     
-    void getNaiveTimeEstimates(double& travelTime, double& extrudeTime);
-
+    /*!
+     * Write the planned paths to gcode
+     * 
+     * \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.
+     * 
+     * \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 of the current retracted path 
+     * \return Whether the path should be an extgruder switch retracted path
+     */
+    bool makeRetractSwitchRetract(GCodeExport& gcode, unsigned int extruder_plan_idx, unsigned int path_idx);
+    
     /*!
      * Writes a path to GCode and performs coasting, or returns false if it did nothing.
      * 
      * Coasting replaces the last piece of an extruded path by move commands and uses the oozed material to lay down lines.
      * 
+     * \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 GCodePlanner::paths for the next path to be written to GCode.
      * \param layerThickness The height of the current layer.
-     * \param coasting_volume_move The volume otherwise leaked during a normal move.
-     * \param coasting_speed_move The speed at which to move during move-coasting.
-     * \param coasting_min_volume_move The minimal volume a path should have which builds up enough pressure to ooze as much as \p coasting_volume_move.
-     * \param coasting_volume_retract The volume otherwise leaked during a retract move.
-     * \param coasting_speed_retract The speed at which to move during retract-coasting.
-     * \param coasting_min_volume_retract The minimal volume a path should have which builds up enough pressure to ooze as much as \p coasting_volume_retract.
+     * \param coasting_volume The volume otherwise leaked during a normal move.
+     * \param coasting_speed The speed at which to move during move-coasting.
+     * \param coasting_min_volume The minimal volume a path should have (before starting to coast) which builds up enough pressure to ooze as much as \p coasting_volume.
      * \return Whether any GCode has been written for the path.
      */
-    bool writePathWithCoasting(unsigned int path_idx, int64_t layerThickness, double coasting_volume_move, double coasting_speed_move, double coasting_min_volume_move, double coasting_volume_retract, double coasting_speed_retract, double coasting_min_volume_retract);
+    bool 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);
 
     /*!
-     * Writes a path to GCode and performs coasting, or returns false if it did nothing.
-     * 
-     * Coasting replaces the last piece of an extruded path by move commands and uses the oozed material to lay down lines.
-     * 
-     * Paths shorter than \p coasting_min_volume will use less \p coasting_volume linearly.
-     * 
-     * \param path The extrusion path to be written to GCode.
-     * \param path_next The next travel path to be written to GCode.
-     * \param layerThickness The height of the current layer.
-     * \param coasting_volume The volume otherwise leaked.
-     * \param coasting_speed The speed at which to move during coasting.
-     * \param coasting_min_volume The minimal volume a path should have which builds up enough pressure to ooze as much as \p coasting_volume.
-     * \param extruder_switch_retract (optional) For a coasted path followed by a retraction: whether to retract normally, or do an extruder switch retraction.
-     * \return Whether any GCode has been written for the path.
+     * Applying speed corrections for minimal layer times and determine the fanSpeed. 
      */
-    bool writePathWithCoasting(GCodePath& path, GCodePath& path_next, int64_t layerThickness, double coasting_volume, double coasting_speed, double coasting_min_volume, bool extruder_switch_retract = false);
+    void processFanSpeedAndMinimalLayerTime();
     
     /*!
-     * Write a retraction: either an extruder switch retraction or a normal retraction based on the last extrusion paths retraction config.
-     * \param path_idx_travel_after Index in GCodePlanner::paths to the travel move before which to do the retraction
+     * Add a travel move to the layer plan to move inside the current layer part by a given distance away from the outline.
+     * This is supposed to be called when the nozzle is around the boundary of a layer part, not when the nozzle is in the middle of support, or in the middle of the air.
+     * 
+     * \param distance The distance to the comb boundary after we moved inside it.
      */
-    void writeRetraction(unsigned int path_idx_travel_after);
-    
-    /*!
-     * Write a retraction: either an extruder switch retraction or a normal retraction based on the given retraction config.
-     * \param extruder_switch_retract Whether to write an extruder switch retract
-     * \param retraction_config The config used.
-     */
-    void writeRetraction(bool extruder_switch_retract, RetractionConfig* retraction_config);
-    
-    void writeGCode(bool liftHeadIfNeeded, int layerThickness);
-    void moveInsideCombBoundary(int arg1);
+    void moveInsideCombBoundary(int distance);
 };
 
 }//namespace cura

src/infill.cpp

@@ -2,12 +2,11 @@
 #include "infill.h"
 #include "functional"
 #include "utils/polygonUtils.h"
-#include "utils/AABB.h"
 #include "utils/logoutput.h"
 
 namespace cura {
 
-void Infill::generate(Polygons& result_polygons, Polygons& result_lines, Polygons* in_between)
+void Infill::generate(Polygons& result_polygons, Polygons& result_lines)
 {
     if (in_outline.size() == 0) return;
     if (line_distance == 0) return;
@@ -16,36 +15,21 @@ void Infill::generate(Polygons& result_polygons, Polygons& result_lines, Polygon
     switch(pattern)
     {
     case EFillMethod::GRID:
-        generateGridInfill(in_outline, outlineOffset, result_lines, extrusion_width, line_distance * 2, infill_overlap, fill_angle);
+        generateGridInfill(result_lines);
         break;
     case EFillMethod::LINES:
-        generateLineInfill(in_outline, outlineOffset, result_lines, extrusion_width, line_distance, infill_overlap, fill_angle);
+        generateLineInfill(result_lines, line_distance, fill_angle);
         break;
     case EFillMethod::TRIANGLES:
-        generateTriangleInfill(in_outline, outlineOffset, result_lines, extrusion_width, line_distance * 3, infill_overlap, fill_angle);
+        generateTriangleInfill(result_lines);
         break;
     case EFillMethod::CONCENTRIC:
-        if (outlineOffset != 0)
-        {
-            PolygonUtils::offsetSafe(in_outline, outlineOffset, extrusion_width, outline_offsetted, avoidOverlappingPerimeters);
-            outline = &outline_offsetted;
-        }
-        if (abs(extrusion_width - line_distance) < 10)
-        {
-            generateConcentricInfillDense(*outline, result_polygons, in_between, extrusion_width, avoidOverlappingPerimeters);
-        }
-        else 
-        {
-            generateConcentricInfill(*outline, result_polygons, line_distance);
-        }
+        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:
-        if (outlineOffset != 0)
-        {
-            PolygonUtils::offsetSafe(in_outline, outlineOffset, extrusion_width, outline_offsetted, avoidOverlappingPerimeters);
-            outline = &outline_offsetted;
-        }
-        generateZigZagInfill(*outline, result_lines, extrusion_width, line_distance, infill_overlap, fill_angle, connect_zigzags, use_endPieces);
+        generateZigZagInfill(result_lines, line_distance, fill_angle, connected_zigzags, use_endpieces);
         break;
     default:
         logError("Fill pattern has unknown value.\n");
@@ -53,184 +37,105 @@ void Infill::generate(Polygons& result_polygons, Polygons& result_lines, Polygon
     }
 }
 
-    
-      
-void generateConcentricInfillDense(Polygons outline, Polygons& result, Polygons* in_between, int extrusionWidth, bool avoidOverlappingPerimeters)
+void Infill::generateConcentricInfill(Polygons outline, Polygons& result, int inset_value)
 {
     while(outline.size() > 0)
     {
-        for (unsigned int polyNr = 0; polyNr < outline.size(); polyNr++)
-        {
-            PolygonRef r = outline[polyNr];
-            result.add(r);
-        }
-        Polygons next_outline;
-        PolygonUtils::offsetExtrusionWidth(outline, true, extrusionWidth, next_outline, in_between, avoidOverlappingPerimeters);
-        outline = next_outline;
-    } 
-
-}
-
-void generateConcentricInfill(Polygons outline, Polygons& result, int inset_value)
-{
-    while(outline.size() > 0)
-    {
-        for (unsigned int polyNr = 0; polyNr < outline.size(); polyNr++)
-        {
-            PolygonRef r = outline[polyNr];
-            result.add(r);
-        }
+        result.add(outline);
         outline = outline.offset(-inset_value);
     } 
 }
 
 
-void generateGridInfill(const Polygons& in_outline, int outlineOffset, Polygons& result,
-                        int extrusionWidth, int lineSpacing, double infillOverlap,
-                        double rotation)
+void Infill::generateGridInfill(Polygons& result)
 {
-    generateLineInfill(in_outline, outlineOffset, result, extrusionWidth, lineSpacing,
-                       infillOverlap, rotation);
-    generateLineInfill(in_outline, outlineOffset, result, extrusionWidth, lineSpacing,
-                       infillOverlap, rotation + 90);
+    generateLineInfill(result, line_distance, fill_angle);
+    generateLineInfill(result, line_distance, fill_angle + 90);
 }
 
-void generateTriangleInfill(const Polygons& in_outline, int outlineOffset, Polygons& result,
-                        int extrusionWidth, int lineSpacing, double infillOverlap,
-                        double rotation)
+void Infill::generateTriangleInfill(Polygons& result)
 {
-    generateLineInfill(in_outline, outlineOffset, result, extrusionWidth, lineSpacing,
-                       infillOverlap, rotation);
-    generateLineInfill(in_outline, outlineOffset, result, extrusionWidth, lineSpacing,
-                       infillOverlap, rotation + 60);
-    generateLineInfill(in_outline, outlineOffset, result, extrusionWidth, lineSpacing,
-                       infillOverlap, rotation + 120);
+    generateLineInfill(result, line_distance, fill_angle);
+    generateLineInfill(result, line_distance, fill_angle + 60);
+    generateLineInfill(result, line_distance, fill_angle + 120);
 }
 
-void addLineInfill(Polygons& result, PointMatrix matrix, int scanline_min_idx, int lineSpacing, AABB boundary, std::vector<std::vector<int64_t> > cutList, int extrusionWidth)
+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)
 {
     auto addLine = [&](Point from, Point to)
-    {            
+    {
         PolygonRef p = result.newPoly();
-        p.add(matrix.unapply(from));
-        p.add(matrix.unapply(to));
+        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);
-        if (n < 0) return -1;
-        if (n > 0) return 1;
+        if (n < 0)
+        {
+            return -1;
+        }
+        if (n > 0)
+        {
+            return 1;
+        }
         return 0;
     };
-    
+
     int scanline_idx = 0;
-    for(int64_t x = scanline_min_idx * lineSpacing; x < boundary.max.X; x += lineSpacing)
+    for(int64_t x = scanline_min_idx * line_distance; x < boundary.max.X; x += line_distance)
     {
-        qsort(cutList[scanline_idx].data(), cutList[scanline_idx].size(), sizeof(int64_t), compare_int64_t);
-        for(unsigned int i = 0; i + 1 < cutList[scanline_idx].size(); i+=2)
+        std::vector<int64_t>& crossings = cut_list[scanline_idx];
+        qsort(crossings.data(), crossings.size(), sizeof(int64_t), compare_int64_t);
+        for(unsigned int crossing_idx = 0; crossing_idx + 1 < crossings.size(); crossing_idx += 2)
         {
-            if (cutList[scanline_idx][i+1] - cutList[scanline_idx][i] < extrusionWidth / 5)
+            if (crossings[crossing_idx + 1] - crossings[crossing_idx] < infill_line_width / 5)
+            { // segment is too short to create infill
                 continue;
-            addLine(Point(x, cutList[scanline_idx][i]), Point(x, cutList[scanline_idx][i+1]));
+            }
+            addLine(Point(x, crossings[crossing_idx]), Point(x, crossings[crossing_idx + 1]));
         }
         scanline_idx += 1;
     }
 }
 
-/*!
- * generate lines within the area of \p in_outline, at regular intervals of \p lineSpacing
- * 
- * idea:
- * intersect a regular grid of 'scanlines' with the area inside \p in_outline
- * 
- * we call the areas between two consecutive scanlines a 'scansegment'.
- * Scansegment x is the area between scanline x and scanline x+1
- * 
- * algorithm:
- * 1) for each line segment of each polygon:
- *      store the intersections of that line segment with all scanlines in a mapping (vector of vectors) from scanline to intersections
- *      (zigzag): add boundary segments to result
- * 2) for each scanline:
- *      sort the associated intersections 
- *      and connect them using the even-odd rule
- * 
- */
-void generateLineInfill(const Polygons& in_outline, int outlineOffset, Polygons& result, int extrusionWidth, int lineSpacing, double infillOverlap, double rotation)
+void Infill::generateLineInfill(Polygons& result, int line_distance, const double& fill_angle)
 {
-    if (lineSpacing == 0) return;
-    if (in_outline.size() == 0) return;
-    Polygons outline = ((outlineOffset)? in_outline.offset(outlineOffset) : in_outline).offset(extrusionWidth * infillOverlap / 100);
-    if (outline.size() == 0) return;
-    
-    PointMatrix matrix(rotation);
-    
-    outline.applyMatrix(matrix);
+    PointMatrix rotation_matrix(fill_angle);
+    NoZigZagConnectorProcessor lines_processor(rotation_matrix, result);
+    bool connected_zigzags = false;
+    bool safe_outline_offset = false;
+    generateLinearBasedInfill(outline_offset, safe_outline_offset, result, line_distance, rotation_matrix, lines_processor, connected_zigzags);
+}
 
-    
-    AABB boundary(outline);
-    
-    int scanline_min_idx = boundary.min.X / lineSpacing;
-    int lineCount = (boundary.max.X + (lineSpacing - 1)) / lineSpacing - scanline_min_idx;
-  
-    std::vector<std::vector<int64_t> > cutList; // mapping from scanline to all intersections with polygon segments
-    
-    for(int n=0; n<lineCount; n++)
-        cutList.push_back(std::vector<int64_t>());
-    
-    for(unsigned int poly_idx=0; poly_idx < outline.size(); poly_idx++)
+
+void Infill::generateZigZagInfill(Polygons& result, const int line_distance, const double& fill_angle, const bool connected_zigzags, const bool use_endpieces)
+{
+    bool safe_outline_offset = true;
+
+    PointMatrix rotation_matrix(fill_angle);
+    if (use_endpieces)
     {
-        Point p0 = outline[poly_idx][outline[poly_idx].size()-1];
-        for(unsigned int i=0; i < outline[poly_idx].size(); i++)
+        if (connected_zigzags)
         {
-            Point p1 = outline[poly_idx][i];
-            int64_t xMin = p1.X, xMax = p0.X;
-            if (xMin == xMax) {
-                p0 = p1;
-                continue; 
-            }
-            if (xMin > xMax) { xMin = p0.X; xMax = p1.X; }
-            
-            int scanline_idx0 = (p0.X + ((p0.X > 0)? -1 : -lineSpacing)) / lineSpacing; // -1 cause a linesegment on scanline x counts as belonging to scansegment x-1   ...
-            int scanline_idx1 = (p1.X + ((p1.X > 0)? -1 : -lineSpacing)) / lineSpacing; // -linespacing because a line between scanline -n and -n-1 belongs to scansegment -n-1 (for n=positive natural number)
-            int direction = 1;
-            if (p0.X > p1.X) 
-            { 
-                direction = -1; 
-                scanline_idx1 += 1; // only consider the scanlines in between the scansegments
-            } else scanline_idx0 += 1; // only consider the scanlines in between the scansegments
-            
-            for(int scanline_idx = scanline_idx0; scanline_idx != scanline_idx1+direction; scanline_idx+=direction)
-            {
-                int x = scanline_idx * lineSpacing;
-                int y = p1.Y + (p0.Y - p1.Y) * (x - p1.X) / (p0.X - p1.X);
-                cutList[scanline_idx - scanline_min_idx].push_back(y);
-            }
-            p0 = p1;
+            ZigzagConnectorProcessorConnectedEndPieces zigzag_processor(rotation_matrix, result);
+            generateLinearBasedInfill(outline_offset - infill_line_width / 2, safe_outline_offset, result, line_distance, rotation_matrix, zigzag_processor, connected_zigzags);
+        }
+        else
+        {
+            ZigzagConnectorProcessorDisconnectedEndPieces zigzag_processor(rotation_matrix, result);
+            generateLinearBasedInfill(outline_offset - infill_line_width / 2, safe_outline_offset, result, line_distance, rotation_matrix, zigzag_processor, connected_zigzags);
         }
     }
-    
-    addLineInfill(result, matrix, scanline_min_idx, lineSpacing, boundary, cutList, extrusionWidth);
+    else 
+    {
+        ZigzagConnectorProcessorNoEndPieces zigzag_processor(rotation_matrix, result);
+        generateLinearBasedInfill(outline_offset - infill_line_width / 2, safe_outline_offset, result, line_distance, rotation_matrix, zigzag_processor, connected_zigzags);
+    }
 }
 
-
-void generateZigZagInfill(const Polygons& in_outline, Polygons& result, int extrusionWidth, int lineSpacing, double infillOverlap, double rotation, bool connect_zigzags, bool use_endPieces)
-{
-    if (use_endPieces) return generateZigZagIninfill_endPieces(in_outline, result, extrusionWidth, lineSpacing, infillOverlap, rotation, connect_zigzags);
-    else return generateZigZagIninfill_noEndPieces(in_outline, result, extrusionWidth, lineSpacing, infillOverlap, rotation);
-}
-
-/*!
- * adapted from generateLineInfill(.)
- * 
- * generate lines within the area of [in_outline], at regular intervals of [lineSpacing]
- * idea:
- * intersect a regular grid of 'scanlines' with the area inside [in_outline]
- * sigzag:
- * include pieces of boundary, connecting the lines, forming an accordion like zigzag instead of separate lines    |_|^|_|
- * 
- * we call the areas between two consecutive scanlines a 'scansegment'
- * 
+/* 
  * algorithm:
  * 1. for each line segment of each polygon:
  *      store the intersections of that line segment with all scanlines in a mapping (vector of vectors) from scanline to intersections
@@ -239,288 +144,119 @@ void generateZigZagInfill(const Polygons& in_outline, Polygons& result, int extr
  *      sort the associated intersections 
  *      and connect them using the even-odd rule
  * 
- * zigzag algorithm:
+ * rough explanation of the zigzag algorithm:
  * while walking around (each) polygon (1.)
  *  if polygon intersects with even scanline
  *      start boundary segment (add each following segment to the [result])
  *  when polygon intersects with a scanline again
  *      stop boundary segment (stop adding segments to the [result])
- *      if polygon intersects with even scanline again (instead of odd)
- *          dont add the last line segment to the boundary (unless [connect_zigzags])
+ *  (see infill/ZigzagConnectorProcessor.h for actual implementation details)
  * 
  * 
- *     <--
- *     ___
- *    |   |   |
- *    |   |   |
- *    |   |___|
- *         -->
- * 
- *        ^ = even scanline
- * 
- * start boundary from even scanline! :D
- * 
- * 
- *          _____
- *   |     |     | ,
- *   |     |     |  |
- *   |_____|     |__/
- * 
- *   ^     ^     ^    scanlines
- *                 ^  disconnected end piece
+ * we call the areas between two consecutive scanlines a 'scansegment'.
+ * Scansegment x is the area between scanline x and scanline x+1
+ * Edit: the term scansegment is wrong, since I call a boundary segment leaving from an even scanline to the left as belonging to an even scansegment, 
+ *  while I also call a boundary segment leaving from an even scanline toward the right as belonging to an even scansegment.
  */
-void generateZigZagIninfill_endPieces(const Polygons& in_outline, Polygons& result, int extrusionWidth, int lineSpacing, double infillOverlap, double rotation, bool connect_zigzags)
+void Infill::generateLinearBasedInfill(const int outline_offset, bool safe_outline_offset, Polygons& result, const int line_distance, const PointMatrix& rotation_matrix, ZigzagConnectorProcessor& zigzag_connector_processor, const bool connected_zigzags)
 {
-//     if (in_outline.size() == 0) return;
-//     Polygons outline = in_outline.offset(extrusionWidth * infillOverlap / 100 - extrusionWidth / 2);
-    Polygons empty;
-    Polygons outline = in_outline.difference(empty); // copy
-    if (outline.size() == 0) return;
-    
-    PointMatrix matrix(rotation);
-    
-    outline.applyMatrix(matrix);
-    
-    auto addLine = [&](Point from, Point to)
-    {            
-        PolygonRef p = result.newPoly();
-        p.add(matrix.unapply(from));
-        p.add(matrix.unapply(to));
-    };   
-        
-    AABB boundary(outline);
-    
-    int scanline_min_idx = boundary.min.X / lineSpacing;
-    int lineCount = (boundary.max.X + (lineSpacing - 1)) / lineSpacing - scanline_min_idx;
-    
-    std::vector<std::vector<int64_t> > cutList; // mapping from scanline to all intersections with polygon segments
-    
-    for(int n=0; n<lineCount; n++)
-        cutList.push_back(std::vector<int64_t>());
-    for(unsigned int polyNr=0; polyNr < outline.size(); polyNr++)
+    if (line_distance == 0)
     {
-        std::vector<Point> firstBoundarySegment;
-        std::vector<Point> unevenBoundarySegment; // stored cause for connected_zigzags a boundary segment which ends in an uneven scanline needs to be included
-        
-        bool isFirstBoundarySegment = true;
-        bool firstBoundarySegmentEndsInEven;
-        
-        bool isEvenScanSegment = false; 
-        
-        
-        Point p0 = outline[polyNr][outline[polyNr].size()-1];
-        Point lastPoint = p0;
-        for(unsigned int i=0; i < outline[polyNr].size(); i++)
+        return;
+    }
+    if (in_outline.size() == 0)
+    {
+        return;
+    }
+    
+    Polygons outline;
+    if (outline_offset != 0)
+    {
+        outline = in_outline.offset(outline_offset);
+    }
+    else
+    {
+        outline = in_outline;
+    }
+    
+        outline = outline.offset(infill_overlap);
+    
+    if (outline.size() == 0)
+    {
+        return;
+    }
+
+    outline.applyMatrix(rotation_matrix);
+
+    AABB boundary(outline);
+
+    int scanline_min_idx = boundary.min.X / line_distance;
+    int line_count = (boundary.max.X + (line_distance - 1)) / line_distance - scanline_min_idx;
+
+    std::vector<std::vector<int64_t> > cut_list; // mapping from scanline to all intersections with polygon segments
+
+    for(int scanline_idx = 0; scanline_idx < line_count; scanline_idx++)
+    {
+        cut_list.push_back(std::vector<int64_t>());
+    }
+
+    for(unsigned int poly_idx = 0; poly_idx < outline.size(); poly_idx++)
+    {
+        PolygonRef poly = outline[poly_idx];
+        Point p0 = poly.back();
+        zigzag_connector_processor.registerVertex(p0); // always adds the first point to ZigzagConnectorProcessorEndPieces::first_zigzag_connector when using a zigzag infill type
+        for(unsigned int point_idx = 0; point_idx < poly.size(); point_idx++)
         {
-            Point p1 = outline[polyNr][i];
-            int64_t xMin = p1.X, xMax = p0.X;
-            if (xMin == xMax) {
-                lastPoint = p1;
+            Point p1 = poly[point_idx];
+            if (p1.X == p0.X)
+            {
+                zigzag_connector_processor.registerVertex(p1); 
+                // TODO: how to make sure it always adds the shortest line? (in order to prevent overlap with the zigzag connectors)
+                // note: this is already a problem for normal infill, but hasn't really cothered anyone so far.
                 p0 = p1;
                 continue; 
             }
-            if (xMin > xMax) { xMin = p0.X; xMax = p1.X; }
-            
-            int scanline_idx0 = (p0.X + ((p0.X > 0)? -1 : -lineSpacing)) / lineSpacing; // -1 cause a linesegment on scanline x counts as belonging to scansegment x-1   ...
-            int scanline_idx1 = (p1.X + ((p1.X > 0)? -1 : -lineSpacing)) / lineSpacing; // -linespacing because a line between scanline -n and -n-1 belongs to scansegment -n-1 (for n=positive natural number)
+
+            int scanline_idx0 = (p0.X + ((p0.X > 0)? -1 : -line_distance)) / line_distance; // -1 cause a linesegment on scanline x counts as belonging to scansegment x-1   ...
+            int scanline_idx1 = (p1.X + ((p1.X > 0)? -1 : -line_distance)) / line_distance; // -linespacing because a line between scanline -n and -n-1 belongs to scansegment -n-1 (for n=positive natural number)
+            // this way of handling the indices takes care of the case where a boundary line segment ends exactly on a scanline:
+            // in case the next segment moves back from that scanline either 2 or 0 scanline-boundary intersections are created
+            // otherwise only 1 will be created, counting as an actual intersection
             int direction = 1;
             if (p0.X > p1.X) 
             { 
                 direction = -1; 
                 scanline_idx1 += 1; // only consider the scanlines in between the scansegments
-            } else scanline_idx0 += 1; // only consider the scanlines in between the scansegments
-            
-            
-            if (isFirstBoundarySegment) firstBoundarySegment.push_back(p0);
-            for(int scanline_idx = scanline_idx0; scanline_idx != scanline_idx1+direction; scanline_idx+=direction)
+            }
+            else
             {
-                int x = scanline_idx * lineSpacing;
+                scanline_idx0 += 1; // only consider the scanlines in between the scansegments
+            }
+
+            for(int scanline_idx = scanline_idx0; scanline_idx != scanline_idx1 + direction; scanline_idx += direction)
+            {
+                int x = scanline_idx * line_distance;
                 int y = p1.Y + (p0.Y - p1.Y) * (x - p1.X) / (p0.X - p1.X);
-                cutList[scanline_idx - scanline_min_idx].push_back(y);
-                
-                
-                bool last_isEvenScanSegment = isEvenScanSegment;
-                if (scanline_idx % 2 == 0) isEvenScanSegment = true;
-                else isEvenScanSegment = false;
-                
-                if (!isFirstBoundarySegment)
-                {
-                    if (last_isEvenScanSegment && (connect_zigzags || !isEvenScanSegment))
-                        addLine(lastPoint, Point(x,y));
-                    else if (connect_zigzags && !last_isEvenScanSegment && !isEvenScanSegment) // if we end an uneven boundary in an uneven segment
-                    { // add whole unevenBoundarySegment (including the just obtained point)
-                        for (unsigned int p = 1; p < unevenBoundarySegment.size(); p++)
-                        {
-                            addLine(unevenBoundarySegment[p-1], unevenBoundarySegment[p]);
-                        }
-                        addLine(unevenBoundarySegment[unevenBoundarySegment.size()-1], Point(x,y));
-                        unevenBoundarySegment.clear();
-                    } 
-                    if (connect_zigzags && last_isEvenScanSegment && !isEvenScanSegment)
-                        unevenBoundarySegment.push_back(Point(x,y));
-                    else 
-                        unevenBoundarySegment.clear();
-                        
-                }
-                lastPoint = Point(x,y);
-                
-                if (isFirstBoundarySegment) 
-                {
-                    firstBoundarySegment.emplace_back(x,y);
-                    firstBoundarySegmentEndsInEven = isEvenScanSegment;
-                    isFirstBoundarySegment = false;
-                }
-                
+                cut_list[scanline_idx - scanline_min_idx].push_back(y);
+                Point scanline_linesegment_intersection(x, y);
+                zigzag_connector_processor.registerScanlineSegmentIntersection(scanline_linesegment_intersection, scanline_idx % 2 == 0);
             }
-            if (!isFirstBoundarySegment)
-            {
-                if (isEvenScanSegment)
-                    addLine(lastPoint, p1);
-                else if (connect_zigzags)
-                    unevenBoundarySegment.push_back(p1);
-            }
-            
-            lastPoint = p1;
+            zigzag_connector_processor.registerVertex(p1);
             p0 = p1;
         }
-        
-        if (isEvenScanSegment || isFirstBoundarySegment || connect_zigzags)
-        {
-            for (unsigned int i = 1; i < firstBoundarySegment.size() ; i++)
-            {
-                if (i < firstBoundarySegment.size() - 1 || !firstBoundarySegmentEndsInEven || connect_zigzags) // only add last element if connect_zigzags or boundary segment ends in uneven scanline
-                    addLine(firstBoundarySegment[i-1], firstBoundarySegment[i]);
-            }   
-        }
-        else if (!firstBoundarySegmentEndsInEven)
-            addLine(firstBoundarySegment[firstBoundarySegment.size()-2], firstBoundarySegment[firstBoundarySegment.size()-1]);
-    } 
-    
-    if (cutList.size() == 0) return;
-    if (connect_zigzags && cutList.size() == 1 && cutList[0].size() <= 2) return;  // don't add connection if boundary already contains whole outline!
-    
-    addLineInfill(result, matrix, scanline_min_idx, lineSpacing, boundary, cutList, extrusionWidth);
-}
+        zigzag_connector_processor.registerPolyFinished();
+    }
 
-
-void generateZigZagIninfill_noEndPieces(const Polygons& in_outline, Polygons& result, int extrusionWidth, int lineSpacing, double infillOverlap, double rotation)
-{
-    if (in_outline.size() == 0) return;
-    Polygons outline = in_outline.offset(extrusionWidth * infillOverlap / 100 - extrusionWidth / 2);
-    if (outline.size() == 0) return;
-    
-    PointMatrix matrix(rotation);
-    
-    outline.applyMatrix(matrix);
-    
-    auto addLine = [&](Point from, Point to)
-    {            
-        PolygonRef p = result.newPoly();
-        p.add(matrix.unapply(from));
-        p.add(matrix.unapply(to));
-    };   
-        
-    AABB boundary(outline);
-    
-    int scanline_min_idx = boundary.min.X / lineSpacing;
-    int lineCount = (boundary.max.X + (lineSpacing - 1)) / lineSpacing - scanline_min_idx;
-    
-    std::vector<std::vector<int64_t> > cutList; // mapping from scanline to all intersections with polygon segments
-    
-    for(int n=0; n<lineCount; n++)
-        cutList.push_back(std::vector<int64_t>());
-    for(unsigned int polyNr=0; polyNr < outline.size(); polyNr++)
+    if (cut_list.size() == 0)
     {
-        std::vector<Point> firstBoundarySegment;
-        std::vector<Point> boundarySegment;
-        
-        bool isFirstBoundarySegment = true;
-        bool firstBoundarySegmentEndsInEven;
-        
-        bool isEvenScanSegment = false; 
-        
-        
-        Point p0 = outline[polyNr][outline[polyNr].size()-1];
-        for(unsigned int i=0; i < outline[polyNr].size(); i++)
-        {
-            Point p1 = outline[polyNr][i];
-            int64_t xMin = p1.X, xMax = p0.X;
-            if (xMin == xMax) {
-                p0 = p1;
-                continue; 
-            }
-            if (xMin > xMax) { xMin = p0.X; xMax = p1.X; }
-            
-            int scanline_idx0 = (p0.X + ((p0.X > 0)? -1 : -lineSpacing)) / lineSpacing; // -1 cause a linesegment on scanline x counts as belonging to scansegment x-1   ...
-            int scanline_idx1 = (p1.X + ((p1.X > 0)? -1 : -lineSpacing)) / lineSpacing; // -linespacing because a line between scanline -n and -n-1 belongs to scansegment -n-1 (for n=positive natural number)
-            int direction = 1;
-            if (p0.X > p1.X) 
-            { 
-                direction = -1; 
-                scanline_idx1 += 1; // only consider the scanlines in between the scansegments
-            } else scanline_idx0 += 1; // only consider the scanlines in between the scansegments
-            
-            
-            if (isFirstBoundarySegment) firstBoundarySegment.push_back(p0);
-            else boundarySegment.push_back(p0);
-            for(int scanline_idx = scanline_idx0; scanline_idx != scanline_idx1+direction; scanline_idx+=direction)
-            {
-                int x = scanline_idx * lineSpacing;
-                int y = p1.Y + (p0.Y - p1.Y) * (x - p1.X) / (p0.X - p1.X);
-                cutList[scanline_idx - scanline_min_idx].push_back(y);
-                
-                
-                bool last_isEvenScanSegment = isEvenScanSegment;
-                if (scanline_idx % 2 == 0) isEvenScanSegment = true;
-                else isEvenScanSegment = false;
-                
-                if (!isFirstBoundarySegment)
-                {
-                    if (last_isEvenScanSegment && !isEvenScanSegment)
-                    { // add whole boundarySegment (including the just obtained point)
-                        for (unsigned int p = 1; p < boundarySegment.size(); p++)
-                        {
-                            addLine(boundarySegment[p-1], boundarySegment[p]);
-                        }
-                        addLine(boundarySegment[boundarySegment.size()-1], Point(x,y));
-                        boundarySegment.clear();
-                    } 
-                    else if (isEvenScanSegment) // we are either in an end piece or an uneven boundary segment
-                    {
-                        boundarySegment.clear();
-                        boundarySegment.emplace_back(x,y);
-                    } else
-                        boundarySegment.clear();
-                        
-                }
-                
-                if (isFirstBoundarySegment) 
-                {
-                    firstBoundarySegment.emplace_back(x,y);
-                    firstBoundarySegmentEndsInEven = isEvenScanSegment;
-                    isFirstBoundarySegment = false;
-                    boundarySegment.emplace_back(x,y);
-                }
-                
-            }
-            if (!isFirstBoundarySegment && isEvenScanSegment)
-                boundarySegment.push_back(p1);
-            
-            
-            p0 = p1;
-        }
-        
-        if (!isFirstBoundarySegment && isEvenScanSegment && !firstBoundarySegmentEndsInEven)
-        {
-            for (unsigned int i = 1; i < firstBoundarySegment.size() ; i++)
-                addLine(firstBoundarySegment[i-1], firstBoundarySegment[i]);
-        }
-    } 
-    
-
-    addLineInfill(result, matrix, scanline_min_idx, lineSpacing, boundary, cutList, extrusionWidth);
+        return;
+    }
+    if (connected_zigzags && cut_list.size() == 1 && cut_list[0].size() <= 2)
+    {
+        return;  // don't add connection if boundary already contains whole outline!
+    }
 
+    addLineInfill(result, rotation_matrix, scanline_min_idx, line_distance, boundary, cut_list);
 }
 
-
 }//namespace cura

src/infill.h

@@ -3,49 +3,169 @@
 #define INFILL_H
 
 #include "utils/polygon.h"
-#include "settings.h"
+#include "settings/settings.h"
+// #include "ZigzagConnectorProcessor.h"
+#include "infill/ZigzagConnectorProcessor.h"
+#include "infill/NoZigZagConnectorProcessor.h"
+#include "infill/ActualZigzagConnectorProcessor.h"
+#include "infill/ZigzagConnectorProcessorNoEndPieces.h"
+#include "infill/ZigzagConnectorProcessorEndPieces.h"
+#include "infill/ZigzagConnectorProcessorConnectedEndPieces.h"
+#include "infill/ZigzagConnectorProcessorDisconnectedEndPieces.h"
+#include "utils/intpoint.h"
+#include "utils/AABB.h"
 
-namespace cura {
+namespace cura
+{
 
 class Infill 
 {
-    EFillMethod pattern;
-    const Polygons& in_outline;
-    int outlineOffset;
-    bool avoidOverlappingPerimeters;
-    int extrusion_width;
-    int line_distance;
-    double infill_overlap;
-    double fill_angle;
-    bool connect_zigzags;
-    bool use_endPieces;
+    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
+    int infill_line_width; //!< The line width of the infill lines to generate
+    int line_distance; //!< The distance between two infill lines / polygons
+    int infill_overlap; //!< the distance by which to overlap with the actual area within which to generate infill
+    double fill_angle; //!< for linear infill types: the angle of the infill lines (or the angle of the grid)
+    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
 
 public:
-    Infill(EFillMethod pattern, const Polygons& in_outline, int outlineOffset, bool avoidOverlappingPerimeters, int extrusion_width, int line_distance, double infill_overlap, double fill_angle, bool connect_zigzags, bool use_endPieces)
+    Infill(EFillMethod pattern, const Polygons& in_outline, int outline_offset, int infill_line_width, int line_distance, int infill_overlap, double fill_angle, bool connected_zigzags = false, bool use_endpieces = false)
     : pattern(pattern)
     , in_outline(in_outline)
-    , outlineOffset(outlineOffset)
-    , avoidOverlappingPerimeters(avoidOverlappingPerimeters)
-    , extrusion_width(extrusion_width)
+    , outline_offset(outline_offset)
+    , infill_line_width(infill_line_width)
     , line_distance(line_distance)
     , infill_overlap(infill_overlap)
     , fill_angle(fill_angle)
-    , connect_zigzags(connect_zigzags)
-    , use_endPieces(use_endPieces)
+    , connected_zigzags(connected_zigzags)
+    , use_endpieces(use_endpieces)
     {
     }
-    void generate(Polygons& result_polygons, Polygons& result_lines, Polygons* in_between);
-};
+    /*!
+     * Generate the infill.
+     * 
+     * \param result_polygons (output) The resulting polygons (from concentric infill)
+     * \param result_lines (output) The resulting line segments (from linear infill types)
+     */
+    void generate(Polygons& result_polygons, Polygons& result_lines);
+
+private:
+
+    /*!
+     * 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 generateConcentricInfill(Polygons outline, Polygons& result, int inset_value);
+
+    /*!
+     * Generate a rectangular grid of infill lines
+     * \param result (output) The resulting lines
+     */
+    void generateGridInfill(Polygons& result);
+
+    /*!
+     * Generate a triangular grid of infill lines
+     * \param result (output) The resulting lines
+     */
+    void generateTriangleInfill(Polygons& result);
     
-void generateInfill(EFillMethod pattern, const Polygons& in_outline, int outlineOffset, Polygons& result_polygons, Polygons& result_lines, Polygons* in_between, bool avoidOverlappingPerimeters, int extrusion_width, int line_distance, double infill_overlap, double fill_angle, bool connect_zigzags, bool use_endPieces);
-void generateConcentricInfill(Polygons outline, Polygons& result, int inset_value);
-void generateConcentricInfillDense(Polygons outline, Polygons& result, Polygons* in_between, int extrusionWidth, bool avoidOverlappingPerimeters);
-void generateGridInfill(const Polygons& in_outline, int outlineOffset, Polygons& result, int extrusionWidth, int lineSpacing, double infillOverlap, double rotation);
-void generateTriangleInfill(const Polygons& in_outline, int outlineOffset, Polygons& result, int extrusionWidth, int lineSpacing, double infillOverlap, double rotation);
-void generateLineInfill(const Polygons& in_outline, int outlineOffset, Polygons& result, int extrusionWidth, int lineSpacing, double infillOverlap, double rotation);
-void generateZigZagInfill(const Polygons& in_outline, Polygons& result, int extrusionWidth, int lineSpacing, double infillOverlap, double rotation, bool connect_zigzags, bool use_endPieces);
-void generateZigZagIninfill_endPieces(const Polygons& in_outline, Polygons& result, int extrusionWidth, int lineSpacing, double infillOverlap, double rotation, bool connect_zigzags);
-void generateZigZagIninfill_noEndPieces(const Polygons& in_outline, Polygons& result, int extrusionWidth, int lineSpacing, double infillOverlap, double rotation);
+    /*!
+     * 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
+     * \param rotation_matrix The rotation matrix (un)applied to enforce the angle of the infill 
+     * \param scanline_min_idx The lowest index of all scanlines crossing the polygon
+     * \param line_distance The distance between two lines which are in the same direction
+     * \param boundary The axis aligned boundary box within which the polygon is
+     * \param cut_list A mapping of each scanline to all y-coordinates (in the space transformed by rotation_matrix) where the polygons are crossing the scanline
+     */
+    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);
+
+    /*!
+     * generate lines within the area of \p in_outline, at regular intervals of \p line_distance
+     * 
+     * idea:
+     * intersect a regular grid of 'scanlines' with the area inside \p in_outline
+     * 
+     * \param result (output) The resulting lines
+     * \param line_distance The distance between two lines which are in the same direction
+     * \param fill_angle The angle of the generated lines
+     */
+    void generateLineInfill(Polygons& result, int line_distance, const double& fill_angle);
+    
+    /*!
+     * Function for creating linear based infill types (Lines, ZigZag).
+     * 
+     * This function implements the basic functionality of Infill::generateLineInfill (see doc of that function),
+     * but makes calls to a ZigzagConnectorProcessor which handles what to do with each line segment - scanline intersection.
+     * 
+     * It is called only from Infill::generateLineinfill and Infill::generateZigZagInfill.
+     * 
+     * \param outline_offset An offset from the reference polygon (Infill::in_outline) to get the actual outline within which to generate infill
+     * \param safe_outline_offset Whether to consider removing overlapping wall parts (not so for normal line infill)
+     * \param result (output) The resulting lines
+     * \param line_distance The distance between two lines which are in the same direction
+     * \param rotation_matrix The rotation matrix (un)applied to enforce the angle of the infill 
+     * \param zigzag_connector_processor The processor used to generate zigzag connectors
+     * \param connected_zigzags Whether to connect the endpiece zigzag segments on both sides to the same infill line
+     */
+    void generateLinearBasedInfill(const int outline_offset, bool safe_outline_offset, Polygons& result, const int line_distance, const PointMatrix& rotation_matrix, ZigzagConnectorProcessor& zigzag_connector_processor, const bool connected_zigzags);
+
+    /*!
+     * 
+     * generate lines within the area of [in_outline], at regular intervals of [line_distance]
+     * idea:
+     * intersect a regular grid of 'scanlines' with the area inside [in_outline] (see generateLineInfill)
+     * zigzag:
+     * include pieces of boundary, connecting the lines, forming an accordion like zigzag instead of separate lines    |_|^|_|
+     * 
+     * Note that ZigZag consists of 3 types:
+     * - without endpieces
+     * - with disconnected endpieces
+     * - with connected endpieces
+     * 
+     *     <--
+     *     ___
+     *    |   |   |
+     *    |   |   |
+     *    |   |___|
+     *         -->
+     * 
+     *        ^ = even scanline
+     *  ^            ^ no endpieces
+     * 
+     * start boundary from even scanline! :D
+     * 
+     * 
+     *                 v  disconnected end piece: leave out last line segment
+     *          _____
+     *   |     |     |  \                     .
+     *   |     |     |  |
+     *   |_____|     |__/
+     * 
+     *   ^     ^     ^    scanlines
+     * 
+     * 
+     *                 v  connected end piece
+     *          ________
+     *   |     |     |  \                      .
+     *   |     |     |  |
+     *   |_____|     |__/                       .
+     * 
+     *   ^     ^     ^    scanlines
+     * 
+     * \param result (output) The resulting lines
+     * \param line_distance The distance between two lines which are in the same direction
+     * \param fill_angle The angle of the generated lines
+     * \param connected_zigzags Whether to connect the endpiece zigzag segments on both sides to the same infill line
+     * \param use_endpieces Whether to include zigzag segments connecting a scanline to itself
+     */
+    void generateZigZagInfill(Polygons& result, const int line_distance, const double& fill_angle, const bool connected_zigzags, const bool use_endpieces);
+};
+
 }//namespace cura
 
 #endif//INFILL_H

src/infill/ActualZigzagConnectorProcessor.h

@@ -0,0 +1,47 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#ifndef INFILL_ACTUAL_ZIGZAG_CONNECTOR_PROCESSOR_H
+#define INFILL_ACTUAL_ZIGZAG_CONNECTOR_PROCESSOR_H
+
+
+#include "../utils/polygon.h"
+#include "ZigzagConnectorProcessor.h"
+#include "../utils/intpoint.h"
+
+namespace cura
+{
+
+/*!
+ * In contrast to NoZigZagConnectorProcessor
+ */
+class ActualZigzagConnectorProcessor : public ZigzagConnectorProcessor
+{
+protected:
+    /*!
+     * The line segments belonging the zigzag connector to which the very first vertex belongs. 
+     * This will be combined with the last handled zigzag_connector, which combine to a whole zigzag connector.
+     * 
+     * Because the boundary polygon may start in in the middle of a zigzag connector, 
+     */
+    std::vector<Point> first_zigzag_connector; 
+    /*!
+     * The currently built up zigzag connector (not the first/last) or end piece or discarded boundary segment
+     */
+    std::vector<Point> zigzag_connector; 
+
+    bool is_first_zigzag_connector; //!< Whether we're still in the first zigzag connector
+    bool first_zigzag_connector_ends_in_even_scanline; //!< Whether the first zigzag connector ends in an even scanline
+    bool last_scanline_is_even;  //!< Whether the last seen scanline-boundary intersection was with an even scanline
+
+    ActualZigzagConnectorProcessor(const PointMatrix& rotation_matrix, Polygons& result)
+    : ZigzagConnectorProcessor(rotation_matrix, result)
+    , is_first_zigzag_connector(true)
+    , first_zigzag_connector_ends_in_even_scanline(true)
+    , last_scanline_is_even(false) 
+    {
+    }
+};
+
+} // namespace cura
+
+
+#endif // INFILL_ACTUAL_ZIGZAG_CONNECTOR_PROCESSOR_H

src/infill/NoZigZagConnectorProcessor.cpp

@@ -0,0 +1,25 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#include "NoZigZagConnectorProcessor.h"
+
+
+namespace cura 
+{
+
+void NoZigZagConnectorProcessor::registerVertex(const Point& vertex)
+{
+
+}
+
+void NoZigZagConnectorProcessor::registerScanlineSegmentIntersection(const Point& intersection, bool scanline_is_even)
+{
+
+}
+
+void NoZigZagConnectorProcessor::registerPolyFinished()
+{
+
+}
+
+
+
+} // namespace cura 

src/infill/NoZigZagConnectorProcessor.h

@@ -0,0 +1,28 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#ifndef INFILL_NO_ZIGZAG_CONNECTOR_PROCESSOR_H
+#define INFILL_NO_ZIGZAG_CONNECTOR_PROCESSOR_H
+
+#include "../utils/polygon.h"
+#include "ZigzagConnectorProcessor.h"
+
+namespace cura
+{
+
+class NoZigZagConnectorProcessor : public ZigzagConnectorProcessor
+{
+public:
+    NoZigZagConnectorProcessor(const PointMatrix& rotation_matrix, Polygons& result)
+    : ZigzagConnectorProcessor(rotation_matrix, result)
+    {
+    }
+
+    void registerVertex(const Point& vertex);
+    void registerScanlineSegmentIntersection(const Point& intersection, bool scanline_is_even);
+    void registerPolyFinished();
+};
+
+
+} // namespace cura
+
+
+#endif // INFILL_NO_ZIGZAG_CONNECTOR_PROCESSOR_H

src/infill/ZigzagConnectorProcessor.h

@@ -0,0 +1,154 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#ifndef INFILL_ZIGZAG_CONNECTOR_PROCESSOR_H
+#define INFILL_ZIGZAG_CONNECTOR_PROCESSOR_H
+
+#include "../utils/polygon.h"
+
+namespace cura
+{
+
+/*!
+ * Processor class for processing the connections between lines which makes the infill a zigzag pattern.
+ * 
+ * During the creation of the infill lines, calls are made to a ZigzagConnectorProcessor so that the zigzag connector segments are created 
+ * at the same time as the lines are created.
+ *
+ * generate lines within the area of [in_outline], at regular intervals of [line_distance]
+ *  idea:
+ * intersect a regular grid of 'scanlines' with the area inside [in_outline] (see generateLineInfill)
+ * zigzag:
+ * include pieces of boundary, connecting the lines, forming an accordion like zigzag instead of separate lines    |_|^|_|
+ * 
+ * we call the areas between two consecutive scanlines a 'scansegment'
+ * 
+ * algorithm:
+ * 1. for each line segment of each polygon:
+ *      store the intersections of that line segment with all scanlines in a mapping (vector of vectors) from scanline to intersections
+ *      (zigzag): add boundary segments to result
+ * 2. for each scanline:
+ *      sort the associated intersections 
+ *      and connect them using the even-odd rule
+ * 
+ * zigzag algorithm:
+ *  while walking around (each) polygon (1.)
+ *  if polygon intersects with even scanline
+ *      start boundary segment (add each following segment to the [result])
+ *  when polygon intersects with a scanline again
+ *      stop boundary segment (stop adding segments to the [result])
+ *      if polygon intersects with even scanline again (instead of odd)
+ *           dont add the last line segment to the boundary (unless [connected_zigzags])
+ * 
+ * Note that ZigZag consists of 3 types:
+ * - without endpieces
+ * - with disconnected endpieces
+ * - with connected endpieces
+ * 
+ * Each of these has a base class for which ZigzagConnectorProcessor is an ancestor.
+ * The inheritance structure is as such:
+ *                                                                      ZigzagConnectorProcessor
+ *                                                                           /             \                                    .
+ *                                                                          /               \                                   .
+ *                                                  ActualZigzagConnectorProcessor      NoZigZagConnectorProcessor
+ *                                                         /                \             for lines infill                                      .
+ *                                                        /                  \                                                  .
+ *                          ZigzagConnectorProcessorEndPieces   ZigzagConnectorProcessorNoEndPieces
+ *                                     /            \                 for zigzag infill (without end pieces)                                                          .
+ *                                    /              \                                                                          .
+ * ZigzagConnectorProcessorConnectedEndPieces     ZigzagConnectorProcessorDisconnectedEndPieces
+ * for zigzag support with normal endpieces          for zigzag support with disconnected endpieces for more easy removability
+ * 
+ *      v   v   zigzag connectors
+ *     <--
+ *    :___:   :      < scanlines
+ *    |   |   |
+ *    |   |   |      < infill lines along scanlines
+ *    |   |___|
+ *    :   :   :
+ *         -->       winding order of polygon
+ * 
+ *        ^ = even scanline
+ *  ^            ^ no endpieces
+ * 
+ * start boundary from even scanline! :D
+ * include only a boundary segment if it starts in an even scanline and ends in an odd scanline
+ * 
+ *          ________
+ *   |     |     |  \                      .
+ *   |     |     |  |
+ *   |_____|     |__/                       .
+ * 
+ *   ^     ^     ^    scanlines
+ *                 ^  connected end piece
+ * include a boundary segment also if it starts in an odd scanline and ends odd, 
+ * or starts in an even scanline and ends in an even scanline,
+ * but not when it starts in an odd and ends in an even scanline (see top left or bottom middle).
+ * 
+ *          _____
+ *   |     |     |  \                     .
+ *   |     |     |  |
+ *   |_____|     |__/
+ * 
+ *   ^     ^     ^    scanlines
+ *                 ^  disconnected end piece
+ * Leave out the last line segment of the boundary polygon: from a vertex to the linesegment-scanline intersection.
+ */
+class ZigzagConnectorProcessor 
+{
+protected:
+    const PointMatrix& rotation_matrix; //!< The rotation matrix used to enforce the infill angle
+    Polygons& result; //!< The result of the computation
+
+    virtual ~ZigzagConnectorProcessor()
+    {}
+
+    /*!
+     * Add a line to the result bu unapplying the rotation rotation_matrix.
+     * 
+     * \param from The one end of the line segment
+     * \param to The other end of the line segment
+     */
+    void addLine(Point from, Point to)
+    {
+        PolygonRef line_poly = result.newPoly();
+        line_poly.add(rotation_matrix.unapply(from));
+        line_poly.add(rotation_matrix.unapply(to));
+    }
+
+    /*!
+     * Basic constructor. Inheriting children should call this constructor.
+     * 
+     * \param rotation_matrix The rotation matrix used to enforce the infill angle
+     * \param result The resulting line segments (Each line segment is a Polygon with 2 points)
+     */
+    ZigzagConnectorProcessor(const PointMatrix& rotation_matrix, Polygons& result)
+    : rotation_matrix(rotation_matrix)
+    , result(result)
+    {}
+public:
+
+    /*!
+     * Handle the next vertex on the outer boundary.
+     * \param vertex The vertex
+     */
+    virtual void registerVertex(const Point& vertex) = 0;
+    
+    /*!
+     * Handle the next intersection between a scanline and the outer boundary.
+     * 
+     * \param intersection The intersection
+     * \param scanline_is_even Whether the scanline was even
+     */
+    virtual void registerScanlineSegmentIntersection(const Point& intersection, bool scanline_is_even) = 0;
+    
+    /*!
+     * Handle the end of a polygon and prepare for the next.
+     * This function should reset all member variables.
+     */
+    virtual void registerPolyFinished() = 0;
+};
+
+
+} // namespace cura
+
+
+#endif // INFILL_ZIGZAG_CONNECTOR_PROCESSOR_H

src/infill/ZigzagConnectorProcessorConnectedEndPieces.cpp

@@ -0,0 +1,75 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#include "ZigzagConnectorProcessorConnectedEndPieces.h"
+
+
+namespace cura 
+{
+
+
+void ZigzagConnectorProcessorConnectedEndPieces::registerScanlineSegmentIntersection(const Point& intersection, bool scanline_is_even)
+{
+    bool previous_scanline_is_even = last_scanline_is_even;
+    last_scanline_is_even = scanline_is_even;
+    bool this_scanline_is_even = last_scanline_is_even;
+    
+    if (is_first_zigzag_connector)
+    {
+        first_zigzag_connector.push_back(intersection);
+        first_zigzag_connector_ends_in_even_scanline = this_scanline_is_even;
+        is_first_zigzag_connector = false;
+    }
+    else
+    {
+        if (previous_scanline_is_even)
+        { // when a boundary segment starts in an even scanline it is either a normal zigzag connector or an endpiece, so it should be included anyway
+            addLine(last_connector_point, intersection);
+        }
+        else if (!previous_scanline_is_even && !this_scanline_is_even) // if we end an odd boundary in an odd segment
+        { // add whole zigzag_connector (including the just obtained point)
+            for (unsigned int point_idx = 1; point_idx < zigzag_connector.size(); point_idx++)
+            {
+                addLine(zigzag_connector[point_idx - 1], zigzag_connector[point_idx]);
+            }
+            addLine(zigzag_connector.back(), intersection);
+            zigzag_connector.clear();
+        }
+
+    }
+    zigzag_connector.clear(); // we're starting a new (odd) zigzag connector, so clear the old one
+    if (!this_scanline_is_even) // we are either in an end piece or an boundary segment starting in an odd scanline
+    { // only when a boundary segment starts in an odd scanline it depends on whether it ends in an odd scanline for whether this segment should be included or not
+        zigzag_connector.push_back(intersection);
+    }
+
+    last_connector_point = intersection;
+}
+
+
+void ZigzagConnectorProcessorConnectedEndPieces::registerPolyFinished()
+{
+    // write end segment if needed (first half of start/end-crossing segment)
+    if (!last_scanline_is_even && !first_zigzag_connector_ends_in_even_scanline)
+    {
+        for (unsigned int point_idx = 1; point_idx < zigzag_connector.size(); point_idx++)
+        {
+            addLine(zigzag_connector[point_idx - 1], zigzag_connector[point_idx]);
+        }
+    }
+    // write begin segment if needed (second half of start/end-crossing segment)
+    if (last_scanline_is_even || (!last_scanline_is_even && !first_zigzag_connector_ends_in_even_scanline)
+        || is_first_zigzag_connector)
+    {
+        for (unsigned int point_idx = 1; point_idx < first_zigzag_connector.size(); point_idx++)
+        {
+            addLine(first_zigzag_connector[point_idx - 1], first_zigzag_connector[point_idx]);
+        }
+    }
+    // reset member variables
+    is_first_zigzag_connector = true;
+    first_zigzag_connector_ends_in_even_scanline = true;
+    last_scanline_is_even = false; 
+    first_zigzag_connector.clear();
+    zigzag_connector.clear();
+}
+
+} // namespace cura 

src/infill/ZigzagConnectorProcessorConnectedEndPieces.h

@@ -0,0 +1,27 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#ifndef INFILL_ZIGZAG_CONNECTOR_PROCESSOR_CONNECTED_END_PIECES_H
+#define INFILL_ZIGZAG_CONNECTOR_PROCESSOR_CONNECTED_END_PIECES_H
+
+#include "../utils/polygon.h"
+#include "ZigzagConnectorProcessorEndPieces.h"
+#include "../utils/intpoint.h"
+
+namespace cura
+{
+
+
+class ZigzagConnectorProcessorConnectedEndPieces : public ZigzagConnectorProcessorEndPieces
+{
+public:
+    ZigzagConnectorProcessorConnectedEndPieces(const PointMatrix& rotation_matrix, Polygons& result)
+    : ZigzagConnectorProcessorEndPieces(rotation_matrix, result)
+    {
+    }
+    void registerScanlineSegmentIntersection(const Point& intersection, bool scanline_is_even);
+    void registerPolyFinished();
+};
+
+} // namespace cura
+
+
+#endif // INFILL_ZIGZAG_CONNECTOR_PROCESSOR_CONNECTED_END_PIECES_H

src/infill/ZigzagConnectorProcessorDisconnectedEndPieces.cpp

@@ -0,0 +1,79 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#include "ZigzagConnectorProcessorDisconnectedEndPieces.h"
+
+
+namespace cura 
+{
+
+void ZigzagConnectorProcessorDisconnectedEndPieces::registerScanlineSegmentIntersection(const Point& intersection, bool scanline_is_even)
+{
+    bool previous_scanline_is_even = last_scanline_is_even;
+    last_scanline_is_even = scanline_is_even;
+    bool this_scanline_is_even = last_scanline_is_even;
+    
+    if (is_first_zigzag_connector) 
+    {
+        first_zigzag_connector.push_back(intersection);
+        first_zigzag_connector_ends_in_even_scanline = this_scanline_is_even;
+        is_first_zigzag_connector = false;
+    }
+    else
+    {
+        if (previous_scanline_is_even && !this_scanline_is_even)
+        { // if we left from an even scanline, but not if this is the line segment connecting that zigzag_connector to an even scanline
+            addLine(last_connector_point, intersection);
+        }
+        else if (!previous_scanline_is_even && !this_scanline_is_even) // if we end an odd boundary in an odd segment
+        { // add whole oddBoundarySegment (including the just obtained point)
+            for (unsigned int point_idx = 1; point_idx < zigzag_connector.size(); point_idx++)
+            {
+                addLine(zigzag_connector[point_idx - 1], zigzag_connector[point_idx]);
+            }
+            // skip the last segment to the [intersection]
+            zigzag_connector.clear();
+        }
+        
+    }
+    zigzag_connector.clear(); // we're starting a new (odd) zigzag connector, so clear the old one
+    if (!this_scanline_is_even) // we are either in an end piece or an boundary segment starting in an odd scanline
+    { // only when a boundary segment starts in an odd scanline it depends on whether it ends in an odd scanline for whether this segment should be included or not
+        zigzag_connector.push_back(intersection);
+    }
+
+    last_connector_point = intersection;
+}
+
+
+void ZigzagConnectorProcessorDisconnectedEndPieces::registerPolyFinished()
+{
+    // write end segment if needed (first half of start/end-crossing segment)
+    if (!last_scanline_is_even && !first_zigzag_connector_ends_in_even_scanline)
+    {
+        for (unsigned int point_idx = 1; point_idx < zigzag_connector.size(); point_idx++)
+        {
+            addLine(zigzag_connector[point_idx - 1], zigzag_connector[point_idx]);
+        }
+    }
+    // write begin segment if needed (second half of start/end-crossing segment)
+    if (last_scanline_is_even || is_first_zigzag_connector)
+    {
+        for (unsigned int point_idx = 1; point_idx < first_zigzag_connector.size() - 1; point_idx++) // -1 cause skipping very last line segment!
+        {
+            addLine(first_zigzag_connector[point_idx - 1], first_zigzag_connector[point_idx]);
+        }
+    }
+    // write very last line segment if needed
+    if (last_scanline_is_even && !first_zigzag_connector_ends_in_even_scanline)
+    { // only add last element if boundary segment ends in odd scanline
+        addLine(first_zigzag_connector[first_zigzag_connector.size() - 2], first_zigzag_connector[first_zigzag_connector.size() - 1]);
+    }
+    // reset member variables
+    is_first_zigzag_connector = true;
+    first_zigzag_connector_ends_in_even_scanline = true;
+    last_scanline_is_even = false; 
+    first_zigzag_connector.clear();
+    zigzag_connector.clear();
+}
+
+
+} // namespace cura 

src/infill/ZigzagConnectorProcessorDisconnectedEndPieces.h

@@ -0,0 +1,26 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#ifndef INFILL_ZIGZAG_CONNECTOR_PROCESSOR_DISCONNECTED_END_PIECES_H
+#define INFILL_ZIGZAG_CONNECTOR_PROCESSOR_DISCONNECTED_END_PIECES_H
+
+#include "../utils/polygon.h"
+#include "ZigzagConnectorProcessorEndPieces.h"
+
+namespace cura
+{
+
+class ZigzagConnectorProcessorDisconnectedEndPieces : public ZigzagConnectorProcessorEndPieces
+{
+
+public:
+    ZigzagConnectorProcessorDisconnectedEndPieces(const PointMatrix& rotation_matrix, Polygons& result)
+    : ZigzagConnectorProcessorEndPieces(rotation_matrix, result)
+    {
+    }
+    void registerScanlineSegmentIntersection(const Point& intersection, bool scanline_is_even);
+    void registerPolyFinished();
+};
+
+} // namespace cura
+
+
+#endif // INFILL_ZIGZAG_CONNECTOR_PROCESSOR_DISCONNECTED_END_PIECES_H

src/infill/ZigzagConnectorProcessorEndPieces.cpp

@@ -0,0 +1,27 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#include "ZigzagConnectorProcessorEndPieces.h"
+
+
+namespace cura 
+{
+
+void ZigzagConnectorProcessorEndPieces::registerVertex(const Point& vertex)
+{
+    if (is_first_zigzag_connector)
+    {
+        first_zigzag_connector.push_back(vertex);
+    }
+    else if (last_scanline_is_even)
+    { // when a boundary segments starts in an even scanline it's either a normal zigzag connector or an endpiece to be included
+        // note that for ZigzagConnectorProcessorDisconnectedEndPieces only the last line segment from a boundary vertex to a scanline-boundary intersection is omitted
+        addLine(last_connector_point, vertex);
+    }
+    else
+    { // it's yet unclear whether the line segment should be included, so we store it until we know
+        zigzag_connector.push_back(vertex);
+    }
+    last_connector_point = vertex;
+}
+
+
+} // namespace cura 

src/infill/ZigzagConnectorProcessorEndPieces.h

@@ -0,0 +1,32 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#ifndef INFILL_ZIGZAG_CONNECTOR_PROCESSOR_END_PIECES_H
+#define INFILL_ZIGZAG_CONNECTOR_PROCESSOR_END_PIECES_H
+
+#include "../utils/polygon.h"
+#include "ActualZigzagConnectorProcessor.h"
+
+namespace cura
+{
+
+
+class ZigzagConnectorProcessorEndPieces : public ActualZigzagConnectorProcessor
+{
+protected:
+    Point last_connector_point; //!< last registered boundary vertex or scanline-coundary intersection
+
+    ZigzagConnectorProcessorEndPieces(const PointMatrix& rotation_matrix, Polygons& result)
+    : ActualZigzagConnectorProcessor(rotation_matrix, result)
+    , last_connector_point(0,0)
+    {
+    }
+
+public:
+    void registerVertex(const Point& vertex);
+};
+
+
+
+} // namespace cura
+
+
+#endif // INFILL_ZIGZAG_CONNECTOR_PROCESSOR_END_PIECES_H

src/infill/ZigzagConnectorProcessorNoEndPieces.cpp

@@ -0,0 +1,72 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#include "ZigzagConnectorProcessorNoEndPieces.h"
+
+
+namespace cura 
+{
+
+void ZigzagConnectorProcessorNoEndPieces::registerVertex(const Point& vertex)
+{
+    if (is_first_zigzag_connector)
+    {
+        first_zigzag_connector.push_back(vertex);
+    }
+    else if (last_scanline_is_even)
+    {
+        zigzag_connector.push_back(vertex);
+    }
+}
+
+
+void ZigzagConnectorProcessorNoEndPieces::registerScanlineSegmentIntersection(const Point& intersection, bool scanline_is_even)
+{
+    bool previous_scanline_is_even = last_scanline_is_even;
+    last_scanline_is_even = scanline_is_even;
+    bool this_scanline_is_even = last_scanline_is_even; // for conceptual clarity
+    
+    if (is_first_zigzag_connector) 
+    {
+        first_zigzag_connector.push_back(intersection);
+        first_zigzag_connector_ends_in_even_scanline = this_scanline_is_even;
+        is_first_zigzag_connector = false;
+    }
+    else
+    {
+        if (previous_scanline_is_even && !this_scanline_is_even)
+        { // add whole zigzag_connector (including the just obtained point)
+            for (unsigned int point_idx = 1; point_idx < zigzag_connector.size(); point_idx++)
+            {
+                addLine(zigzag_connector[point_idx - 1], zigzag_connector[point_idx]);
+            }
+            addLine(zigzag_connector.back(), intersection);
+            zigzag_connector.clear();
+        }
+    }
+    zigzag_connector.clear(); // we're starting a new zigzag connector, so clear the old one
+    if (this_scanline_is_even) // only boundary segments starting in an even segment are considered
+    {
+        zigzag_connector.push_back(intersection);
+    }
+    
+}
+
+
+void ZigzagConnectorProcessorNoEndPieces::registerPolyFinished()
+{
+    if (!is_first_zigzag_connector && last_scanline_is_even && !first_zigzag_connector_ends_in_even_scanline)
+    { // only if it's a normal zigzag connector; not when the whole boundary didn't cross any scanlines
+        for (unsigned int point_idx = 1; point_idx < first_zigzag_connector.size() ; point_idx++)
+        {
+            addLine(first_zigzag_connector[point_idx - 1], first_zigzag_connector[point_idx]);
+        }
+    }
+    // reset member variables
+    is_first_zigzag_connector = true;
+    first_zigzag_connector_ends_in_even_scanline = true;
+    last_scanline_is_even = false; 
+    first_zigzag_connector.clear();
+    zigzag_connector.clear();
+}
+
+
+} // namespace cura 

src/infill/ZigzagConnectorProcessorNoEndPieces.h

@@ -0,0 +1,29 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#ifndef INFILL_ZIGZAG_CONNECTOR_PROCESSOR_NO_ENDPIECES_H
+#define INFILL_ZIGZAG_CONNECTOR_PROCESSOR_NO_ENDPIECES_H
+
+#include "../utils/polygon.h"
+#include "ActualZigzagConnectorProcessor.h"
+#include "../utils/intpoint.h"
+
+namespace cura
+{
+
+class ZigzagConnectorProcessorNoEndPieces : public ActualZigzagConnectorProcessor
+{
+public:
+    ZigzagConnectorProcessorNoEndPieces(const PointMatrix& rotation_matrix, Polygons& result)
+    : ActualZigzagConnectorProcessor(rotation_matrix, result)
+    {
+    }
+
+    void registerVertex(const Point& vertex);
+    void registerScanlineSegmentIntersection(const Point& intersection, bool scanline_is_even);
+    void registerPolyFinished();
+};
+
+
+} // namespace cura
+
+
+#endif // INFILL_ZIGZAG_CONNECTOR_PROCESSOR_NO_ENDPIECES_H

src/inset.cpp

@@ -1,74 +0,0 @@
-/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
-#include "inset.h"
-#include "utils/polygonUtils.h"
-namespace cura {
-
-void generateInsets(SliceLayerPart* part, int nozzle_width, int line_width_0, int line_width_x, int insetCount, bool avoidOverlappingPerimeters_0, bool avoidOverlappingPerimeters)
-{
-    if (insetCount == 0)
-    {
-        part->insets.push_back(part->outline);
-        return;
-    }
-    
-    for(int i=0; i<insetCount; i++)
-    {
-        part->insets.push_back(Polygons());
-        if (i == 0)
-        {
-            if (line_width_0 < nozzle_width)
-            {
-                PolygonUtils::offsetSafe(part->outline, - nozzle_width/2, line_width_0, part->insets[0], avoidOverlappingPerimeters_0);
-            }
-            else 
-            {
-                PolygonUtils::offsetSafe(part->outline, - line_width_0/2, line_width_0, part->insets[0], avoidOverlappingPerimeters_0);
-            }
-        } else if (i == 1)
-        {
-            if (line_width_0 < nozzle_width)
-            {
-                int offset_from_first_boundary_for_edge_of_outer_wall = -nozzle_width/2; 
-                // ideally this /\ should be: nozzle_width/2 - line_width_0; however, factually, the nozzle will fill up part of the perimeter gaps
-                PolygonUtils::offsetSafe(part->insets[0], nozzle_width/2 - line_width_0 - line_width_x/2, offset_from_first_boundary_for_edge_of_outer_wall, line_width_x, part->insets[1], &part->perimeterGaps, avoidOverlappingPerimeters);
-            }
-            else 
-            {
-                PolygonUtils::offsetSafe(part->insets[0], -line_width_0/2 - line_width_x/2, -line_width_0/2, line_width_x, part->insets[1], &part->perimeterGaps, avoidOverlappingPerimeters);
-            }
-        } else
-        {
-            PolygonUtils::offsetExtrusionWidth(part->insets[i-1], true, line_width_x, part->insets[i], &part->perimeterGaps, avoidOverlappingPerimeters);
-        }
-        
-        
-        //Finally optimize all the polygons. Every point removed saves time in the long run.
-        part->insets[i].simplify();
-        if (part->insets[i].size() < 1)
-        {
-            part->insets.pop_back();
-            break;
-        }
-    }
-}
-
-void generateInsets(SliceLayer* layer, int nozzle_width, int line_width_0, int line_width_x, int insetCount, bool avoidOverlappingPerimeters_0, bool avoidOverlappingPerimeters)
-{
-    for(unsigned int partNr = 0; partNr < layer->parts.size(); partNr++)
-    {
-        generateInsets(&layer->parts[partNr], nozzle_width, line_width_0, line_width_x, insetCount, avoidOverlappingPerimeters_0, avoidOverlappingPerimeters);
-    }
-    
-    //Remove the parts which did not generate an inset. As these parts are too small to print,
-    // and later code can now assume that there is always minimal 1 inset line.
-    for(unsigned int partNr = 0; partNr < layer->parts.size(); partNr++)
-    {
-        if (layer->parts[partNr].insets.size() < 1)
-        {
-            layer->parts.erase(layer->parts.begin() + partNr);
-            partNr -= 1;
-        }
-    }
-}
-
-}//namespace cura

src/inset.h

@@ -1,41 +0,0 @@
-/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
-#ifndef INSET_H
-#define INSET_H
-
-#include "sliceDataStorage.h"
-
-namespace cura 
-{
-
-/*!
- * Generates the insets / perimeters for a single layer part.
- * 
- * \param part The part for which to generate the insets.
- * \param nozzle_width The diameter of the hole in the nozzle
- * \param line_width_0 line width of the outer wall
- * \param line_width_x line width of other walls
- * \param insetCount The number of insets to to generate
- * \param avoidOverlappingPerimeters_0 Whether to remove the parts of the first perimeters where it have overlap with itself (and store the gaps thus created in the \p storage)
- * \param avoidOverlappingPerimeters Whether to remove the parts of two consecutive perimeters where they have overlap (and store the gaps thus created in the \p part)
- */
-void generateInsets(SliceLayerPart* part, int nozzle_width, int line_width_0, int line_width_x, int insetCount, bool avoidOverlappingPerimeters_0, bool avoidOverlappingPerimeters);
-
-/*!
- * Generates the insets / perimeters for all parts in a layer.
- * 
- * Note that the second inset gets offsetted by \p line_width_0 instead of the first, 
- * which leads to better results for a smaller \p line_width_0 than \p line_width_x and when printing the outer wall last.
- * 
- * \param layer The layer for which to generate the insets.
- * \param nozzle_width The diameter of the hole in the nozzle
- * \param line_width_0 line width of the outer wall
- * \param line_width_x line width of other walls
- * \param insetCount The number of insets to to generate
- * \param avoidOverlappingPerimeters_0 Whether to remove the parts of the first perimeters where it have overlap with itself (and store the gaps thus created in the \p storage)
- * \param avoidOverlappingPerimeters Whether to remove the parts of two consecutive perimeters where they have overlap (and store the gaps thus created in the \p part)
- */ 
-void generateInsets(SliceLayer* layer, int nozzle_width, int line_width_0, int line_width_x, int insetCount, bool avoidOverlappingPerimeters_0, bool avoidOverlappingPerimeters);
-
-}//namespace cura
-
-#endif//INSET_H

src/layerPart.cpp

@@ -1,8 +1,8 @@
 /** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
 
 #include "layerPart.h"
-#include "settings.h"
-#include "Progress.h"
+#include "settings/settings.h"
+#include "progress/Progress.h"
 
 #include "utils/SVG.h" // debug output
 
@@ -26,15 +26,15 @@ void createLayerWithParts(SliceLayer& storageLayer, SlicerLayer* layer, bool uni
 
     if (union_all_remove_holes)
     {
-        for(unsigned int i=0; i<layer->polygonList.size(); i++)
+        for(unsigned int i=0; i<layer->polygons.size(); i++)
         {
-            if (layer->polygonList[i].orientation())
-                layer->polygonList[i].reverse();
+            if (layer->polygons[i].orientation())
+                layer->polygons[i].reverse();
         }
     }
     
     std::vector<PolygonsPart> result;
-    result = layer->polygonList.splitIntoParts(union_layers || union_all_remove_holes);
+    result = layer->polygons.splitIntoParts(union_layers || union_all_remove_holes);
     for(unsigned int i=0; i<result.size(); i++)
     {
         storageLayer.parts.emplace_back();
@@ -42,14 +42,14 @@ void createLayerWithParts(SliceLayer& storageLayer, SlicerLayer* layer, bool uni
         storageLayer.parts[i].boundaryBox.calculate(storageLayer.parts[i].outline);
     }
 }
-void createLayerParts(SliceMeshStorage& storage, Slicer* slicer, bool union_layers, bool union_all_remove_holes)
+void createLayerParts(SliceMeshStorage& mesh, Slicer* slicer, bool union_layers, bool union_all_remove_holes)
 {
     for(unsigned int layer_nr = 0; layer_nr < slicer->layers.size(); layer_nr++)
     {
-        storage.layers.push_back(SliceLayer());
-        storage.layers[layer_nr].sliceZ = slicer->layers[layer_nr].z;
-        storage.layers[layer_nr].printZ = slicer->layers[layer_nr].z;
-        createLayerWithParts(storage.layers[layer_nr], &slicer->layers[layer_nr], union_layers, union_all_remove_holes);
+        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/layerPart.h

@@ -22,9 +22,9 @@ namespace cura {
 
 void createLayerWithParts(SliceLayer& storageLayer, SlicerLayer* layer, bool union_layers, bool union_all_remove_holes);
 
-void createLayerParts(SliceMeshStorage& storage, Slicer* slicer, bool union_layers, bool union_all_remove_holes);
+void createLayerParts(SliceMeshStorage& mesh, Slicer* slicer, bool union_layers, bool union_all_remove_holes);
 
-void layerparts2HTML(SliceDataStorage& storage, const char* filename, bool all_layers = true, int layer_nr = -1);
+void layerparts2HTML(SliceDataStorage& mesh, const char* filename, bool all_layers = true, int layer_nr = -1);
 
 }//namespace cura
 

src/main.cpp

@@ -16,7 +16,9 @@
 #include "utils/string.h"
 
 #include "FffProcessor.h"
-#include "settingRegistry.h"
+#include "settings/SettingRegistry.h"
+
+#include "settings/SettingsToGV.h"
 
 namespace cura
 {
@@ -28,23 +30,25 @@ void print_usage()
     cura::logError("CuraEngine help\n");
     cura::logError("\tShow this help message\n");
     cura::logError("\n");
-    cura::logError("CuraEngine connect <host>[:<port>] [-j <settings.json>]\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\n\tLoad settings.json file to register all settings and their defaults\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] [-o <output.gcode>] [-l <model.stl>] [--next]\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.json file to register all settings and their defaults.\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\n\tAdd a new extruder train.\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-e [extruder train 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("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");
 }
 
@@ -66,10 +70,10 @@ void print_call(int argc, char **argv)
 
 void connect(int argc, char **argv)
 {
-    CommandSocket* commandSocket = new CommandSocket();
     std::string ip;
     int port = 49674;
-    
+
+    // parse ip port
     std::string ip_port(argv[2]);
     if (ip_port.find(':') != std::string::npos)
     {
@@ -77,7 +81,6 @@ void connect(int argc, char **argv)
         port = std::stoi(ip_port.substr(ip_port.find(':') + 1).data());
     }
 
-    
     for(int argn = 3; argn < argc; argn++)
     {
         char* str = argv[argn];
@@ -92,7 +95,7 @@ void connect(int argc, char **argv)
                     break;
                 case 'j':
                     argn++;
-                    if (SettingRegistry::getInstance()->loadJSONsettings(argv[argn]))
+                    if (SettingRegistry::getInstance()->loadJSONsettings(argv[argn], FffProcessor::getInstance()))
                     {
                         cura::logError("ERROR: Failed to load json file: %s\n", argv[argn]);
                     }
@@ -106,8 +109,9 @@ void connect(int argc, char **argv)
             }
         }
     }
-    
-    commandSocket->connect(ip, port);
+
+    CommandSocket::instantiate();
+    CommandSocket::getInstance()->connect(ip, port);
 }
 
 void slice(int argc, char **argv)
@@ -116,11 +120,12 @@ void slice(int argc, char **argv)
     
     FMatrix3x3 transformation; // the transformation applied to a model when loaded
                         
-    MeshGroup meshgroup(FffProcessor::getInstance());
+    MeshGroup* meshgroup = new MeshGroup(FffProcessor::getInstance());
     
     int extruder_train_nr = 0;
 
-    SettingsBase* last_extruder_train = meshgroup.getExtruderTrain(0);
+    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++)
     {
@@ -134,25 +139,29 @@ 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();
+                        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.getExtruderTrain(extruder_nr)->setExtruderTrainDefaults(extruder_nr); // also initializes yet uninitialized extruder trains
+                            ExtruderTrain* train = meshgroup->createExtruderTrain(extruder_nr); // create new extruder train objects or use already existing ones
+                            SettingRegistry::getInstance()->loadExtruderJSONsettings(extruder_nr, train);
                         }
                         //start slicing
-                        FffProcessor::getInstance()->processMeshGroup(&meshgroup);
+                        FffProcessor::getInstance()->processMeshGroup(meshgroup);
                         
                         // initialize loading of new meshes
                         FffProcessor::getInstance()->time_keeper.restart();
-                        meshgroup = MeshGroup(FffProcessor::getInstance());
-                        last_settings_object = &meshgroup;
+                        delete meshgroup;
+                        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");
                         exit(1);
                     }
-                    break;
                 }else{
                     cura::logError("Unknown option: %s\n", str);
                 }
@@ -169,7 +178,7 @@ void slice(int argc, char **argv)
                         break;
                     case 'j':
                         argn++;
-                        if (SettingRegistry::getInstance()->loadJSONsettings(argv[argn]))
+                        if (SettingRegistry::getInstance()->loadJSONsettings(argv[argn], last_settings_object))
                         {
                             cura::logError("ERROR: Failed to load json file: %s\n", argv[argn]);
                         }
@@ -177,8 +186,9 @@ void slice(int argc, char **argv)
                     case 'e':
                         str++;
                         extruder_train_nr = int(*str - '0'); // TODO: parse int instead (now "-e10"="-e:" , "-e11"="-e;" , "-e12"="-e<" .. etc) 
-                        last_settings_object = meshgroup.getExtruderTrain(extruder_train_nr);
-                        last_extruder_train = meshgroup.getExtruderTrain(extruder_train_nr);
+                        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++;
@@ -186,13 +196,13 @@ void slice(int argc, char **argv)
                         log("Loading %s from disk...\n", argv[argn]);
                         // transformation = // TODO: get a transformation from somewhere
                         
-                        if (!loadMeshIntoMeshGroup(&meshgroup, argv[argn], transformation, last_extruder_train))
+                        if (!loadMeshIntoMeshGroup(meshgroup, argv[argn], transformation, last_extruder_train))
                         {
                             logError("Failed to load model: %s\n", argv[argn]);
                         }
                         else 
                         {
-                            last_settings_object = &(meshgroup.meshes.back()); // pointer is valid until a new object is added, so this is OK
+                            last_settings_object = &(meshgroup->meshes.back()); // pointer is valid until a new object is added, so this is OK
                         }
                         break;
                     case 'o':
@@ -204,7 +214,7 @@ void slice(int argc, char **argv)
                         }
                         break;
                     case 'g':
-                        last_settings_object = &meshgroup;
+                        last_settings_object = meshgroup;
                     case 's':
                         {
                             //Parse the given setting and store it.
@@ -238,9 +248,11 @@ void slice(int argc, char **argv)
         }
     }
 
-    for (extruder_train_nr = 0; extruder_train_nr < FffProcessor::getInstance()->getSettingAsCount("machine_extruder_count"); extruder_train_nr++)
+    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.getExtruderTrain(extruder_train_nr)->setExtruderTrainDefaults(extruder_train_nr); // also initializes yet uninitialized extruder trains
+        ExtruderTrain* train = meshgroup->createExtruderTrain(extruder_train_nr); // create new extruder train objects or use already existing ones
+        SettingRegistry::getInstance()->loadExtruderJSONsettings(extruder_train_nr, train);
     }
     
     
@@ -249,12 +261,12 @@ void slice(int argc, char **argv)
 #endif
         //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();
+        meshgroup->finalize();
         log("Loaded from disk in %5.3fs\n", FffProcessor::getInstance()->time_keeper.restart());
         
         //start slicing
-        FffProcessor::getInstance()->processMeshGroup(&meshgroup);
-        
+        FffProcessor::getInstance()->processMeshGroup(meshgroup);
+
 #ifndef DEBUG
     }catch(...){
         cura::logError("Unknown exception\n");
@@ -263,7 +275,8 @@ void slice(int argc, char **argv)
 #endif
     //Finalize the processor, this adds the end.gcode. And reports statistics.
     FffProcessor::getInstance()->finalize();
-    
+
+    delete meshgroup;
 }
 
 }//namespace cura
@@ -317,6 +330,79 @@ int main(int argc, char **argv)
     {
         slice(argc, argv);
     }
+    else if (stringcasecompare(argv[1], "help") == 0)
+    {
+        print_usage();
+        exit(0);
+    }
+    else if (stringcasecompare(argv[1], "analyse") == 0)
+    { // CuraEngine analyse [json] [output.gv] [engine_settings] -[p|i|e|w]
+        // p = show parent-child relations
+        // i = show inheritance function
+        // e = show error functions
+        // w = show warning functions
+        // dot refl_ff.gv -Tpng > rafl_ff_dotted.png
+        // see meta/HOWTO.txt
+        
+        bool parent_child_viz = false;
+        bool inherit_viz = false;
+        bool warning_viz = false;
+        bool error_viz = false;
+        if (argc >= 6)
+        {
+            char* str = argv[5];
+            if (str[0] == '-')
+            {
+                for(str++; *str; str++)
+                {
+                    switch(*str)
+                    {
+                    case 'p':
+                        parent_child_viz = true;
+                        break;
+                    case 'i':
+                        inherit_viz = true;
+                        break;
+                    case 'e':
+                        error_viz = true;
+                        break;
+                    case 'w':
+                        warning_viz = true;
+                        break;
+                    default:
+                        cura::logError("Unknown option: %c\n", *str);
+                        print_call(argc, argv);
+                        print_usage();
+                        break;
+                    }
+                }
+            }
+        }
+        else
+        {
+            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);
+        if (gv_out.generate(std::string(argv[2])))
+        {
+            cura::logError("ERROR: Failed to analyse json file: %s\n", argv[2]);
+        }
+        exit(0);
+    }
     else
     {
         cura::logError("Unknown command: %s\n", argv[1]);

src/mesh.cpp

@@ -1,11 +1,17 @@
 #include "mesh.h"
 #include "utils/logoutput.h"
 
+// #define LOG_MESH_ERRORS
+
 namespace cura
 {
 
 const int vertex_meld_distance = MM2INT(0.03);
-static inline uint32_t pointHash(Point3& p)
+/*!
+ * returns a hash for the location, but first divides by the vertex_meld_distance,
+ * so that any point within a box of vertex_meld_distance by vertex_meld_distance would get mapped to the same hash.
+ */
+static inline uint32_t pointHash(const Point3& p)
 {
     return ((p.x + vertex_meld_distance/2) / vertex_meld_distance) ^ (((p.y + vertex_meld_distance/2) / vertex_meld_distance) << 10) ^ (((p.z + vertex_meld_distance/2) / vertex_meld_distance) << 20);
 }
@@ -55,16 +61,21 @@ void Mesh::finish()
     }
 }
 
-Point3 Mesh::min()
+Point3 Mesh::min() const
 {
     return aabb.min;
 }
-Point3 Mesh::max()
+Point3 Mesh::max() const
 {
     return aabb.max;
 }
+AABB3D Mesh::getAABB() const
+{
+    return aabb;
+}
 
-int Mesh::findIndexOfVertex(Point3& v)
+
+int Mesh::findIndexOfVertex(const Point3& v)
 {
     uint32_t hash = pointHash(v);
 
@@ -107,7 +118,7 @@ See <a href="http://stackoverflow.com/questions/14066933/direct-way-of-computing
 
 
 */
-int Mesh::getFaceIdxWithPoints(int idx0, int idx1, int notFaceIdx)
+int Mesh::getFaceIdxWithPoints(int idx0, int idx1, int notFaceIdx) const
 {
     std::vector<int> candidateFaces; // in case more than two faces meet at an edge, multiple candidates are generated
     int notFaceVertexIdx = -1; // index of the third vertex of the face corresponding to notFaceIdx
@@ -126,14 +137,27 @@ int Mesh::getFaceIdxWithPoints(int idx0, int idx1, int notFaceIdx)
             )  candidateFaces.push_back(f);
 
     }
-
-    if (candidateFaces.size() == 0) { cura::logError("Couldn't find face connected to face %i.\n", notFaceIdx); return -1; }
+    if (candidateFaces.size() == 0)
+    {
+#ifdef LOG_MESH_ERRORS
+        cura::logError("Couldn't find face connected to face %i.\n", notFaceIdx);
+#endif
+        return -1;
+    }
     if (candidateFaces.size() == 1) { return candidateFaces[0]; }
 
 
-    if (notFaceVertexIdx < 0) { cura::logError("Couldn't find third point on face %i.\n", notFaceIdx); return -1; }
+    if (notFaceVertexIdx < 0)
+    {
+#ifdef LOG_MESH_ERRORS
+        cura::logError("Couldn't find third point on face %i.\n", notFaceIdx);
+#endif
+        return -1;
+    }
 
+#ifdef LOG_MESH_ERRORS
     if (candidateFaces.size() % 2 == 0) cura::log("Warning! Edge with uneven number of faces connecting it!(%i)\n", candidateFaces.size()+1);
+#endif
 
     FPoint3 vn = vertices[idx1].p - vertices[idx0].p;
     FPoint3 n = vn / vn.vSize(); // the normal of the plane in which all normals of faces connected to the edge lie => the normalized normal
@@ -142,7 +166,9 @@ int Mesh::getFaceIdxWithPoints(int idx0, int idx1, int notFaceIdx)
 // the normals below are abnormally directed! : these normals all point counterclockwise (viewed from idx1 to idx0) from the face, irrespective of the direction of the face.
     FPoint3 n0 = FPoint3(vertices[notFaceVertexIdx].p - vertices[idx0].p).cross(v0);
 
+#ifdef LOG_MESH_ERRORS
     if (n0.vSize() <= 0) cura::log("Warning! Face %i has zero area!", notFaceIdx);
+#endif
 
     double smallestAngle = 1000; // more then 2 PI (impossible angle)
     int bestIdx = -1;
@@ -166,7 +192,9 @@ int Mesh::getFaceIdxWithPoints(int idx0, int idx1, int notFaceIdx)
 
         if (angle == 0)
         {
+#ifdef LOG_MESH_ERRORS
             cura::log("Warning! Overlapping faces: face %i and face %i.\n", notFaceIdx, candidateFace);
+#endif
             std::cerr<< n.vSize() <<"; "<<n1.vSize()<<";"<<n0.vSize() <<std::endl;
         }
         if (angle < smallestAngle)
@@ -175,8 +203,10 @@ int Mesh::getFaceIdxWithPoints(int idx0, int idx1, int notFaceIdx)
             bestIdx = candidateFace;
         }
     }
+#ifdef LOG_MESH_ERRORS
     if (bestIdx < 0) cura::logError("Couldn't find face connected to face %i.\n", notFaceIdx);
+#endif
     return bestIdx;
 }
 
-}//namespace cura
+}//namespace cura

src/mesh.h

@@ -1,8 +1,8 @@
 #ifndef MESH_H
 #define MESH_H
 
-#include "settings.h"
-#include "utils/AABB.h"
+#include "settings/settings.h"
+#include "utils/AABB3D.h"
 
 namespace cura
 {
@@ -69,8 +69,9 @@ public:
     void clear(); //!< clears all data
     void finish(); //!< complete the model : set the connected_face_index fields of the faces.
 
-    Point3 min(); //!< min (in x,y and z) vertex of the bounding box
-    Point3 max(); //!< max (in x,y and z) vertex of the bounding box
+    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
     
     /*!
      * Offset the whole mesh (all vertices and the bounding box).
@@ -85,12 +86,12 @@ public:
     }
 
 private:
-    int findIndexOfVertex(Point3& v); //!< find index of vertex close to the given point, or create a new vertex and return its index.
+    int findIndexOfVertex(const Point3& v); //!< find index of vertex close to the given point, or create a new vertex and return its index.
     /*!
     Get the index of the face connected to the face with index \p notFaceIdx, via vertices \p idx0 and \p idx1.
     In case multiple faces connect with the same edge, return the next counter-clockwise face when viewing from \p idx1 to \p idx0.
     */
-    int getFaceIdxWithPoints(int idx0, int idx1, int notFaceIdx);
+    int getFaceIdxWithPoints(int idx0, int idx1, int notFaceIdx) const;
 };
 
 }//namespace cura

src/multiVolumes.cpp

@@ -6,15 +6,29 @@ namespace cura
 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 idx=0; idx < volumes.size(); idx++)
+    for (unsigned int volume_1_idx = 0; volume_1_idx < volumes.size(); volume_1_idx++)
     {
-        for(unsigned int idx2=0; idx2<idx; idx2++)
+        Slicer& volume_1 = *volumes[volume_1_idx];
+        if (volume_1.mesh->getSettingBoolean("infill_mesh"))
         {
-            for(unsigned int layerNr=0; layerNr < volumes[idx]->layers.size(); layerNr++)
+            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"))
             {
-                SlicerLayer& layer1 = volumes[idx]->layers[layerNr];
-                SlicerLayer& layer2 = volumes[idx2]->layers[layerNr];
-                layer1.polygonList = layer1.polygonList.difference(layer2.polygonList);
+                continue;
+            }
+            if (!volume_1.mesh->getAABB().hit(volume_2.mesh->getAABB()))
+            {
+                continue;
+            }
+            for (unsigned int layerNr = 0; layerNr < volume_1.layers.size(); layerNr++)
+            {
+                SlicerLayer& layer1 = volume_1.layers[layerNr];
+                SlicerLayer& layer2 = volume_2.layers[layerNr];
+                layer1.polygons = layer1.polygons.difference(layer2.polygons);
             }
         }
     }
@@ -22,24 +36,40 @@ void carveMultipleVolumes(std::vector<Slicer*> &volumes)
  
 //Expand each layer a bit and then keep the extra overlapping parts that overlap with other volumes.
 //This generates some overlap in dual extrusion, for better bonding in touching parts.
-void generateMultipleVolumesOverlap(std::vector<Slicer*> &volumes, int overlap)
+void generateMultipleVolumesOverlap(std::vector<Slicer*> &volumes)
 {
-    if (volumes.size() < 2 || overlap <= 0) return;
-    
-    for(unsigned int layerNr=0; layerNr < volumes[0]->layers.size(); layerNr++)
+    if (volumes.size() < 2)
     {
-        Polygons fullLayer;
-        for(unsigned int volIdx = 0; volIdx < volumes.size(); volIdx++)
+        return;
+    }
+
+    int offset_to_merge_other_merged_volumes = 20;
+    for (Slicer* volume : volumes)
+    {
+        int overlap = volume->mesh->getSettingInMicrons("multiple_mesh_overlap");
+        if (volume->mesh->getSettingBoolean("infill_mesh")
+            || overlap == 0)
         {
-            SlicerLayer& layer1 = volumes[volIdx]->layers[layerNr];
-            fullLayer = fullLayer.unionPolygons(layer1.polygonList.offset(20)); // TODO: put hard coded value in a variable with an explanatory name (and make var a parameter, and perhaps even a setting?)
+            continue;
         }
-        fullLayer = fullLayer.offset(-20); // TODO: put hard coded value in a variable with an explanatory name (and make var a parameter, and perhaps even a setting?)
-        
-        for(unsigned int volIdx = 0; volIdx < volumes.size(); volIdx++)
+        for (unsigned int layer_nr = 0; layer_nr < volume->layers.size(); layer_nr++)
         {
-            SlicerLayer& layer1 = volumes[volIdx]->layers[layerNr];
-            layer1.polygonList = fullLayer.intersection(layer1.polygonList.offset(overlap / 2));
+            Polygons all_other_volumes;
+            for (Slicer* other_volume : volumes)
+            {
+                if (other_volume->mesh->getSettingBoolean("infill_mesh")
+                    || !other_volume->mesh->getAABB().hit(volume->mesh->getAABB())
+                )
+                {
+                    continue;
+                }
+                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.unionPolygons(all_other_volumes.intersection(volume_layer.polygons.offset(overlap / 2)));
         }
     }
 }

src/multiVolumes.h

@@ -13,7 +13,7 @@ void carveMultipleVolumes(std::vector<Slicer*> &meshes);
  * Expand each layer a bit and then keep the extra overlapping parts that overlap with other volumes.
  * This generates some overlap in dual extrusion, for better bonding in touching parts.
  */
-void generateMultipleVolumesOverlap(std::vector<Slicer*> &meshes, int overlap);
+void generateMultipleVolumesOverlap(std::vector<Slicer*> &meshes);
 
 }//namespace cura
 

src/pathOrderOptimizer.cpp

@@ -2,6 +2,7 @@
 #include "pathOrderOptimizer.h"
 #include "utils/logoutput.h"
 #include "utils/BucketGrid2D.h"
+#include "utils/linearAlg2D.h"
 
 #define INLINE static inline
 
@@ -15,17 +16,16 @@ void PathOrderOptimizer::optimize()
     bool picked[polygons.size()];
     memset(picked, false, sizeof(bool) * polygons.size());/// initialized as falses
     
-    for(unsigned int i_polygon=0 ; i_polygon<polygons.size() ; i_polygon++) /// 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();
-        PolygonRef poly = polygons[i_polygon];
-        for(unsigned int i_point=0; i_point<poly.size(); i_point++) /// get closest point in polygon
+        for (unsigned int point_idx = 0; point_idx < poly.size(); point_idx++) /// get closest point in polygon
         {
-            float dist = vSize2f(poly[i_point] - startPoint);
+            float dist = vSize2f(poly[point_idx] - startPoint);
             if (dist < bestDist)
             {
-                best = i_point;
+                best = point_idx;
                 bestDist = dist;
             }
         }
@@ -37,46 +37,50 @@ void PathOrderOptimizer::optimize()
 
 
     Point prev_point = startPoint;
-    for(unsigned int i_polygon=0 ; i_polygon<polygons.size() ; i_polygon++) /// actual path order optimizer
+    for (unsigned int poly_order_idx = 0; poly_order_idx < polygons.size(); poly_order_idx++) /// actual path order optimizer
     {
-        int best = -1;
+        int best_poly_idx = -1;
         float bestDist = std::numeric_limits<float>::infinity();
 
 
-        for(unsigned int i_polygon=0 ; i_polygon<polygons.size() ; i_polygon++)
+        for (unsigned int poly_idx = 0; poly_idx < polygons.size(); poly_idx++)
         {
-            if (picked[i_polygon] || polygons[i_polygon].size() < 1) /// skip single-point-polygons
+            if (picked[poly_idx] || polygons[poly_idx].size() < 1) /// skip single-point-polygons
+            {
                 continue;
+            }
 
-            assert (polygons[i_polygon].size() != 2);
+            assert (polygons[poly_idx].size() != 2);
 
-            float dist = vSize2f(polygons[i_polygon][polyStart[i_polygon]] - prev_point);
+            float dist = vSize2f(polygons[poly_idx][polyStart[poly_idx]] - prev_point);
             if (dist < bestDist)
             {
-                best = i_polygon;
+                best_poly_idx = poly_idx;
                 bestDist = dist;
             }
 
         }
 
 
-        if (best > -1) /// should always be true; we should have been able to identify the best next polygon
+        if (best_poly_idx > -1) /// should always be true; we should have been able to identify the best next polygon
         {
-            assert(polygons[best].size() != 2);
+            assert(polygons[best_poly_idx].size() != 2);
 
-            prev_point = polygons[best][polyStart[best]];
+            prev_point = polygons[best_poly_idx][polyStart[best_poly_idx]];
 
-            picked[best] = true;
-            polyOrder.push_back(best);
+            picked[best_poly_idx] = true;
+            polyOrder.push_back(best_poly_idx);
         }
         else
+        {
             logError("Failed to find next closest polygon.\n");
+        }
     }
 
     prev_point = startPoint;
-    for(unsigned int n=0; n<polyOrder.size(); n++) /// decide final starting points in each polygon
+    for (unsigned int order_idx = 0; order_idx < polyOrder.size(); order_idx++) /// decide final starting points in each polygon
     {
-        int poly_idx = polyOrder[n];
+        int poly_idx = polyOrder[order_idx];
         int point_idx = getPolyStart(prev_point, poly_idx);
         polyStart[poly_idx] = point_idx;
         prev_point = polygons[poly_idx][point_idx];
@@ -99,22 +103,23 @@ int PathOrderOptimizer::getPolyStart(Point prev_point, int poly_idx)
 int PathOrderOptimizer::getClosestPointInPolygon(Point prev_point, int poly_idx)
 {
     PolygonRef poly = polygons[poly_idx];
+
     int best_point_idx = -1;
-    float bestDist = std::numeric_limits<float>::infinity();
-    bool orientation = poly.orientation();
-    for(unsigned int i_point=0 ; i_point<poly.size() ; i_point++)
+    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++)
     {
-        float dist = vSize2f(poly[i_point] - prev_point);
-        Point n0 = normal(poly[(i_point-1+poly.size())%poly.size()] - poly[i_point], 2000);
-        Point n1 = normal(poly[i_point] - poly[(i_point + 1) % poly.size()], 2000);
-        float dot_score = dot(n0, n1) - dot(crossZ(n0), n1); /// prefer binnenbocht
-        if (orientation)
-            dot_score = -dot_score;
-        if (dist + dot_score < bestDist)
+        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
+        if (dist + is_on_inside_corner_score < best_point_score)
         {
-            best_point_idx = i_point;
-            bestDist = dist;
+            best_point_idx = point_idx;
+            best_point_score = dist + is_on_inside_corner_score;
         }
+        p0 = p1;
     }
     return best_point_idx;
 }
@@ -147,132 +152,118 @@ int PathOrderOptimizer::getFarthestPointInPolygon(int poly_idx)
 */
 void LineOrderOptimizer::optimize()
 {
-    int gridSize = 5000; // the size of the cells in the hash grid.
+    int gridSize = 5000; // the size of the cells in the hash grid. TODO
     BucketGrid2D<unsigned int> line_bucket_grid(gridSize);
     bool picked[polygons.size()];
     memset(picked, false, sizeof(bool) * polygons.size());/// initialized as falses
     
-    for(unsigned int i_polygon=0 ; i_polygon<polygons.size() ; i_polygon++) /// find closest point to initial starting point within each polygon +initialize picked
+    for (unsigned int poly_idx = 0; poly_idx < polygons.size(); poly_idx++) /// find closest point to initial starting point within each polygon +initialize picked
     {
-        int best = -1;
-        float bestDist = std::numeric_limits<float>::infinity();
-        PolygonRef poly = polygons[i_polygon];
-        for(unsigned int i_point=0; i_point<poly.size(); i_point++) /// get closest point from polygon
+        int best_point_idx = -1;
+        float best_point_dist = std::numeric_limits<float>::infinity();
+        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[i_point] - startPoint);
-            if (dist < bestDist)
+            float dist = vSize2f(poly[point_idx] - startPoint);
+            if (dist < best_point_dist)
             {
-                best = i_point;
-                bestDist = dist;
+                best_point_idx = point_idx;
+                best_point_dist = dist;
             }
         }
-        polyStart.push_back(best);
+        polyStart.push_back(best_point_idx);
 
         assert(poly.size() == 2);
 
-        line_bucket_grid.insert(poly[0], i_polygon);
-        line_bucket_grid.insert(poly[1], i_polygon);
+        line_bucket_grid.insert(poly[0], poly_idx);
+        line_bucket_grid.insert(poly[1], poly_idx);
 
     }
 
 
-    Point incommingPerpundicularNormal(0, 0);
+    Point incoming_perpundicular_normal(0, 0);
     Point prev_point = startPoint;
-    for(unsigned int i_polygon=0 ; i_polygon<polygons.size() ; i_polygon++) /// actual path order optimizer
+    for (unsigned int order_idx = 0; order_idx < polygons.size(); order_idx++) /// actual path order optimizer
     {
-        int best = -1;
-        float bestDist = std::numeric_limits<float>::infinity();
+        int best_line_idx = -1;
+        float best_score = std::numeric_limits<float>::infinity(); // distance score for the best next line
 
-        for(unsigned int i_close_line_polygon :  line_bucket_grid.findNearbyObjects(prev_point)) /// check if single-line-polygon is close to last point
+        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[i_close_line_polygon] || polygons[i_close_line_polygon].size() < 1)
+            if (picked[close_line_poly_idx] || polygons[close_line_poly_idx].size() < 1)
+            {
                 continue;
+            }
 
-
-            checkIfLineIsBest(i_close_line_polygon, best, bestDist, prev_point, incommingPerpundicularNormal);
-
+            updateBestLine(close_line_poly_idx, best_line_idx, best_score, prev_point, incoming_perpundicular_normal);
         }
 
-        if (best == -1) /// if single-line-polygon hasn't been found yet
+        if (best_line_idx == -1) /// if single-line-polygon hasn't been found yet
         {
-           for(unsigned int i_polygon=0 ; i_polygon<polygons.size() ; i_polygon++)
+            for (unsigned int poly_idx = 0; poly_idx < polygons.size(); poly_idx++)
             {
-                if (picked[i_polygon] || polygons[i_polygon].size() < 1) /// skip single-point-polygons
+                if (picked[poly_idx] || polygons[poly_idx].size() < 1) /// skip single-point-polygons
+                {
                     continue;
-                assert(polygons[i_polygon].size() == 2);
+                }
+                assert(polygons[poly_idx].size() == 2);
 
-                checkIfLineIsBest(i_polygon, best, bestDist, prev_point, incommingPerpundicularNormal);
+                updateBestLine(poly_idx, best_line_idx, best_score, prev_point, incoming_perpundicular_normal);
 
             }
         }
 
-        if (best > -1) /// should always be true; we should have been able to identify the best next polygon
+        if (best_line_idx > -1) /// should always be true; we should have been able to identify the best next polygon
         {
-            assert(polygons[best].size() == 2);
+            PolygonRef best_line = polygons[best_line_idx];
+            assert(best_line.size() == 2);
 
-            int endIdx = polyStart[best] * -1 + 1; /// 1 -> 0 , 0 -> 1
-            prev_point = polygons[best][endIdx];
-            incommingPerpundicularNormal = crossZ(normal(polygons[best][endIdx] - polygons[best][polyStart[best]], 1000));
+            int line_start_point_idx = polyStart[best_line_idx];
+            int line_end_point_idx = line_start_point_idx * -1 + 1; /// 1 -> 0 , 0 -> 1
+            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));
 
-            picked[best] = true;
-            polyOrder.push_back(best);
+            picked[best_line_idx] = true;
+            polyOrder.push_back(best_line_idx);
         }
         else
-            logError("Failed to find next closest line.\n");
-    }
-
-    prev_point = startPoint;
-    for(unsigned int n=0; n<polyOrder.size(); n++) /// decide final starting points in each polygon
-    {
-        int nr = polyOrder[n];
-        PolygonRef poly = polygons[nr];
-        int best = -1;
-        float bestDist = std::numeric_limits<float>::infinity();
-        bool orientation = poly.orientation();
-        for(unsigned int i=0;i<poly.size(); i++)
         {
-            float dist = vSize2f(polygons[nr][i] - prev_point);
-            Point n0 = normal(poly[(i+poly.size()-1)%poly.size()] - poly[i], 2000);
-            Point n1 = normal(poly[i] - poly[(i + 1) % poly.size()], 2000);
-            float dot_score = dot(n0, n1) - dot(crossZ(n0), n1);
-            if (orientation)
-                dot_score = -dot_score;
-            if (dist + dot_score < bestDist)
-            {
-                best = i;
-                bestDist = dist + dot_score;
-            }
+            logError("Failed to find next closest line.\n");
         }
-
-        polyStart[nr] = best;
-        assert(poly.size() == 2);
-        prev_point = poly[best *-1 + 1]; /// 1 -> 0 , 0 -> 1
-
     }
 }
 
-inline void LineOrderOptimizer::checkIfLineIsBest(unsigned int i_line_polygon, int& best, float& bestDist, Point& prev_point, Point& incommingPerpundicularNormal)
+inline void LineOrderOptimizer::updateBestLine(unsigned int poly_idx, int& best, float& best_score, Point prev_point, Point incoming_perpundicular_normal)
 {
+    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 dist = vSize2f(polygons[i_line_polygon][0] - prev_point);
-        dist += abs(dot(incommingPerpundicularNormal, normal(polygons[i_line_polygon][1] - polygons[i_line_polygon][0], 1000))) * 0.0001f; /// penalize sharp corners
-        if (dist < bestDist)
+        float score = vSize2f(p0 - prev_point) + dot_score; // prefer 90 degree corners
+        if (score < best_score)
         {
-            best = i_line_polygon;
-            bestDist = dist;
-            polyStart[i_line_polygon] = 0;
+            best = poly_idx;
+            best_score = score;
+            polyStart[poly_idx] = 0;
         }
     }
     { /// check distance to second point on line (1)
-        float dist = vSize2f(polygons[i_line_polygon][1] - prev_point);
-        dist += abs(dot(incommingPerpundicularNormal, normal(polygons[i_line_polygon][0] - polygons[i_line_polygon][1], 1000) )) * 0.0001f; /// penalize sharp corners
-        if (dist < bestDist)
+        float score = vSize2f(p1 - prev_point) + dot_score; // prefer 90 degree corners
+        if (score < best_score)
         {
-            best = i_line_polygon;
-            bestDist = dist;
-            polyStart[i_line_polygon] = 1;
+            best = poly_idx;
+            best_score = score;
+            polyStart[poly_idx] = 1;
         }
     }
 }
 
+float LineOrderOptimizer::getAngleScore(Point incoming_perpundicular_normal, Point p0, Point p1)
+{
+    return dot(incoming_perpundicular_normal, normal(p1 - p0, 1000)) * 0.0001f;
+}
+
+
 }//namespace cura

src/pathOrderOptimizer.h

@@ -4,7 +4,7 @@
 
 #include <stdint.h>
 #include "utils/polygon.h"
-#include "settings.h"
+#include "settings/settings.h"
 
 namespace cura {
  
@@ -81,8 +81,35 @@ public:
     void optimize(); //!< sets #polyStart and #polyOrder
 
 private:
-    void checkIfLineIsBest(unsigned int i_line_polygon, int& best, float& bestDist, Point& prev_point, Point& incommingPerpundicularNormal);
+    /*!
+     * Update LineOrderOptimizer::polyStart if the current line is better than the current best.
+     * 
+     * Besides looking at the distance from the previous line segment, we also look at the angle we make.
+     * 
+     * We prefer 90 degree angles; 180 degree turn arounds are slow on machines where the jerk is limited.
+     * 0 degree (straight ahead) 'corners' occur only when a single infill line is interrupted, 
+     * in which case the travel move might involve combing, which makes it rather longer.
+     * 
+     * \param poly_idx[in] The index in LineOrderOptimizer::polygons for the current line to test
+     * \param best[in, out] The index of current best line
+     * \param best_score[in, out] The distance score for the current best line
+     * \param prev_point[in] The previous point from which to find the next best line
+     * \param incoming_perpundicular_normal[in] The direction of movement when the print head arrived at \p prev_point, turned 90 degrees CCW
+     */
+    void updateBestLine(unsigned int poly_idx, int& best, float& best_score, Point prev_point, Point incoming_perpundicular_normal);
 
+    /*!
+     * Get a score to modify the distance score for measuring how good two lines follow each other.
+     * 
+     * The angle score is symmetric in \p from and \p to; they can be exchanged without altering the result. (Code relies on this property)
+     * 
+     * \param incoming_perpundicular_normal The direction in which the head was moving while printing the previous line, turned 90 degrees CCW
+     * \param from The one end of the next line
+     * \param to The other end of the next line
+     * \return A score measuring how good the angle is of the line between \p from and \p to when the previous line had a direction given by \p incoming_perpundicular_normal 
+     * 
+     */
+    static float getAngleScore(Point incoming_perpundicular_normal, Point from, Point to);
 };
 
 }//namespace cura

src/pathPlanning/Comb.cpp

@@ -0,0 +1,336 @@
+/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
+#include "Comb.h"
+
+#include <algorithm>
+
+#include "../utils/polygonUtils.h"
+#include "../sliceDataStorage.h"
+#include "../utils/SVG.h"
+
+namespace cura {
+
+
+// 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;
+}
+
+  
+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
+, max_moveInside_distance2(offset_from_outlines * 2 * offset_from_outlines * 2)
+, offset_from_outlines_outside(travel_avoid_distance)
+, 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( 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 (boundary_outside)
+    {
+        delete boundary_outside;
+    }
+    if (outside_loc_to_line)
+    {
+        delete outside_loc_to_line;
+    }
+}
+
+bool Comb::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)
+{
+    if (shorterThen(endPoint - startPoint, max_comb_distance_ignored))
+    {
+        return true;
+    }
+
+    //Move start and end point inside the comb boundary
+    unsigned int start_inside_poly = NO_INDEX;
+    const bool startInside = moveInside(_startInside, startPoint, start_inside_poly);
+
+    unsigned int end_inside_poly = NO_INDEX;
+    const bool endInside = moveInside(_endInside, endPoint, end_inside_poly);
+
+    unsigned int start_part_boundary_poly_idx;
+    unsigned int end_part_boundary_poly_idx;
+    unsigned int start_part_idx =   (start_inside_poly == NO_INDEX)?    NO_INDEX : partsView_inside.getPartContaining(start_inside_poly, &start_part_boundary_poly_idx);
+    unsigned int end_part_idx =     (end_inside_poly == NO_INDEX)?      NO_INDEX : partsView_inside.getPartContaining(end_inside_poly, &end_part_boundary_poly_idx);
+    
+    if (startInside && endInside && start_part_idx == end_part_idx)
+    { // normal combing within part
+        PolygonsPart part = partsView_inside.assemblePart(start_part_idx);
+        combPaths.emplace_back();
+        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) 
+        //  INSIDE  |          in_between            |            OUTSIDE     |              in_between         |     INSIDE
+        //        ^crossing_1_in     ^crossing_1_mid  ^crossing_1_out        ^crossing_2_out    ^crossing_2_mid   ^crossing_2_in
+        //
+        // when startPoint is inside crossing_1_in is of interest
+        // when it is in between inside and outside it is equal to crossing_1_mid
+
+        if (via_outside_makes_combing_fail)
+        {
+            return false;
+        }
+
+        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 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
+            avoid_other_parts_now = false;
+        }
+
+        if (avoid_other_parts_now)
+        { // compute the crossing points when moving through air
+            Polygons& outside = getBoundaryOutside(); // comb through all air, since generally the outside consists of a single part
+
+            bool success = start_crossing.findOutside(outside, end_crossing.in_or_mid, fail_on_unavoidable_obstacles, *this);
+            if (!success)
+            {
+                return false;
+            }
+
+            success = end_crossing.findOutside(outside, start_crossing.out, fail_on_unavoidable_obstacles, *this);
+            if (!success)
+            {
+                return false;
+            }
+        }
+
+        // generate the actual comb paths
+        if (startInside)
+        {
+            // 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, 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;
+            }
+        }
+        
+        // throught air from boundary to boundary
+        if (avoid_other_parts_now)
+        {
+            combPaths.emplace_back();
+            combPaths.throughAir = true;
+            if ( vSize(start_crossing.in_or_mid - end_crossing.in_or_mid) < vSize(start_crossing.in_or_mid - start_crossing.out) + vSize(end_crossing.in_or_mid - end_crossing.out) )
+            { // via outside is moving more over the in-between zone
+                combPaths.back().push_back(start_crossing.in_or_mid);
+                combPaths.back().push_back(end_crossing.in_or_mid);
+            }
+            else
+            {
+                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;
+                }
+            }
+        }
+        else 
+        { // directly through air (not avoiding other parts)
+            combPaths.emplace_back();
+            combPaths.throughAir = true;
+            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 (endInside)
+        {
+            // boundary to end
+            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, 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;
+            }
+        }
+        
+        return true;
+    }
+}
+
+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)
+, 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)
+{
+
+}
+
+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);
+        if (cpp.point_idx == NO_INDEX)
+        {
+            return false;
+        }
+        else
+        {
+            inside_poly = cpp.poly_idx;
+            return true;
+        }
+    }
+    return false;
+}
+
+void Comb::Crossing::findCrossingInOrMid(const PartsView& partsView_inside, const Point close_to)
+{
+    if (dest_is_inside)
+    { // in-case
+        // find the point on the start inside-polygon closest to the endpoint, but also kind of close to the start point
+        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);
+        Point result(close_to);
+        int64_t max_dist2 = std::numeric_limits<int64_t>::max();
+        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;
+        }
+        else
+        { // part is too small to be ensuring a point inside with the given distance
+            in_or_mid = dest_point; // just use the startPoint or endPoint itself
+        }
+    }
+    else
+    {
+        in_or_mid = dest_point; // mid-case
+    }
+};
+
+bool Comb::Crossing::findOutside(const Polygons& outside, const Point close_to, const bool fail_on_unavoidable_obstacles, Comb& comber)
+{
+    out = in_or_mid;
+    if (dest_is_inside || outside.inside(in_or_mid, true)) // start in_between
+    { // move outside
+        Point preferred_crossing_1_out = in_or_mid + normal(close_to - in_or_mid, comber.offset_from_inside_to_outside);
+        std::function<int(Point)> close_to_penalty_function([preferred_crossing_1_out](Point candidate){ return vSize2((candidate - preferred_crossing_1_out) / 2); });
+        std::optional<ClosestPolygonPoint> crossing_1_out_cpp = PolygonUtils::findClose(in_or_mid, outside, comber.getOutsideLocToLine(), close_to_penalty_function);
+        if (crossing_1_out_cpp)
+        {
+            out = PolygonUtils::moveOutside(*crossing_1_out_cpp, comber.offset_dist_to_get_from_on_the_polygon_to_outside);
+        }
+        else 
+        {
+            PolygonUtils::moveOutside(outside, out, comber.offset_dist_to_get_from_on_the_polygon_to_outside);
+        }
+    }
+    int64_t in_out_dist2_1 = vSize2(out - in_or_mid); 
+    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
+        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);
+            out = PolygonUtils::moveOutside(best->second, comber.offset_dist_to_get_from_on_the_polygon_to_outside);
+        }
+        if (fail_on_unavoidable_obstacles && vSize2(out - in_or_mid) > comber.max_crossing_dist2) // moveInside moved still too far
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+
+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;
+    int64_t best_detour_score = std::numeric_limits<int64_t>::max();
+    int64_t best_crossing_dist2;
+    std::vector<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>> crossing_out_candidates = PolygonUtils::findClose(from, outside, comber.getOutsideLocToLine());
+    bool seen_close_enough_connection = false;
+    for (std::pair<ClosestPolygonPoint, ClosestPolygonPoint>& crossing_candidate : crossing_out_candidates)
+    {
+        int64_t crossing_dist2 = vSize2(crossing_candidate.first.location - crossing_candidate.second.location);
+        if (crossing_dist2 > comber.max_crossing_dist2 * 2)
+        { // preliminary filtering
+            continue;
+        }
+        
+        int64_t dist_to_start = vSize(crossing_candidate.second.location - estimated_start); // use outside location, so that the crossing direction is taken into account
+        int64_t dist_to_end = vSize(crossing_candidate.second.location - estimated_end);
+        int64_t detour_dist = dist_to_start + dist_to_end;
+        int64_t detour_score = crossing_dist2 + detour_dist * detour_dist / 1000; // prefer a closest connection over a detour
+        // The detour distance is generally large compared to the crossing distance.
+        // While the crossing is generally about 1mm across,
+        // the distance between an arbitrary point and the boundary may well be a couple of centimetres.
+        // So the crossing_dist2 is about 1.000.000 while the detour_dist_2 is in the order of 400.000.000
+        // In the end we just want to choose between two points which have the _same_ crossing distance, modulo rounding error.
+        if ((!seen_close_enough_connection && detour_score < best_detour_score) // keep the best as long as we havent seen one close enough (so that we may walk along the polygon to find a closer connection from it in the code below)
+            || (!seen_close_enough_connection && crossing_dist2 <= comber.max_crossing_dist2) // make the one which is close enough the best as soon as we see one close enough
+            || (seen_close_enough_connection && crossing_dist2 <= comber.max_crossing_dist2 && detour_score < best_detour_score)) // update to keep the best crossing which is close enough already
+        {
+            if (!seen_close_enough_connection && crossing_dist2 <= comber.max_crossing_dist2)
+            {
+                seen_close_enough_connection = true;
+            }
+            best_in = &crossing_candidate.first;
+            best_out = &crossing_candidate.second;
+            best_detour_score = detour_score;
+            best_crossing_dist2 = crossing_dist2;
+        }
+    }
+    if (best_detour_score == std::numeric_limits<int64_t>::max())
+    { // i.e. if best_in == nullptr or if best_out == nullptr
+        return std::shared_ptr<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>>();
+    }
+    if (best_crossing_dist2 > comber.max_crossing_dist2)
+    { // find closer point on line segments, rather than moving between vertices of the polygons only
+        PolygonUtils::walkToNearestSmallestConnection(*best_in, *best_out);
+        best_crossing_dist2 = vSize2(best_in->location - best_out->location);
+        if (best_crossing_dist2 > comber.max_crossing_dist2)
+        {
+            return std::shared_ptr<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>>();
+        }
+    }
+    return std::make_shared<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>>(*best_in, *best_out);
+}
+
+}//namespace cura

src/pathPlanning/Comb.h

@@ -0,0 +1,169 @@
+/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
+#ifndef PATH_PLANNING_COMB_H
+#define PATH_PLANNING_COMB_H
+
+#include <memory> // shared_ptr
+
+#include "../utils/polygon.h"
+#include "../utils/BucketGrid2D.h"
+#include "../utils/polygonUtils.h"
+
+#include "LinePolygonsCrossings.h"
+#include "CombPath.h"
+#include "CombPaths.h"
+
+namespace cura 
+{
+
+class SliceDataStorage;
+
+/*!
+ * Class for generating a full combing actions from a travel move from a start point to an end point.
+ * A single Comb object is used for each layer.
+ * 
+ * Comb::calc is the main function of this class.
+ * 
+ * Typical output: A combing path to the boundary of the polygon + a move through air avoiding other parts in the layer + a combing path from the boundary of the ending polygon to the end point.
+ * Each of these three is a CombPath; the first and last are within Comb::boundary_inside while the middle is outside of Comb::boundary_outside.
+ * Between these there is a little gap where the nozzle crosses the boundary of an object approximately perpendicular to its boundary.
+ * 
+ * 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 
+{
+    friend class LinePolygonsCrossings;
+private:
+    /*!
+     * A crossing from the inside boundary to the outside boundary.
+     * 
+     * 'dest' is either the startPoint or the endpoint of a whole combing move.
+     */
+    class Crossing
+    {
+    public:
+        bool dest_is_inside; //!< Whether the startPoint or endPoint is inside the inside boundary
+        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)
+        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
+         * 
+         * \param dest_point Either the eventual startPoint or the eventual endPoint of this combing move.
+         * \param dest_is_inside Whether the startPoint or endPoint is inside the inside boundary.
+         * \param dest_part_idx The index into Comb:partsView_inside of the part in which the \p dest_point is.
+         * \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);
+
+        /*!
+         * Find the not-outside location (Combing::in_or_mid) of the crossing between to the outside boundary
+         * 
+         * \param partsView_inside Structured indices onto Comb::boundary_inside which shows which polygons belong to which part. 
+         * \param close_to[in] Try to get a crossing close to this point
+         */
+        void findCrossingInOrMid(const PartsView& partsView_inside, const Point close_to);
+
+        /*!
+         * Find the outside location (Combing::out)
+         * 
+         * \param outside The outside boundary polygons
+         * \param close_to A point to get closer to when there are multiple candidates on the outside boundary which are almost equally close to the Crossing::in_or_mid
+         * \param fail_on_unavoidable_obstacles When moving over other parts is inavoidable, stop calculation early and return false.
+         * \param comber[in] The combing calculator which has references to the offsets and boundaries to use in combing.
+         */
+        bool findOutside(const Polygons& outside, const Point close_to, const bool fail_on_unavoidable_obstacles, Comb& comber);
+
+    private:
+        const Point dest_point; //!< Either the eventual startPoint or the eventual endPoint of this combing move
+        unsigned int dest_part_idx; //!< The index into Comb:partsView_inside of the part in which the \p dest_point is.
+
+        /*!
+         * Find the best crossing from some inside polygon to the outside boundary.
+         * 
+         * The detour from \p estimated_start to \p estimated_end is minimized.
+         * 
+         * \param outside The outside boundary polygons
+         * \param from From which inside boundary the crossing to the outside starts or ends
+         * \param estimated_start The one point to which to stay close when evaluating crossings which cross about the same distance
+         * \param estimated_end The other point to which to stay close when evaluating crossings which cross about the same distance
+         * \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, const PolygonRef from, Point estimated_start, Point estimated_end, Comb& comber);
+    };
+
+
+    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)
+    const int64_t max_moveInside_distance2; //!< Maximal distance of a point to the Comb::boundary_inside which is still to be considered inside. (very sharp corners not allowed :S)
+    const int64_t offset_from_outlines_outside; //!< Offset from the boundary of a part to a travel path which avoids it by this distance.
+    const int64_t offset_from_inside_to_outside; //!< The sum of the offsets for the inside and outside boundary Comb::offset_from_outlines and Comb::offset_from_outlines_outside
+    const int64_t max_crossing_dist2; //!< The maximal distance by which to cross the in_between area between inside and outside
+    static const int64_t max_moveOutside_distance2 = INT64_MAX; //!< Any point which is not inside should be considered outside.
+    static const int64_t offset_dist_to_get_from_on_the_polygon_to_outside = 40; //!< in order to prevent on-boundary vs crossing boundary confusions (precision thing)
+    static const int64_t offset_extra_start_end = 100; //!< Distance to move start point and end point toward eachother to extra avoid collision with the boundaries.
+
+    const bool avoid_other_parts; //!< Whether to perform inverse combing a.k.a. avoid parts.
+    
+    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 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
+     * \param is_inside[in] Whether the \p dest_point should be inside
+     * \param dest_point[in,out] The point to move
+     * \param start_inside_poly[out] The polygon in which the point has been moved
+     * \return Whether we have moved the point inside
+     */
+    bool moveInside(bool is_inside, Point& dest_point, unsigned int& start_inside_poly);
+
+public:
+    /*!
+     * Initializes the combing areas for every mesh in the layer (not support)
+     * \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.
+     * \param offset_from_outlines The offset from the outline polygon, to create the combing boundary in case there is no second wall.
+     * \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(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
+     * 
+     * \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
+     * \param startInside Whether we want to start inside the comb boundary
+     * \param endInside Whether we want to end up inside the comb boundary
+     * \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);
+};
+
+}//namespace cura
+
+#endif//PATH_PLANNING_COMB_H

src/pathPlanning/CombPath.h

@@ -0,0 +1,17 @@
+/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
+#ifndef PATH_PLANNING_COMB_PATH_H
+#define PATH_PLANNING_COMB_PATH_H
+
+#include "../utils/intpoint.h"
+
+namespace cura 
+{
+
+struct CombPath : public  std::vector<Point> //!< A single path either inside or outise the parts
+{
+    bool cross_boundary = false; //!< Whether the path crosses a boundary.
+};
+
+}//namespace cura
+
+#endif//PATH_PLANNING_COMB_PATH_H

src/pathPlanning/CombPaths.h

@@ -0,0 +1,17 @@
+/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
+#ifndef PATH_PLANNING_COMB_PATHS_H
+#define PATH_PLANNING_COMB_PATHS_H
+
+#include "CombPath.h"
+
+namespace cura 
+{
+
+struct CombPaths : public  std::vector<CombPath> //!< A list of paths alternating between inside a part and outside a part
+{
+    bool throughAir = false; //!< Whether the path is one which moves through air.
+}; 
+
+}//namespace cura
+
+#endif//PATH_PLANNING_COMB_PATHS_H

src/pathPlanning/LinePolygonsCrossings.cpp

@@ -0,0 +1,220 @@
+/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
+#include "LinePolygonsCrossings.h"
+
+#include <algorithm>
+
+#include "../utils/polygonUtils.h"
+#include "../sliceDataStorage.h"
+#include "../utils/SVG.h"
+
+namespace cura {
+
+
+bool LinePolygonsCrossings::calcScanlineCrossings(bool fail_on_unavoidable_obstacles)
+{
+    
+    min_crossing_idx = NO_INDEX;
+    max_crossing_idx = NO_INDEX;
+
+    for(unsigned int poly_idx = 0; poly_idx < boundary.size(); poly_idx++)
+    {
+        PolyCrossings minMax(poly_idx); 
+        PolygonRef poly = boundary[poly_idx];
+        Point p0 = transformation_matrix.apply(poly[poly.size() - 1]);
+        for(unsigned int point_idx = 0; point_idx < poly.size(); point_idx++)
+        {
+            Point p1 = transformation_matrix.apply(poly[point_idx]);
+            if ((p0.Y >= transformed_startPoint.Y && p1.Y <= transformed_startPoint.Y) || (p1.Y >= transformed_startPoint.Y && p0.Y <= transformed_startPoint.Y))
+            { // if line segment crosses the line through the transformed start and end point (aka scanline)
+                if (p1.Y == p0.Y) //Line segment is parallel with the scanline. That means that both endpoints lie on the scanline, so they will have intersected with the adjacent line.
+                {
+                    p0 = p1;
+                    continue;
+                }
+                int64_t x = p0.X + (p1.X - p0.X) * (transformed_startPoint.Y - p0.Y) / (p1.Y - p0.Y); // intersection point between line segment and the scanline
+                
+                if (x >= transformed_startPoint.X && x <= transformed_endPoint.X)
+                {
+                    if (!((p1.Y == transformed_startPoint.Y && p1.Y < p0.Y) || (p0.Y == transformed_startPoint.Y && p0.Y < p1.Y)))
+                    { // perform edge case only for line segments on and below the scanline, not for line segments on and above.
+                        // \/ will be no crossings and /\ two, but most importantly | will be one crossing.
+                        minMax.n_crossings++;
+                    }
+                    if(x < minMax.min.x) //For the leftmost intersection, move x left to stay outside of the border.
+                                         //Note: The actual distance from the intersection to the border is almost always less than dist_to_move_boundary_point_outside, since it only moves along the direction of the scanline.
+                    {
+                        minMax.min.x = x;
+                        minMax.min.point_idx = point_idx;
+                    }
+                    if(x > minMax.max.x) //For the rightmost intersection, move x right to stay outside of the border.
+                    {
+                        minMax.max.x = x;
+                        minMax.max.point_idx = point_idx;
+                    }
+                }
+            }
+            p0 = p1;
+        }
+
+        if (fail_on_unavoidable_obstacles && minMax.n_crossings % 2 == 1)
+        { // if start area and end area are not the same
+            return false;
+        }
+        else if (minMax.min.point_idx != NO_INDEX) // then always also max.point_idx != NO_INDEX
+        { // if this polygon crossed the scanline
+            if (min_crossing_idx == NO_INDEX || minMax.min.x < crossings[min_crossing_idx].min.x) { min_crossing_idx = crossings.size(); }
+            if (max_crossing_idx == NO_INDEX || minMax.max.x > crossings[max_crossing_idx].max.x) { max_crossing_idx = crossings.size(); }
+            crossings.push_back(minMax);
+        }
+    }
+    return true;
+}
+
+
+bool LinePolygonsCrossings::lineSegmentCollidesWithBoundary()
+{
+    Point diff = endPoint - startPoint;
+
+    transformation_matrix = PointMatrix(diff);
+    transformed_startPoint = transformation_matrix.apply(startPoint);
+    transformed_endPoint = transformation_matrix.apply(endPoint);
+
+    for(PolygonRef poly : boundary)
+    {
+        Point p0 = transformation_matrix.apply(poly.back());
+        for(Point p1_ : poly)
+        {
+            Point p1 = transformation_matrix.apply(p1_);
+            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;
+        }
+    }
+    
+    return false;
+}
+
+
+bool LinePolygonsCrossings::getCombingPath(CombPath& combPath, int64_t max_comb_distance_ignored, bool fail_on_unavoidable_obstacles)
+{
+    if (shorterThen(endPoint - startPoint, max_comb_distance_ignored) || !lineSegmentCollidesWithBoundary())
+    {
+        //We're not crossing any boundaries. So skip the comb generation.
+        combPath.push_back(startPoint); 
+        combPath.push_back(endPoint);
+        return true;
+    }
+    
+    bool success = calcScanlineCrossings(fail_on_unavoidable_obstacles);
+    if (!success)
+    {
+        return false;
+    }
+
+    CombPath basicPath;
+    getBasicCombingPath(basicPath);
+    optimizePath(basicPath, combPath);
+//     combPath = basicPath; // uncomment to disable comb path optimization
+    return true;
+}
+
+
+void LinePolygonsCrossings::getBasicCombingPath(CombPath& combPath) 
+{
+    for (PolyCrossings* crossing = getNextPolygonAlongScanline(transformed_startPoint.X)
+        ; crossing != nullptr
+        ; crossing = getNextPolygonAlongScanline(crossing->max.x))
+    {
+        getBasicCombingPath(*crossing, combPath);
+    }
+    combPath.push_back(endPoint);
+}
+
+void LinePolygonsCrossings::getBasicCombingPath(PolyCrossings& polyCrossings, CombPath& combPath) 
+{
+    PolygonRef poly = boundary[polyCrossings.poly_idx];
+    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
+        for(unsigned int point_idx = polyCrossings.min.point_idx
+            ; point_idx != polyCrossings.max.point_idx
+            ; point_idx = (point_idx < poly.size() - 1) ? (point_idx + 1) : (0))
+        {
+            combPath.push_back(PolygonUtils::getBoundaryPointWithOffset(poly, point_idx, dist_to_move_boundary_point_outside));
+        }
+    }
+    else
+    { // follow the path in the opposite direction of the winding order of the boundary polygon
+        unsigned int min_idx = (polyCrossings.min.point_idx == 0)? poly.size() - 1: polyCrossings.min.point_idx - 1;
+        unsigned int max_idx = (polyCrossings.max.point_idx == 0)? poly.size() - 1: polyCrossings.max.point_idx - 1;
+
+        for(unsigned int point_idx = min_idx; point_idx != max_idx; point_idx = (point_idx > 0) ? (point_idx - 1) : (poly.size() - 1))
+        {
+            combPath.push_back(PolygonUtils::getBoundaryPointWithOffset(poly, point_idx, dist_to_move_boundary_point_outside));
+        }
+    }
+    combPath.push_back(transformation_matrix.unapply(Point(polyCrossings.max.x + dist_to_move_boundary_point_outside, transformed_startPoint.Y))); 
+}
+
+
+
+LinePolygonsCrossings::PolyCrossings* LinePolygonsCrossings::getNextPolygonAlongScanline(int64_t x)
+{
+    PolyCrossings* ret = nullptr;
+    for(PolyCrossings& crossing : crossings)
+    {
+        if (crossing.min.x > x && (ret == nullptr || crossing.min.x < ret->min.x) )
+        {
+            ret = &crossing;
+        }
+    }
+    return ret;
+}
+
+bool LinePolygonsCrossings::optimizePath(CombPath& comb_path, CombPath& optimized_comb_path) 
+{
+    optimized_comb_path.push_back(startPoint);
+    for(unsigned int point_idx = 1; point_idx<comb_path.size(); point_idx++)
+    {
+        if(comb_path[point_idx] == comb_path[point_idx - 1]) //Two points are the same. Skip the second.
+        {
+            continue;
+        }
+        Point& current_point = optimized_comb_path.back();
+        if (PolygonUtils::polygonCollidesWithlineSegment(boundary, current_point, comb_path[point_idx]))
+        {
+            if (PolygonUtils::polygonCollidesWithlineSegment(boundary, current_point, comb_path[point_idx - 1]))
+            {
+                comb_path.cross_boundary = true;
+            }
+            optimized_comb_path.push_back(comb_path[point_idx - 1]);
+        }
+        else 
+        {
+            // : dont add the newest point
+            
+            // 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(boundary, optimized_comb_path[optimized_comb_path.size() - 2], comb_path[point_idx]))
+                {
+                    break;
+                }
+                else 
+                {
+                    optimized_comb_path.pop_back();
+                }
+            }
+        }
+    }
+    optimized_comb_path.push_back(comb_path.back());
+    return true;
+}
+
+}//namespace cura

src/pathPlanning/LinePolygonsCrossings.h

@@ -1,20 +1,13 @@
 /** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
-#ifndef COMB_H
-#define COMB_H
+#ifndef PATH_PLANNING_LINE_POLYGONS_CROSSINGS_H
+#define PATH_PLANNING_LINE_POLYGONS_CROSSINGS_H
 
-#include "utils/polygon.h"
+#include "../utils/polygon.h"
+
+#include "CombPath.h"
 
 namespace cura 
 {
-    
-struct CombPath : public  std::vector<Point> //!< A single path either inside or outise the parts
-{
-    bool throughAir = false; //!< Whether the path is one which moves through air.
-    bool cross_boundary = false; //!< Whether the path crosses a boundary.
-};
-struct CombPaths : public  std::vector<CombPath> //!< A list of paths alternating between inside a part and outside a part
-{
-}; 
 
 /*!
  * Class for generating a combing move action from point a to point b and avoiding collision with other parts when moving through air.
@@ -60,6 +53,7 @@ private:
         unsigned int poly_idx; //!< The index of the polygon which crosses the scanline
         Crossing min; //!< The point where the polygon first crosses the scanline.
         Crossing max; //!< The point where the polygon last crosses the scanline.
+        int n_crossings; //!< The number of times the polygon crossed the scanline.
         /*!
          * Create a PolyCrossings with minimal initialization. PolyCrossings::min and PolyCrossings::max are not yet computed.
          * \param poly_idx The index of the polygon in LinePolygonsCrossings::boundary
@@ -67,6 +61,7 @@ private:
         PolyCrossings(unsigned int poly_idx) 
         : poly_idx(poly_idx)
         , min(INT64_MAX, NO_INDEX), max(INT64_MIN, NO_INDEX) 
+        , n_crossings(0)
         { 
         }
     };
@@ -91,8 +86,8 @@ private:
     int64_t dist_to_move_boundary_point_outside; //!< The distance used to move outside or inside so that a boundary point doesn't intersect with the boundary anymore. Neccesary due to computational rounding problems. Use negative value for insicde combing.
     
     PointMatrix transformation_matrix; //!< The transformation which rotates everything such that the scanline is aligned with the x-axis.
-    Point transformed_startPoint; //!< The LinePolygonsCrossings::startPoint as transformed by Comb::transformation_matrix
-    Point transformed_endPoint; //!< The LinePolygonsCrossings::endPoint as transformed by Comb::transformation_matrix
+    Point transformed_startPoint; //!< The LinePolygonsCrossings::startPoint as transformed by Comb::transformation_matrix such that it has (roughly) the same Y as transformed_endPoint
+    Point transformed_endPoint; //!< The LinePolygonsCrossings::endPoint as transformed by Comb::transformation_matrix such that it has (roughly) the same Y as transformed_startPoint
 
     
     /*!
@@ -105,15 +100,19 @@ private:
     
     /*!
      * Calculate Comb::crossings, Comb::min_crossing_idx and Comb::max_crossing_idx.
+     * \param fail_on_unavoidable_obstacles When moving over other parts is inavoidable, stop calculation early and return false.
+     * \return Whether combing succeeded, i.e. when fail_on_unavoidable_obstacles: we didn't cross any gaps/other parts
      */
-    void calcScanlineCrossings();
+    bool calcScanlineCrossings(bool fail_on_unavoidable_obstacles);
     
     /*! 
      * Get the basic combing path and optimize it.
      * 
      * \param combPath Output parameter: the points along the combing path.
+     * \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
      */
-    void getCombingPath(CombPath& combPath);
+    bool getCombingPath(CombPath& combPath, int64_t max_comb_distance_ignored, bool fail_on_unavoidable_obstacles);
     
     /*! 
      * Get the basic combing path, without shortcuts. The path goes straight toward the endPoint and follows the boundary when it hits it, until it passes the scanline again.
@@ -177,99 +176,16 @@ public:
      * \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 void comb(Polygons& boundary, Point startPoint, Point endPoint, CombPath& combPath, int64_t dist_to_move_boundary_point_outside)
+    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, startPoint, endPoint, dist_to_move_boundary_point_outside);
-        linePolygonsCrossings.getCombingPath(combPath);
+        return linePolygonsCrossings.getCombingPath(combPath, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
     };
 };
 
-class SliceDataStorage;
-
-/*!
- * Class for generating a full combing actions from a travel move from a start point to an end point.
- * A single Comb object is used for each layer.
- * 
- * Comb::calc is the main function of this class.
- * 
- * Typical output: A combing path to the boundary of the polygon + a move through air avoiding other parts in the layer + a combing path from the boundary of the ending polygon to the end point.
- * Each of these three is a CombPath; the first and last are within Comb::boundary_inside while the middle is outside of Comb::boundary_outside.
- * Between these there is a little gap where the nozzle crosses the boundary of an object approximately perpendicular to its boundary.
- * 
- * 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 
-{
-    friend class LinePolygonsCrossings;
-private:
-    SliceDataStorage& storage; //!< The storage from which to compute the outside boundary, when needed.
-    unsigned int layer_nr; //!< The layer number for the layer for which to compute the outside boundary, when needed.
-    
-    int64_t offset_from_outlines; //!< Offset from the boundary of a part to the comb path. (nozzle width / 2)
-    int64_t max_moveInside_distance2; //!< Maximal distance of a point to the Comb::boundary_inside which is still to be considered inside. (very sharp corners not allowed :S)
-    int64_t offset_from_outlines_outside; //!< Offset from the boundary of a part to a travel path which avoids it by this distance.
-    static const int64_t max_moveOutside_distance2 = INT64_MAX; //!< Any point which is not inside should be considered outside.
-    static const int64_t offset_dist_to_get_from_on_the_polygon_to_outside = 40; //!< in order to prevent on-boundary vs crossing boundary confusions (precision thing)
-    static const int64_t max_comb_distance_ignored = MM2INT(1.5); //!< If the direct path from start point to end point is shorter than this, go directly without any combing.
-    static const int64_t offset_extra_start_end = 100; //!< Distance to move start point and end point toward eachother to extra avoid collision with the boundaries.
-    
-    bool avoid_other_parts; //!< Whether to perform inverse combing a.k.a. avoid parts.
-    
-    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)
-    PartsView partsView_inside; //!< Structured indices onto boundary_inside which shows which polygons belong to which part. 
-        
-    /*!
-     * Collects the inner most walls for every mesh in the layer (not support) or computes them from the outlines using Comb::offset_from_outlines.
-     */
-    Polygons getLayerSecondWalls();
-
-    /*!
-     * 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();
-    
-public:
-    /*!
-     * Initializes the combing areas for every mesh in the layer (not support)
-     * \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 offset_from_outlines The offset from the outline polygon, to create the combing boundary in case there is no second wall.
-     * \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(SliceDataStorage& storage, unsigned int layer_nr, int64_t offset_from_outlines, bool travel_avoid_other_parts, int64_t travel_avoid_distance);
-    
-    ~Comb();
-    
-    //! Utility function for `boundary_inside.inside(p)`.
-    bool inside(const Point p) { return boundary_inside.inside(p); }
-
-    /*!
-     * Calculate the comb paths (if any) - one for each polygon combed alternated with travel paths
-     * 
-     * \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
-     * \param startInside Whether we want to start inside the comb boundary
-     * \param endInside Whether we want to end up inside the comb boundary
-     * \return Whether combing has succeeded; otherwise a retraction is needed.
-     */    
-    bool calc(Point startPoint, Point endPoint, CombPaths& combPaths, bool startInside = false, bool endInside = false);
-    
-    /*!
-     * Move \p p to inside the inner comb boundary with a \p distance from the boundary.
-     * 
-     * \param p the point to change/move
-     * \param distance the distance from the resulting point to the boundary on the inside
-     * \return whether the point has been moved inside
-     */
-    bool moveInsideBoundary(Point* p, int distance);
-    
-};
-
 }//namespace cura
 
-#endif//COMB_H
+#endif//PATH_PLANNING_LINE_POLYGONS_CROSSINGS_H

src/progress/Progress.cpp

@@ -1,30 +1,28 @@
 /** Copyright (C) 2015 Ultimaker - Released under terms of the AGPLv3 License */
 #include "Progress.h"
 
-#include "commandSocket.h"
-#include "utils/gettime.h"
+#include "../commandSocket.h"
+#include "../utils/gettime.h"
 
 namespace cura {
     
 double Progress::times [] = 
 { 
-    0.0, 
-    5.269, 
-    1.533, 
-    22.953,
-    51.009, 
-    48.858, 
-    154.62, 
-    0.1 
+    0.0,    // START   = 0, 
+    5.269,  // SLICING = 1, 
+    1.533,  // PARTS   = 2, 
+    71.811, // INSET_SKIN = 3
+    51.009, // SUPPORT = 4, 
+    154.62, // EXPORT  = 5, 
+    0.1     // FINISH  = 6
 };
 std::string Progress::names [] = 
 {
     "start",
     "slice",
     "layerparts",
-    "inset",
+    "inset+skin",
     "support",
-    "skin",
     "export",
     "process"
 };
@@ -39,9 +37,8 @@ const Progress::Stage Progress::stages[] =
     Progress::Stage::START, 
     Progress::Stage::SLICING, 
     Progress::Stage::PARTS, 
-    Progress::Stage::INSET, 
+    Progress::Stage::INSET_SKIN, 
     Progress::Stage::SUPPORT, 
-    Progress::Stage::SKIN, 
     Progress::Stage::EXPORT, 
     Progress::Stage::FINISH 
 };
@@ -64,22 +61,22 @@ void Progress::init()
     total_timing = accumulated_time;
 }
 
-void Progress::messageProgress(Progress::Stage stage, int progress_in_stage, int progress_in_stage_max, CommandSocket* command_socket)
+void Progress::messageProgress(Progress::Stage stage, int progress_in_stage, int progress_in_stage_max)
 {
     float percentage = calcOverallProgress(stage, float(progress_in_stage) / float(progress_in_stage_max));
-    if (command_socket)
+    if (CommandSocket::getInstance())
     {
-        command_socket->sendProgress(percentage);
+        CommandSocket::getInstance()->sendProgress(percentage);
     }
     
     logProgress(names[(int)stage].c_str(), progress_in_stage, progress_in_stage_max, percentage);
 }
 
-void Progress::messageProgressStage(Progress::Stage stage, TimeKeeper* time_keeper, CommandSocket* command_socket)
+void Progress::messageProgressStage(Progress::Stage stage, TimeKeeper* time_keeper)
 {
-    if (command_socket)
+    if (CommandSocket::getInstance())
     {
-        command_socket->sendProgressStage(stage);
+        CommandSocket::getInstance()->sendProgressStage(stage);
     }
     
     if (time_keeper)

src/progress/Progress.h

@@ -4,14 +4,14 @@
 
 #include <string>
 
-#include "utils/logoutput.h"
-#include "utils/gettime.h"
+#include "../utils/logoutput.h"
+#include "../utils/gettime.h"
 
 namespace cura {
 
 class CommandSocket;
 
-#define N_PROGRESS_STAGES 8
+#define N_PROGRESS_STAGES 7
 
 /*!
  * Class for handling the progress bar and the progress logging.
@@ -30,11 +30,10 @@ public:
         START   = 0, 
         SLICING = 1, 
         PARTS   = 2, 
-        INSET   = 3, 
+        INSET_SKIN = 3, 
         SUPPORT = 4, 
-        SKIN    = 5, 
-        EXPORT  = 6, 
-        FINISH  = 7
+        EXPORT  = 5, 
+        FINISH  = 6
     };
 private:
     static double times [N_PROGRESS_STAGES]; //!< Time estimates per stage
@@ -52,22 +51,20 @@ private:
 public:
     static void init(); //!< Initialize some values needed in a fast computation of the progress
     /*!
-     * Message progress over the \p commandSocket and to the terminal (if the command line arg '-p' is provided).
+     * Message progress over the CommandSocket and to the terminal (if the command line arg '-p' is provided).
      * 
      * \param stage The current stage of processing
      * \param progress_in_stage Any number giving the progress within the stage
      * \param progress_in_stage_max The maximal value of \p progress_in_stage
-     * \param commandSocket The command socket over which to communicate the progress.
      */
-    static void messageProgress(Stage stage, int progress_in_stage, int progress_in_stage_max, CommandSocket* commandSocket);
+    static void messageProgress(Stage stage, int progress_in_stage, int progress_in_stage_max);
     /*!
      * Message the progress stage over the command socket.
      * 
      * \param stage The current stage
      * \param timeKeeper The stapwatch keeping track of the timings for each stage (optional)
-     * \param commandSocket The command socket over which to communicate (optional)
      */
-    static void messageProgressStage(Stage stage, TimeKeeper* timeKeeper, CommandSocket* commandSocket);
+    static void messageProgressStage(Stage stage, TimeKeeper* timeKeeper);
 };
 
 

src/progress/ProgressEstimator.h

@@ -0,0 +1,29 @@
+/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
+#ifndef PROGRESS_PROGRESS_ESTIMATOR_H
+#define PROGRESS_PROGRESS_ESTIMATOR_H
+
+#include <vector>
+
+namespace cura
+{
+/*
+ * ProgressEstimator is a finger-tree with ProgressEstimatorLinear as leaves.
+ * 
+ * Each (non-leaf) node consists of a ProgressStageEstimator which consists of several stages.
+ * 
+ * The structure of this tree is an oversimplification of the call graph of CuraEngine.
+ * 
+ */
+    
+class ProgressEstimator
+{
+public:
+    virtual double progress(int current_step) = 0;
+    virtual ~ProgressEstimator()
+    {
+    }
+};
+
+} // namespace cura
+
+#endif // PROGRESS_PROGRESS_ESTIMATOR_H

src/progress/ProgressEstimatorLinear.h

@@ -0,0 +1,29 @@
+/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
+#ifndef PROGRESS_PROGRESS_ESTIMATOR_LINEAR_H
+#define PROGRESS_PROGRESS_ESTIMATOR_LINEAR_H
+
+#include <vector>
+
+#include "ProgressEstimator.h"
+
+namespace cura
+{
+
+
+class ProgressEstimatorLinear : public ProgressEstimator
+{
+    unsigned int total_steps;
+public:
+    ProgressEstimatorLinear(unsigned int total_steps)
+    : total_steps(total_steps)
+    {
+    }
+    double progress(int current_step)
+    {
+        return double(current_step) / double(total_steps);
+    }
+};
+
+} // namespace cura
+
+#endif // PROGRESS_PROGRESS_ESTIMATOR_LINEAR_H

src/progress/ProgressStageEstimator.cpp

@@ -0,0 +1,52 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#include "ProgressStageEstimator.h"
+
+
+namespace cura 
+{
+
+
+ProgressStageEstimator::ProgressStageEstimator(std::vector< double >& relative_time_estimates)
+: total_estimated_time(0)
+, accumulated_estimate(0)
+, current_stage_idx(-1)
+{
+    stages.reserve(relative_time_estimates.size());
+    for (double relative_estimated_time : relative_time_estimates)
+    {
+        stages.emplace_back(relative_estimated_time);
+        total_estimated_time += relative_estimated_time;
+    }
+}
+
+ProgressStageEstimator::~ProgressStageEstimator()
+{
+    for (ProgressStage& stage : stages)
+    {
+        delete stage.stage;
+    }
+}
+
+double ProgressStageEstimator::progress(int current_step)
+{
+    ProgressStage& current_stage = stages[current_stage_idx];
+    return (accumulated_estimate + current_stage.stage->progress(current_step) * current_stage.relative_estimated_time) / total_estimated_time;
+}
+
+void ProgressStageEstimator::nextStage(ProgressEstimator* stage)
+{
+    if (current_stage_idx >= int(stages.size()) - 1)
+    {
+        return;
+    }
+    if (current_stage_idx >= 0)
+    {
+        ProgressStage& current_stage = stages[current_stage_idx];
+        accumulated_estimate += current_stage.relative_estimated_time;
+    }
+    current_stage_idx++;
+    stages[current_stage_idx].stage = stage;
+}
+
+
+} // namespace cura 

src/progress/ProgressStageEstimator.h

@@ -0,0 +1,54 @@
+/** Copyright (C) 2016 Tim Kuipers - Released under terms of the AGPLv3 License */
+#ifndef PROGRESS_PROGRESS_STAGE_ESTIMATOR_H
+#define PROGRESS_PROGRESS_STAGE_ESTIMATOR_H
+
+#include <vector>
+
+#include "ProgressEstimator.h"
+
+namespace cura
+{
+
+/*!
+ * A staged progress estimator which estimates each stage to have different times.
+ */
+class ProgressStageEstimator : public ProgressEstimator
+{
+    struct ProgressStage
+    {
+        double relative_estimated_time;
+        ProgressEstimator* stage;
+        ProgressStage(double relative_estimated_time)
+        : relative_estimated_time(relative_estimated_time)
+        , stage(nullptr)
+        {
+        }
+        
+    };
+    
+protected:
+    std::vector<ProgressStage> stages;
+    double total_estimated_time;
+    
+private:
+    double accumulated_estimate;
+    int current_stage_idx;
+    
+public:
+    ProgressStageEstimator(std::vector<double>& relative_time_estimates);
+    
+    double progress(int current_step);
+    
+    /*!
+     * 
+     * \warning This class is responsible for deleting the \p stage
+     * 
+     */
+    void nextStage(ProgressEstimator* stage);
+    
+    ~ProgressStageEstimator();
+};
+
+} // namespace cura
+
+#endif // PROGRESS_PROGRESS_STAGE_ESTIMATOR_H

src/raft.cpp

@@ -1,4 +1,6 @@
 /** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
+#include <clipper/clipper.hpp>
+
 #include "raft.h"
 #include "support.h"
 
@@ -8,15 +10,15 @@ void generateRaft(SliceDataStorage& storage, int distance)
 {
     if (storage.draft_protection_shield.size() > 0)
     {
-        storage.raftOutline = storage.raftOutline.unionPolygons(storage.draft_protection_shield.offset(distance));
+        storage.raftOutline = storage.raftOutline.unionPolygons(storage.draft_protection_shield.offset(distance, ClipperLib::jtRound));
     }
     else if (storage.oozeShield.size() > 0 && storage.oozeShield[0].size() > 0)
     {
-        storage.raftOutline = storage.raftOutline.unionPolygons(storage.oozeShield[0].offset(distance));
+        storage.raftOutline = storage.raftOutline.unionPolygons(storage.oozeShield[0].offset(distance, ClipperLib::jtRound));
     }
     else 
     {
-        storage.raftOutline = storage.getLayerOutlines(0, true);
+        storage.raftOutline = storage.getLayerOutlines(0, true).offset(distance, ClipperLib::jtRound);
     }
 }
 

src/settingRegistry.cpp

@@ -1,312 +0,0 @@
-#include "settingRegistry.h"
-
-#include <sstream>
-#include <iostream> // debug IO
-#include <libgen.h> // dirname
-#include <string>
-
-#include "utils/logoutput.h"
-
-#include "rapidjson/rapidjson.h"
-#include "rapidjson/document.h"
-#include "rapidjson/error/en.h"
-#include "rapidjson/filereadstream.h"
-#include "utils/logoutput.h"
-
-namespace cura
-{
-    
-SettingRegistry SettingRegistry::instance; // define settingRegistry
-
-std::string SettingRegistry::toString(rapidjson::Type type)
-{
-    switch (type)
-    {
-        case rapidjson::Type::kNullType: return "null";
-        case rapidjson::Type::kFalseType: return "false";
-        case rapidjson::Type::kTrueType: return "true";
-        case rapidjson::Type::kObjectType: return "object";
-        case rapidjson::Type::kArrayType: return "array";
-        case rapidjson::Type::kStringType: return "string";
-        case rapidjson::Type::kNumberType: return "number";
-        default: return "Unknown";
-    }
-}
-
-
-SettingContainer::SettingContainer(std::string key, std::string label)
-: key(key)
-, label(label)
-{
-}
-
-SettingConfig* SettingContainer::addChild(std::string key, std::string label)
-{
-    children.emplace_back(key, label, nullptr);
-    return &children.back();
-}
-
-SettingConfig::SettingConfig(std::string key, std::string label, SettingContainer* parent)
-: SettingContainer(key, label)
-, parent(parent)
-{
-//     std::cerr << key << std::endl; // debug output to show all frontend registered settings...
-}
-
-bool SettingRegistry::settingExists(std::string key) const
-{
-    return settings.find(key) != settings.end();
-}
-
-SettingConfig* SettingRegistry::getSettingConfig(std::string key)
-{
-    auto it = settings.find(key);
-    if (it == settings.end())
-        return nullptr;
-    return it->second;
-}
-
-SettingContainer* SettingRegistry::getCategory(std::string key)
-{
-    for (SettingContainer& cat : categories)
-        if (cat.getKey().compare(key) == 0)
-            return &cat;
-    return nullptr;
-}
-
-
-SettingRegistry::SettingRegistry()
-{
-}
-
-bool SettingRegistry::settingsLoaded()
-{
-    return settings.size() > 0;
-}
-
-int SettingRegistry::loadJSON(std::string filename, rapidjson::Document& json_document)
-{
-    FILE* f = fopen(filename.c_str(), "rb");
-    if (!f)
-    {
-        cura::logError("Couldn't open JSON file.\n");
-        return 1;
-    }
-    char read_buffer[4096];
-    rapidjson::FileReadStream reader_stream(f, read_buffer, sizeof(read_buffer));
-    json_document.ParseStream(reader_stream);
-    fclose(f);
-    if (json_document.HasParseError())
-    {
-        cura::logError("Error parsing JSON(offset %u): %s\n", (unsigned)json_document.GetErrorOffset(), GetParseError_En(json_document.GetParseError()));
-        return 2;
-    }
-    
-    return 0;
-}
-
-int SettingRegistry::loadJSONsettings(std::string filename)
-{
-    rapidjson::Document json_document;
-    
-    int err = loadJSON(filename, json_document);
-    if (err) { return err; }
-    
-    if (json_document.HasMember("inherits"))
-    {
-        std::string filename_copy = std::string(filename.c_str()); // copy the string because dirname(.) changes the input string!!!
-        char* filename_cstr = (char*)filename_copy.c_str();
-        int err = loadJSONsettings(std::string(dirname(filename_cstr)) + std::string("/") + json_document["inherits"].GetString());
-        if (err) { return err; }
-        return loadJSONsettingsFromDoc(json_document, false);
-    }
-    else 
-    {
-        return loadJSONsettingsFromDoc(json_document, true);
-    }
-    
-}
-
-int SettingRegistry::loadJSONsettingsFromDoc(rapidjson::Document& json_document, bool warn_duplicates)
-{
-    
-    if (!json_document.IsObject())
-    {
-        cura::logError("JSON file is not an object.\n");
-        return 3;
-    }
-
-    if (json_document.HasMember("machine_extruder_trains"))
-    {
-        categories.emplace_back("machine_extruder_trains", "Extruder Trains Settings Objects");
-        SettingContainer* category_trains = &categories.back();
-        const rapidjson::Value& trains = json_document["machine_extruder_trains"];
-        if (trains.IsArray()) 
-        {
-            if (trains.Size() > 0 && trains[0].IsObject())
-            {
-                unsigned int idx = 0;
-                for (auto it = trains.Begin(); it != trains.End(); ++it)
-                {
-                    SettingConfig* child = category_trains->addChild(std::to_string(idx), std::to_string(idx));
-                    
-                    for (rapidjson::Value::ConstMemberIterator setting_iterator = it->MemberBegin(); setting_iterator != it->MemberEnd(); ++setting_iterator)
-                    {
-                        _addSettingToContainer(child, setting_iterator, warn_duplicates, false);
-                    }
-                    
-                    idx++;
-                }
-            }
-        }
-        else 
-        {
-            logError("Error: JSON machine_extruder_trains is not an array!\n");
-        }
-    }
-    if (json_document.HasMember("machine_settings"))
-    {
-        categories.emplace_back("machine_settings", "Machine Settings");
-        SettingContainer* category_machine_settings = &categories.back();
-        
-        const rapidjson::Value& json_object_container = json_document["machine_settings"];
-        for (rapidjson::Value::ConstMemberIterator setting_iterator = json_object_container.MemberBegin(); setting_iterator != json_object_container.MemberEnd(); ++setting_iterator)
-        {
-            _addSettingToContainer(category_machine_settings, setting_iterator, warn_duplicates);
-        }
-    }
-    
-    if (json_document.HasMember("categories"))
-    {
-        for (rapidjson::Value::ConstMemberIterator category_iterator = json_document["categories"].MemberBegin(); category_iterator != json_document["categories"].MemberEnd(); ++category_iterator)
-        {
-            if (!category_iterator->value.IsObject())
-            {
-                continue;
-            }
-            if (!category_iterator->value.HasMember("label") || !category_iterator->value["label"].IsString())
-            {
-                continue;
-            }
-            if (!category_iterator->value.HasMember("settings") || !category_iterator->value["settings"].IsObject())
-            {
-                continue;
-            }
-            
-            categories.emplace_back(category_iterator->name.GetString(), category_iterator->value["label"].GetString());
-            SettingContainer* category = &categories.back();
-            
-            const rapidjson::Value& json_object_container = category_iterator->value["settings"];
-            for (rapidjson::Value::ConstMemberIterator setting_iterator = json_object_container.MemberBegin(); setting_iterator != json_object_container.MemberEnd(); ++setting_iterator)
-            {
-                _addSettingToContainer(category, setting_iterator, warn_duplicates);
-            }
-        }
-    }
-    
-    if (false && json_document.HasMember("overrides"))
-    {
-        const rapidjson::Value& json_object_container = json_document["overrides"];
-        for (rapidjson::Value::ConstMemberIterator override_iterator = json_object_container.MemberBegin(); override_iterator != json_object_container.MemberEnd(); ++override_iterator)
-        {
-            SettingConfig* conf = getSettingConfig(override_iterator->name.GetString());
-            _addSettingToContainer(conf, override_iterator, false);
-        }
-    }
-    
-    return 0;
-}
-void SettingRegistry::_addSettingToContainer(SettingContainer* parent, rapidjson::Value::ConstMemberIterator& json_object_it, bool warn_duplicates, bool add_to_settings)
-{
-        const rapidjson::Value& data = json_object_it->value;
-        
-        if (data.HasMember("type") && data["type"].IsString() && 
-            (data["type"].GetString() == std::string("polygon") || data["type"].GetString() == std::string("polygons")))
-        {
-            logWarning("Loading polygon setting %s not implemented...\n", json_object_it->name.GetString());
-            /// When this setting has children, add those children to the parent setting.
-            if (data.HasMember("children") && data["children"].IsObject())
-            {
-                const rapidjson::Value& json_object_container = data["children"];
-                for (rapidjson::Value::ConstMemberIterator setting_iterator = json_object_container.MemberBegin(); setting_iterator != json_object_container.MemberEnd(); ++setting_iterator)
-                {
-                    _addSettingToContainer(parent, setting_iterator, warn_duplicates, add_to_settings);
-                }
-            }
-            return;
-        }
-        
-        std::string label;
-        if (!json_object_it->value.HasMember("label") || !data["label"].IsString())
-        {
-            label = "N/A";
-        }
-        else
-        {
-            label = data["label"].GetString();
-        }
-
-        /// Create the new setting config object.
-        SettingConfig* config = parent->addChild(json_object_it->name.GetString(), label);
-        
-        
-        /// Fill the setting config object with data we have in the json file.
-        if (data.HasMember("type") && data["type"].IsString())
-        {
-            config->setType(data["type"].GetString());
-        }
-        if (data.HasMember("default"))
-        {
-            const rapidjson::Value& dflt = data["default"];
-            if (dflt.IsString())
-            {
-                config->setDefault(dflt.GetString());
-            }
-            else if (dflt.IsTrue())
-            {
-                config->setDefault("true");
-            }
-            else if (dflt.IsFalse())
-            {
-                config->setDefault("false");
-            }
-            else if (dflt.IsNumber())
-            {
-                std::ostringstream ss;
-                ss << dflt.GetDouble();
-                config->setDefault(ss.str());
-            } // arrays are ignored because machine_extruder_trains needs to be handled separately
-            else 
-            {
-                logError("Unrecognized data type in JSON: %s has type %s\n", json_object_it->name.GetString(), toString(dflt.GetType()).c_str());
-            }
-        }
-        if (data.HasMember("unit") && data["unit"].IsString())
-        {
-            config->setUnit(data["unit"].GetString());
-        }
-        
-        /// Register the setting in the settings map lookup.
-        if (warn_duplicates && settingExists(config->getKey()))
-        {
-            cura::logError("Duplicate definition of setting: %s a.k.a. \"%s\" was already claimed by \"%s\"\n", config->getKey().c_str(), config->getLabel().c_str(), getSettingConfig(config->getKey())->getLabel().c_str());
-        }
-        
-        if (add_to_settings)
-        {
-            settings[config->getKey()] = config;
-        }
-
-        /// When this setting has children, add those children to this setting.
-        if (data.HasMember("children") && data["children"].IsObject())
-        {
-            const rapidjson::Value& json_object_container = data["children"];
-            for (rapidjson::Value::ConstMemberIterator setting_iterator = json_object_container.MemberBegin(); setting_iterator != json_object_container.MemberEnd(); ++setting_iterator)
-            {
-                _addSettingToContainer(parent, setting_iterator, warn_duplicates, add_to_settings);
-            }
-        }
-}
-
-
-}//namespace cura

src/settingRegistry.h

@@ -1,191 +0,0 @@
-#ifndef SETTING_REGISTRY_H
-#define SETTING_REGISTRY_H
-
-#include <vector>
-#include <list>
-#include <unordered_map>
-#include <string>
-
-#include "utils/NoCopy.h"
-#include "rapidjson/document.h"
-
-namespace cura
-{
-    
-// Forward declaration
-class SettingConfig;
-
-/*!
- * Setting category.
- * Filled from the fdmprinter.json file. Contains one or more children settings.
- */
-class SettingContainer
-{
-    friend class SettingConfig;
-private:
-    std::string key;
-    std::string label;
-    std::list<SettingConfig> children;
-public:
-    std::string getKey() const { return key; }
-    std::string getLabel() const { return label; }
-    SettingContainer(std::string key, std::string label);
-    
-    SettingConfig* addChild(std::string key, std::string label);
-    
-    /*!
-     * Get the \p idx th child.
-     * 
-     * This is used to get a specific extruder train in Settingsbase::setExtruderTrainDefaults
-     * 
-     * \param idx The index in the list of children
-     * \return The \p idx th child
-     */
-    const SettingConfig* getChild(unsigned int idx) const
-    {
-        if (idx < children.size())
-        {
-            auto it = children.begin();
-            while (idx > 0) { ++it; idx--; }
-            return &*it;
-        }
-        else 
-            return nullptr;
-    }
-};
-
-/*!
- * Single setting data.
- * Filled from the fdmprinter.json file. Can contain child settings, and is registered in the
- * setting registry with it's key.
- */
-class SettingConfig : public SettingContainer
-{
-private:
-    std::string type;
-    std::string default_value;
-    std::string unit;
-    SettingContainer* parent;
-public:
-    SettingConfig(std::string key, std::string label, SettingContainer* parent);
-    
-    /*!
-     * Get the SettingConfig::children.
-     * 
-     * This is used to get the extruder trains; see Settingsbase::setExtruderTrainDefaults
-     * 
-     * \return SettingConfig::children
-     */
-    const std::list<SettingConfig>& getChildren() const { return children; }
-    
-    std::string getKey() const
-    {
-        return key;
-    }
-    
-    void setType(std::string type)
-    {
-        this->type = type;
-    }
-    
-    std::string getType() const
-    {
-        return type;
-    }
-
-    void setDefault(std::string default_value)
-    {
-        this->default_value = default_value;
-    }
-    
-    std::string getDefaultValue() const
-    {
-        return default_value;
-    }
-
-    void setUnit(std::string unit)
-    {
-        this->unit = unit;
-    }
-    
-    std::string getUnit() const
-    {
-        return unit;
-    }
-};
-
-/*!
- * Setting registry.
- * There is a single global setting registry.
- * This registry contains all known setting keys.
- * The registry also contains the settings categories to build up the setting hiarcy from the json file.
- */
-class SettingRegistry : NoCopy
-{
-private:
-    static SettingRegistry instance;
-
-    SettingRegistry();
-    
-    std::unordered_map<std::string, SettingConfig*> settings;
-    std::list<SettingContainer> categories;
-public:
-    /*!
-     * Get the SettingRegistry.
-     * 
-     * This is a singleton class.
-     * 
-     * \return The SettingRegistry
-     */
-    static SettingRegistry* getInstance() { return &instance; }
-    
-    bool settingExists(std::string key) const;
-    SettingConfig* getSettingConfig(std::string key);
-    
-    /*!
-     * Return the first category with the given key as name, or a null pointer.
-     * 
-     * \param key the key as it is in the JSON file
-     * \return The first category in the list having the \p key
-     */
-    SettingContainer* getCategory(std::string key);
-    
-    bool settingsLoaded();
-    /*!
-     * Load settings from a json file and all the parents it inherits from.
-     * 
-     * Uses recursion to load the parent json file.
-     * 
-     * \param filename The filename of the json file to parse
-     * \return an error code or zero of succeeded
-     */
-    int loadJSONsettings(std::string filename);
-    
-private:
-    std::string toString(rapidjson::Type type);
-    /*!
-     * Load a json document.
-     * 
-     * \param filename The filename of the json file to parse
-     * \param json_document (output) the document to be loaded
-     * \return an error code or zero of succeeded
-     */
-    int loadJSON(std::string filename, rapidjson::Document& json_document);
-    
-    /*!
-     * Load settings from a single json file.
-     * 
-     * \param filename The filename of the json file to parse
-     * \param warn_duplicates whether to warn for duplicate definitions
-     * \return an error code or zero of succeeded
-     */
-    int loadJSONsettingsFromDoc(rapidjson::Document& json_document, bool warn_duplicates);
-    
-    /*!
-     * \param warn_duplicates whether to warn for duplicate definitions
-     */
-    void _addSettingToContainer(SettingContainer* parent, rapidjson::Value::ConstMemberIterator& json_object_it, bool warn_duplicates, bool add_to_settings = true);
-};
-
-}//namespace cura
-#endif//SETTING_REGISTRY_H

src/settings/SettingConfig.cpp

@@ -0,0 +1,14 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#include "SettingConfig.h"
+
+
+namespace cura
+{
+
+SettingConfig::SettingConfig(std::string key, std::string label)
+: SettingContainer(key, label)
+{
+//     std::cerr << key << std::endl; // debug output to show all frontend registered settings...
+}
+
+}//namespace cura

src/settings/SettingConfig.h

@@ -0,0 +1,76 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#ifndef SETTINGS_SETTING_CONFIG_H
+#define SETTINGS_SETTING_CONFIG_H
+
+#include <string>
+#include <iostream> // debug out
+
+#include "SettingContainer.h"
+
+#include "../utils/NoCopy.h"
+#include "rapidjson/document.h"
+
+namespace cura
+{
+
+/*!
+ * Single setting data.
+ * Filled from the fdmprinter.json file. Can contain child settings, and is registered in the
+ * setting registry with it's key.
+ */
+class SettingConfig : public SettingContainer
+{
+private:
+    std::string type; //!< The type of the default_value, e.g. str, int, bool
+    std::string default_value; //!< The default value for this setting
+    std::string unit; //!< The unit of the physical quantity in which this setting is measured, e.g. "mm", "mm/s", ""
+public:
+    SettingConfig(std::string key, std::string label);
+
+    std::string getKey() const
+    {
+        return key;
+    }
+    
+    void setType(std::string type)
+    {
+        this->type = type;
+    }
+    
+    std::string getType() const
+    {
+        return type;
+    }
+
+    void setDefault(std::string default_value)
+    {
+        this->default_value = default_value;
+    }
+    
+    std::string getDefaultValue() const
+    {
+        return default_value;
+    }
+
+    void setUnit(std::string unit)
+    {
+        this->unit = unit;
+    }
+    
+    std::string getUnit() const
+    {
+        return unit;
+    }
+    
+    void debugOutputAllSettings() const
+    {
+        std::cerr << key <<  "(" << default_value << ")" << std::endl;
+        for (const SettingConfig& child : children)
+        {
+            child.debugOutputAllSettings();
+        }
+    }
+};
+
+}//namespace cura
+#endif//SETTINGS_SETTING_CONFIG_H

src/settings/SettingContainer.cpp

@@ -0,0 +1,47 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#include "SettingContainer.h"
+#include "SettingConfig.h"
+
+#include <string>
+#include <algorithm> // find_if
+
+namespace cura
+{
+
+SettingContainer::SettingContainer(std::string key, std::string label)
+: key(key)
+, label(label)
+{
+}
+
+SettingConfig* SettingContainer::addChild(std::string key, std::string label)
+{
+    children.emplace_back(key, label);
+    return &children.back();
+}
+
+SettingConfig& SettingContainer::getOrCreateChild(std::string key, std::string label)
+{
+    auto child_it = std::find_if(children.begin(), children.end(), [&key](SettingConfig& child) { return child.key == key; } );
+    if (child_it == children.end())
+    {
+        children.emplace_back(key, label);
+        return children.back();
+    }
+    else
+    {
+        return *child_it;
+    }
+}
+
+
+void SettingContainer::debugOutputAllSettings() const
+{
+    std::cerr << "\nSETTINGS BASE: " << key << std::endl;
+    for (const SettingConfig& child : children)
+    {
+        child.debugOutputAllSettings();
+    }
+}
+
+}//namespace cura

src/settings/SettingContainer.h

@@ -0,0 +1,83 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#ifndef SETTINGS_SETTING_CONTAINER_H
+#define SETTINGS_SETTING_CONTAINER_H
+
+#include <vector>
+#include <list>
+#include <unordered_map>
+#include <string>
+#include <iostream> // debug out
+
+#include "../utils/NoCopy.h"
+#include "rapidjson/document.h"
+
+namespace cura
+{
+    
+// Forward declaration
+class SettingConfig;
+class SettingRegistry;
+
+/*!
+ * Setting container for a settings base of definitions and default values.
+ * Filled from the .def.json files. Contains one or more children settings.
+ */
+class SettingContainer
+{
+    friend class SettingConfig;
+    friend class SettingRegistry;
+private:
+    std::string key;
+    std::string label;
+    std::list<SettingConfig> children; // must be a list cause the pointers to individual children are mapped to in SettingRegistry::settings.
+    std::list<std::string> path; //!< The path of parents (internal names) to this container
+public:
+    std::string getKey() const { return key; }
+    std::string getLabel() const { return label; }
+    SettingContainer(std::string key, std::string label);
+    
+    /*!
+     * Get the SettingConfig::children.
+     * 
+     * This is used to get the extruder trains; see Settingsbase::setExtruderTrainDefaults
+     * 
+     * \return SettingConfig::children
+     */
+    const std::list<SettingConfig>& getChildren() const { return children; }
+    
+    SettingConfig* addChild(std::string key, std::string label);
+    
+    /*!
+     * Get the \p idx th child.
+     * 
+     * This is used to get a specific extruder train in Settingsbase::setExtruderTrainDefaults
+     * 
+     * \param idx The index in the list of children
+     * \return The \p idx th child
+     */
+    const SettingConfig* getChild(unsigned int idx) const
+    {
+        if (idx < children.size())
+        {
+            auto it = children.begin();
+            while (idx > 0) { ++it; idx--; }
+            return &*it;
+        }
+        else 
+            return nullptr;
+    }
+
+private:
+    /*!
+     * Get the (direct) child with key \p key, or create one with key \p key and label \p label as well.
+     * 
+     * \param key the key
+     * \param label the label for creating a new child
+     * \return The existing or newly created child setting.
+     */
+    SettingConfig& getOrCreateChild(std::string key, std::string label);
+public:
+    void debugOutputAllSettings() const;
+};
+}//namespace cura
+#endif//SETTINGS_SETTING_CONTAINER_H

src/settings/SettingRegistry.cpp

@@ -0,0 +1,397 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#include "SettingRegistry.h"
+
+#include <sstream>
+#include <iostream> // debug IO
+#include <libgen.h> // dirname
+#include <string>
+#include <cstring> // strtok (split string using delimiters) strcpy
+#include <fstream> // ifstream (to see if file exists)
+
+#include "rapidjson/rapidjson.h"
+#include "rapidjson/document.h"
+#include "rapidjson/error/en.h"
+#include "rapidjson/filereadstream.h"
+#include "../utils/logoutput.h"
+
+namespace cura
+{
+    
+SettingRegistry SettingRegistry::instance; // define settingRegistry
+
+std::string SettingRegistry::toString(rapidjson::Type type)
+{
+    switch (type)
+    {
+        case rapidjson::Type::kNullType: return "null";
+        case rapidjson::Type::kFalseType: return "false";
+        case rapidjson::Type::kTrueType: return "true";
+        case rapidjson::Type::kObjectType: return "object";
+        case rapidjson::Type::kArrayType: return "array";
+        case rapidjson::Type::kStringType: return "string";
+        case rapidjson::Type::kNumberType: return "number";
+        default: return "Unknown";
+    }
+}
+
+
+SettingConfig::SettingConfig(std::string key, std::string label)
+: SettingContainer(key, label)
+{
+//     std::cerr << key << std::endl; // debug output to show all frontend registered settings...
+}
+
+bool SettingRegistry::settingExists(std::string key) const
+{
+    return setting_key_to_config.find(key) != setting_key_to_config.end();
+}
+
+SettingConfig* SettingRegistry::getSettingConfig(std::string key) const
+{
+    auto it = setting_key_to_config.find(key);
+    if (it == setting_key_to_config.end())
+        return nullptr;
+    return it->second;
+}
+
+SettingRegistry::SettingRegistry()
+: setting_definitions("settings", "Settings")
+{
+    // load search paths from environment variable CURA_ENGINE_SEARCH_PATH
+    char* paths = getenv("CURA_ENGINE_SEARCH_PATH");
+    if (paths)
+    {
+#if defined(__linux__) || (defined(__APPLE__) && defined(__MACH__))
+        char delims[] = ":"; // colon
+#else
+        char delims[] = ";"; // semicolon
+#endif
+        char* path = strtok(paths, delims); // search for next path delimited by any of the characters in delims
+        while (path != NULL)
+        {
+            search_paths.emplace(path);
+            path = strtok(NULL, ";:,"); // continue searching in last call to strtok
+        }
+    }
+}
+
+int SettingRegistry::loadJSON(std::string filename, rapidjson::Document& json_document)
+{
+    FILE* f = fopen(filename.c_str(), "rb");
+    if (!f)
+    {
+        cura::logError("Couldn't open JSON file.\n");
+        return 1;
+    }
+    char read_buffer[4096];
+    rapidjson::FileReadStream reader_stream(f, read_buffer, sizeof(read_buffer));
+    json_document.ParseStream(reader_stream);
+    fclose(f);
+    if (json_document.HasParseError())
+    {
+        cura::logError("Error parsing JSON(offset %u): %s\n", (unsigned)json_document.GetErrorOffset(), GetParseError_En(json_document.GetParseError()));
+        return 2;
+    }
+
+    return 0;
+}
+
+/*!
+ * Check whether a file exists.
+ * from https://techoverflow.net/blog/2013/01/11/cpp-check-if-file-exists/
+ * 
+ * \param filename The path to a filename to check if it exists
+ * \return Whether the file exists.
+ */
+bool fexists(const char *filename)
+{
+    std::ifstream ifile(filename);
+    return (bool)ifile;
+}
+
+bool SettingRegistry::getDefinitionFile(const std::string machine_id, std::string& result)
+{
+    for (const std::string& search_path : search_paths)
+    {
+        result = search_path + std::string("/") + machine_id + std::string(".def.json");
+        if (fexists(result.c_str()))
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+
+int SettingRegistry::loadExtruderJSONsettings(unsigned int extruder_nr, SettingsBase* settings_base)
+{
+    if (extruder_nr >= extruder_train_ids.size())
+    {
+        return -1;
+    }
+    
+    std::string definition_file;
+    bool found = getDefinitionFile(extruder_train_ids[extruder_nr], definition_file);
+    if (!found)
+    {
+        return -1;
+    }
+    bool warn_base_file_duplicates = false;
+    return loadJSONsettings(definition_file, settings_base, warn_base_file_duplicates);
+}
+
+int SettingRegistry::loadJSONsettings(std::string filename, SettingsBase* settings_base, bool warn_base_file_duplicates)
+{
+    rapidjson::Document json_document;
+    
+    log("Loading %s...\n", filename.c_str());
+
+    int err = loadJSON(filename, json_document);
+    if (err) { return err; }
+
+    { // add parent folder to search paths
+        char filename_cstr[filename.size()];
+        std::strcpy(filename_cstr, filename.c_str()); // copy the string because dirname(.) changes the input string!!!
+        std::string folder_name = std::string(dirname(filename_cstr));
+        search_paths.emplace(folder_name);
+    }
+
+    if (json_document.HasMember("inherits") && json_document["inherits"].IsString())
+    {
+        std::string child_filename;
+        bool found = getDefinitionFile(json_document["inherits"].GetString(), child_filename);
+        if (!found)
+        {
+            return -1;
+        }
+        err = loadJSONsettings(child_filename, settings_base, warn_base_file_duplicates); // load child first
+        if (err)
+        {
+            return err;
+        }
+        err = loadJSONsettingsFromDoc(json_document, settings_base, false);
+    }
+    else 
+    {
+        err = loadJSONsettingsFromDoc(json_document, settings_base, warn_base_file_duplicates);
+    }
+
+    if (json_document.HasMember("metadata") && json_document["metadata"].IsObject())
+    {
+        const rapidjson::Value& json_metadata = json_document["metadata"];
+        if (json_metadata.HasMember("machine_extruder_trains") && json_metadata["machine_extruder_trains"].IsObject())
+        {
+            const rapidjson::Value& json_machine_extruder_trains = json_metadata["machine_extruder_trains"];
+            for (rapidjson::Value::ConstMemberIterator extr_train_iterator = json_machine_extruder_trains.MemberBegin(); extr_train_iterator != json_machine_extruder_trains.MemberEnd(); ++extr_train_iterator)
+            {
+                int extruder_train_nr = atoi(extr_train_iterator->name.GetString());
+                if (extruder_train_nr < 0)
+                {
+                    continue;
+                }
+                const rapidjson::Value& json_id = extr_train_iterator->value;
+                if (!json_id.IsString())
+                {
+                    continue;
+                }
+                const char* id = json_id.GetString();
+                if (extruder_train_nr >= (int) extruder_train_ids.size())
+                {
+                    extruder_train_ids.resize(extruder_train_nr + 1);
+                }
+                extruder_train_ids[extruder_train_nr] = std::string(id);
+            }
+        }
+    }
+
+    return err;
+}
+
+int SettingRegistry::loadJSONsettingsFromDoc(rapidjson::Document& json_document, SettingsBase* settings_base, bool warn_duplicates)
+{
+    
+    if (!json_document.IsObject())
+    {
+        cura::logError("JSON file is not an object.\n");
+        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"))
+    {
+        std::list<std::string> path;
+        handleChildren(json_document["settings"], path, settings_base, warn_duplicates);
+    }
+    
+    if (json_document.HasMember("overrides"))
+    {
+        const rapidjson::Value& json_object_container = json_document["overrides"];
+        for (rapidjson::Value::ConstMemberIterator override_iterator = json_object_container.MemberBegin(); override_iterator != json_object_container.MemberEnd(); ++override_iterator)
+        {
+            std::string setting = override_iterator->name.GetString();
+            SettingConfig* conf = getSettingConfig(setting);
+            if (!conf) //Setting could not be found.
+            {
+                logWarning("Trying to override unknown setting %s.\n", setting.c_str());
+                continue;
+            }
+            _loadSettingValues(conf, override_iterator, settings_base);
+        }
+    }
+    
+    return 0;
+}
+
+void SettingRegistry::handleChildren(const rapidjson::Value& settings_list, std::list<std::string>& path, SettingsBase* settings_base, bool warn_duplicates)
+{
+    if (!settings_list.IsObject())
+    {
+        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, path, settings_base, warn_duplicates);
+        if (setting_iterator->value.HasMember("children"))
+        {
+            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);
+        }
+    }
+}
+
+bool SettingRegistry::settingIsUsedByEngine(const rapidjson::Value& setting)
+{
+    if (setting.HasMember("children"))
+    {
+        return false;
+    }
+    else
+    {
+        return true;
+    }
+}
+
+
+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("ERROR: json setting is not an object!\n");
+        return;
+    }
+    std::string name = json_setting_it->name.GetString();
+    if (json_setting.HasMember("type") && json_setting["type"].IsString() && json_setting["type"].GetString() == std::string("category"))
+    { // skip category objects
+        setting_key_to_config[name] = nullptr; // add the category name to the mapping, but don't instantiate a setting config for it.
+        return;
+    }
+    if (settingIsUsedByEngine(json_setting))
+    {
+        if (!json_setting.HasMember("label") || !json_setting["label"].IsString())
+        {
+            logError("ERROR: json setting \"%s\" has no label!\n", name.c_str());
+            return;
+        }
+        std::string label = json_setting["label"].GetString();
+        
+        SettingConfig* setting = getSettingConfig(name);
+        if (warn_duplicates && setting)
+        {
+            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)
+        {
+            setting = &addSetting(name, label);
+        }
+        _loadSettingValues(setting, json_setting_it, settings_base);
+    }
+    else
+    {
+        setting_key_to_config[name] = nullptr; // add the setting name to the mapping, but don't instantiate a setting config for it.
+    }
+}
+
+SettingConfig& SettingRegistry::addSetting(std::string name, std::string label)
+{
+    SettingConfig* config = setting_definitions.addChild(name, label);
+
+    setting_key_to_config[name] = config;
+
+    return *config;
+}
+
+void SettingRegistry::loadDefault(const rapidjson::GenericValue< rapidjson::UTF8< char > >::ConstMemberIterator& json_object_it, SettingConfig* config)
+{
+    const rapidjson::Value& setting_content = json_object_it->value;
+    if (setting_content.HasMember("default_value"))
+    {
+        const rapidjson::Value& dflt = setting_content["default_value"];
+        if (dflt.IsString())
+        {
+            config->setDefault(dflt.GetString());
+        }
+        else if (dflt.IsTrue())
+        {
+            config->setDefault("true");
+        }
+        else if (dflt.IsFalse())
+        {
+            config->setDefault("false");
+        }
+        else if (dflt.IsNumber())
+        {
+            std::ostringstream ss;
+            ss << dflt.GetDouble();
+            config->setDefault(ss.str());
+        } // arrays are ignored because machine_extruder_trains needs to be handled separately
+        else 
+        {
+            logWarning("WARNING: Unrecognized data type in JSON: %s has type %s\n", json_object_it->name.GetString(), toString(dflt.GetType()).c_str());
+        }
+    }
+}
+
+
+void SettingRegistry::_loadSettingValues(SettingConfig* config, const rapidjson::GenericValue< rapidjson::UTF8< char > >::ConstMemberIterator& json_object_it, SettingsBase* settings_base)
+{
+    const rapidjson::Value& data = json_object_it->value;
+    /// Fill the setting config object with data we have in the json file.
+    if (data.HasMember("type") && data["type"].IsString())
+    {
+        config->setType(data["type"].GetString());
+    }
+    if (config->getType() == std::string("polygon") || config->getType() == std::string("polygons"))
+    { // skip polygon settings : not implemented yet and not used yet (TODO)
+//         logWarning("WARNING: Loading polygon setting %s not implemented...\n", json_object_it->name.GetString());
+        return;
+    }
+
+    loadDefault(json_object_it, config);
+
+    if (data.HasMember("unit") && data["unit"].IsString())
+    {
+        config->setUnit(data["unit"].GetString());
+    }
+
+    settings_base->_setSetting(config->getKey(), config->getDefaultValue());
+}
+
+}//namespace cura

src/settings/SettingRegistry.h

@@ -0,0 +1,191 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#ifndef SETTINGS_SETTING_REGISTRY_H
+#define SETTINGS_SETTING_REGISTRY_H
+
+#include <vector>
+#include <unordered_set>
+#include <list>
+#include <unordered_map>
+#include <string>
+#include <iostream> // debug out
+
+#include "SettingConfig.h"
+#include "SettingContainer.h"
+
+#include "../utils/NoCopy.h"
+#include "rapidjson/document.h"
+#include "settings.h"
+
+namespace cura
+{
+
+/*!
+ * Setting registry.
+ * There is a single global setting registry.
+ * This registry contains all known setting keys and (some of) their attributes.
+ * The default values are stored and retrieved in case a given setting doesn't get a value from the command line or the frontend.
+ */
+class SettingRegistry : NoCopy
+{
+private:
+    static SettingRegistry instance;
+
+    SettingRegistry();
+    
+    std::unordered_map<std::string, SettingConfig*> setting_key_to_config; //!< Mapping from setting keys to their configurations
+
+    SettingContainer setting_definitions; //!< All setting configurations (A flat list)
+    
+    std::vector<std::string> extruder_train_ids; //!< The internal id's of each extruder (the filename without the extension)
+
+    std::unordered_set<std::string> search_paths; //!< The paths to search for json files.
+public:
+    /*!
+     * Get the SettingRegistry.
+     * 
+     * This is a singleton class.
+     * 
+     * \return The SettingRegistry
+     */
+    static SettingRegistry* getInstance() { return &instance; }
+    
+    /*!
+     * Check whether a setting exists, according to the settings json files.
+     * 
+     * \param key The internal key for the setting to test
+     * \return Whether a definition of the setting is recorded in this registry.
+     */
+    bool settingExists(std::string key) const;
+
+    /*!
+     * Get the config of a setting with a given key.
+     * 
+     * \param key the (internal) key for a setting
+     * \return the setting definition values
+     */
+    SettingConfig* getSettingConfig(std::string key) const;
+protected:
+    /*!
+     * Whether this json settings object is a definition of a CuraEngine setting,
+     * or only a shorthand setting to control other settings.
+     * Only settings used by the engine will be recordedd in the registry.
+     * 
+     * \param setting The setting to check whether CuraEngine uses it.
+     * \return Whether CuraEngine uses the setting.
+     */
+    bool settingIsUsedByEngine(const rapidjson::Value& setting);
+
+    /*!
+     * Get the filename for the machine definition with the given id.
+     * Check the directories in SettingRegistry::search_paths.
+     * 
+     * \param machine_id The id and base filename (without extensions) of the machine definition to search for.
+     * \param result The filename of the machine definition
+     * \return Whether we found the file.
+     */
+    bool getDefinitionFile(const std::string machine_id, std::string& result);
+    
+    /*!
+     * Get the default value of a json setting object in the format used internally (c style).
+     * 
+     * \param[in] json_object_it An iterator for a given setting json object
+     * \param[out] config Where the default value is stored
+     */
+    static void loadDefault(const rapidjson::GenericValue< rapidjson::UTF8< char > >::ConstMemberIterator& json_object_it, SettingConfig* config);
+public:
+    /*!
+     * Load settings from a json file and all the parents it inherits from.
+     * 
+     * Uses recursion to load the parent json file.
+     * 
+     * \param filename The filename of the json file to parse
+     * \param settings_base The settings base where to store the default values.
+     * \param warn_base_file_duplicates Whether to warn if there are duplicate definitions in the base file (the .def.json which has no inherits).
+     * \return an error code or zero of succeeded
+     */
+    int loadJSONsettings(std::string filename, SettingsBase* settings_base, bool warn_base_file_duplicates = true);
+    
+    void debugOutputAllSettings() const
+    {
+        setting_definitions.debugOutputAllSettings();
+    }
+
+    /*!
+     * Load settings from the extruder definition json file and all the parents it inherits from.
+     * Use the json file refered to in the machine_extruder_trains attribute of the last loaded machine json file.
+     * 
+     * Uses recursion to load the parent json file.
+     * 
+     * \param extruder_nr The number of the extruder to load
+     * \param settings_base The settings base where to store the default values. (The extruder settings base)
+     * \return an error code or zero of succeeded
+     */
+    int loadExtruderJSONsettings(unsigned int extruder_nr, SettingsBase* settings_base);
+private:
+    
+    /*!
+     * \param type type to convert to string
+     * \return human readable version of json type
+     */
+    static std::string toString(rapidjson::Type type);
+public:
+    /*!
+     * Load a json document.
+     * 
+     * \param filename The filename of the json file to parse
+     * \param json_document (output) the document to be loaded
+     * \return an error code or zero of succeeded
+     */
+    static int loadJSON(std::string filename, rapidjson::Document& json_document);
+private:
+    /*!
+     * Load settings from a single json file.
+     * 
+     * \param filename The filename of the json file to parse
+     * \param settings_base The settings base where to store the default values.
+     * \param warn_duplicates whether to warn for duplicate definitions
+     * \return an error code or zero of succeeded
+     */
+    int loadJSONsettingsFromDoc(rapidjson::Document& json_document, SettingsBase* settings_base, bool warn_duplicates);
+
+    /*!
+     * Create a new SettingConfig and add it to the registry.
+     * 
+     * \param name The internal key of the setting
+     * \param label The human readable name for the frontend
+     * \return The config created
+     */
+    SettingConfig& addSetting(std::string name, std::string label);
+
+    /*!
+     * Load inessential data about the setting, like its type and unit.
+     * 
+     * \param[out] config Where to store the data
+     * \param[in] json_object_it Iterator to a setting json object
+     * \param[out] settings_base The settings base where to store the default values.
+     */
+    void _loadSettingValues(SettingConfig* config, const rapidjson::Value::ConstMemberIterator& json_object_it, SettingsBase* settings_base);
+
+    /*!
+     * Handle a json object which contains a list of settings.
+     * 
+     * \param settings_list The object containing one or more setting definitions
+     * \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 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, std::list<std::string>& path, SettingsBase* settings_base, bool warn_duplicates);
+};
+
+}//namespace cura
+#endif//SETTINGS_SETTING_REGISTRY_H

src/settings/SettingsToGV.h

@@ -0,0 +1,238 @@
+/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
+#ifndef SETTINGS_TO_GV_H
+#define SETTINGS_TO_GV_H
+
+
+#include <stdio.h> // for file output
+#include <sstream>
+#include <iostream> // debug IO
+#include <libgen.h> // dirname
+#include <string>
+#include <algorithm> // find_if
+#include <regex> // regex_search
+#include <cassert>
+#include <fstream>
+#include <set>
+
+#include "rapidjson/rapidjson.h"
+#include "rapidjson/document.h"
+#include "rapidjson/error/en.h"
+#include "rapidjson/filereadstream.h"
+#include "../utils/logoutput.h"
+#include "SettingRegistry.h"
+
+namespace cura
+{
+
+class SettingsToGv
+{
+    enum class RelationType
+    {
+        PARENT_CHILD,
+        INHERIT_FUNCTION,
+        ERROR_FUNCTION,
+        WARNING_FUNCTION
+    };
+    
+    FILE* out;
+    std::set<std::string> engine_settings;
+    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)
+    : parent_child_viz(parent_child_viz)
+    , inherit_viz(inherit_viz)
+    , error_viz(error_viz)
+    , warning_viz(warning_viz)
+    {
+        out = fopen(output_filename.c_str(), "w");
+        fprintf(out, "digraph G {\n");
+        
+        
+        std::ifstream engine_settings_file(engine_settings_filename.c_str());
+        std::string line;
+        while (std::getline(engine_settings_file, line))
+        {
+            engine_settings.insert(line);
+            //fprintf(out, "%s [color=green];\n", line.c_str());
+        }
+        engine_settings_file.close();
+    }
+private:
+    void generateEdge(const std::string& parent, const std::string& child, RelationType relation_type)
+    {
+        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());
+        }
+        std::string color;
+        switch (relation_type)
+        {
+            case SettingsToGv::RelationType::INHERIT_FUNCTION:
+                if (!inherit_viz)
+                {
+                    return;
+                }
+                color = "blue";
+                break;
+            case SettingsToGv::RelationType::PARENT_CHILD:
+                if (!parent_child_viz)
+                {
+                    return;
+                }
+                color = "black";
+                break;
+            case SettingsToGv::RelationType::ERROR_FUNCTION:
+                if (!error_viz)
+                {
+                    return;
+                }
+                color = "red";
+                break;
+            case SettingsToGv::RelationType::WARNING_FUNCTION:
+                if (!warning_viz)
+                {
+                    return;
+                }
+                color = "orange";
+                break;
+        }
+        fprintf(out, "edge [color=%s];\n", color.c_str());
+        fprintf(out, "%s -> %s;\n", parent.c_str(), child.c_str());
+    }
+    
+    bool createFunctionEdges(const rapidjson::Value& data, std::string function_key, const std::string& parent, const std::string& name, const RelationType relation_type)
+    {
+        bool generated_edge = false;
+        if (data.HasMember(function_key.c_str()) && data[function_key.c_str()].IsString())
+        {
+            std::string function = data[function_key.c_str()].GetString();
+            
+            std::regex setting_name_regex("[a-zA-Z0-9_]+"); // matches mostly with setting names
+            std::smatch regex_match;
+            while (std::regex_search (function, regex_match, setting_name_regex))
+            {
+                std::string inherited_setting_string = regex_match[0];
+                if (inherited_setting_string == "parent_value")
+                {
+                    generateEdge(parent, name, RelationType::PARENT_CHILD);
+                    generated_edge = true;
+                }
+                else if ( ! std::regex_match(inherited_setting_string, std::regex("[0-9]+")) && // exclude numbers
+                    // result != "parent_value" && 
+                    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 != "grid" && inherited_setting_string != "triangles" // exclude enum values
+                    && function.c_str()[regex_match.position() + regex_match.length()] != '\'') // exclude enum terms
+                {
+                    if (inherited_setting_string == parent)
+                    {
+                        generated_edge = true;
+                        generateEdge(inherited_setting_string, name, RelationType::PARENT_CHILD);
+                    }
+                    else 
+                    {
+                        generateEdge(inherited_setting_string, name, relation_type);
+                    }
+                }
+                function = regex_match.suffix().str();
+            }
+        }
+        return generated_edge;
+    }
+    
+    void parseSetting(const std::string& parent, rapidjson::Value::ConstMemberIterator json_object_it)
+    {
+        std::string name = json_object_it->name.GetString();
+        
+//         std::cerr << "parsed: " << name <<"\n";
+        
+        bool generated_edge = false;
+        
+        const rapidjson::Value& data = json_object_it->value;
+        
+        if (data.HasMember("type") && data["type"].IsString() && data["type"].GetString() != std::string("category"))
+        {
+            
+            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;
+            }
+            
+            if (!generated_edge && parent != "")
+            {
+                generateEdge(parent, name, RelationType::PARENT_CHILD);
+            }
+        }
+        else
+        {
+            name = "";
+        }
+        
+        // recursive part
+        if (data.HasMember("children") && data["children"].IsObject())
+        {
+            const rapidjson::Value& json_object_container = data["children"];
+            for (rapidjson::Value::ConstMemberIterator setting_iterator = json_object_container.MemberBegin(); setting_iterator != json_object_container.MemberEnd(); ++setting_iterator)
+            {
+                parseSetting(name, setting_iterator);
+            }
+        }
+    }
+    
+    void parseJson(const rapidjson::Document& json_document)
+    {
+        if (json_document.HasMember("settings"))
+        {
+            for (rapidjson::Value::ConstMemberIterator setting_iterator = json_document["settings"].MemberBegin(); setting_iterator != json_document["settings"].MemberEnd(); ++setting_iterator)
+            {
+                parseSetting("", setting_iterator);
+            }
+        }
+    }
+
+    int generateRecursive(std::string filename)
+    {
+        rapidjson::Document json_document;
+        
+        int err = SettingRegistry::loadJSON(filename, json_document);
+        if (err) { return err; }
+        
+        if (json_document.HasMember("inherits"))
+        {
+            std::string filename_copy = std::string(filename.c_str()); // copy the string because dirname(.) changes the input string!!!
+            char* filename_cstr = (char*)filename_copy.c_str();
+            int err = generate(std::string(dirname(filename_cstr)) + std::string("/") + json_document["inherits"].GetString());
+            if (err)
+            {
+                return err;
+            }
+        }
+        parseJson(json_document);
+        return 0;
+    }
+public:
+    int generate(std::string json_filename)
+    {
+        int err = generateRecursive(json_filename);
+        fprintf(out, "}\n");
+        fclose(out);
+        return err;
+    }
+
+
+
+};
+
+} // namespace cura
+
+#endif // SETTINGS_TO_GV_H