QIDISlicer1.0.0

src/libslic3r/GCode/AvoidCrossingPerimeters.hpp

@@ -0,0 +1,74 @@
+#ifndef slic3r_AvoidCrossingPerimeters_hpp_
+#define slic3r_AvoidCrossingPerimeters_hpp_
+
+#include "../libslic3r.h"
+#include "../ExPolygon.hpp"
+#include "../EdgeGrid.hpp"
+
+namespace Slic3r {
+
+// Forward declarations.
+class GCode;
+class Layer;
+class Point;
+
+class AvoidCrossingPerimeters
+{
+public:
+    // Routing around the objects vs. inside a single object.
+    void        use_external_mp(bool use = true) { m_use_external_mp = use; };
+    void        use_external_mp_once()  { m_use_external_mp_once = true; }
+    bool        used_external_mp_once() { return m_use_external_mp_once; }
+    void        disable_once()          { m_disabled_once = true; }
+    bool        disabled_once() const   { return m_disabled_once; }
+    void        reset_once_modifiers()  { m_use_external_mp_once = false; m_disabled_once = false; }
+
+    void        init_layer(const Layer &layer);
+
+    Polyline    travel_to(const GCode& gcodegen, const Point& point)
+    {
+        bool could_be_wipe_disabled;
+        return this->travel_to(gcodegen, point, &could_be_wipe_disabled);
+    }
+
+    Polyline    travel_to(const GCode& gcodegen, const Point& point, bool* could_be_wipe_disabled);
+
+    struct Boundary {
+        // Collection of boundaries used for detection of crossing perimeters for travels
+        Polygons                        boundaries;
+        // Bounding box of boundaries
+        BoundingBoxf                    bbox;
+        // Precomputed distances of all points in boundaries
+        std::vector<std::vector<float>> boundaries_params;
+        // Used for detection of intersection between line and any polygon from boundaries
+        EdgeGrid::Grid                  grid;
+
+        void clear()
+        {
+            boundaries.clear();
+            boundaries_params.clear();
+        }
+    };
+
+private:
+    bool           m_use_external_mp { false };
+    // just for the next travel move
+    bool           m_use_external_mp_once { false };
+    // this flag disables avoid_crossing_perimeters just for the next travel move
+    // we enable it by default for the first travel move in print
+    bool           m_disabled_once { true };
+
+    // Lslices offseted by half an external perimeter width. Used for detection if line or polyline is inside of any polygon.
+    ExPolygons               m_lslices_offset;
+    std::vector<BoundingBox> m_lslices_offset_bboxes;
+    // Used for detection of line or polyline is inside of any polygon.
+    EdgeGrid::Grid           m_grid_lslices_offset;
+    // Store all needed data for travels inside object
+    Boundary m_internal;
+    // Store all needed data for travels outside object
+    Boundary m_external;
+};
+
+} // namespace Slic3r
+
+#endif // slic3r_AvoidCrossingPerimeters_hpp_

src/libslic3r/GCode/CoolingBuffer.cpp

@@ -0,0 +1,938 @@
+#include "../GCode.hpp"
+#include "CoolingBuffer.hpp"
+#include <algorithm>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/replace.hpp>
+#include <boost/log/trivial.hpp>
+#include <iostream>
+#include <float.h>
+
+#if 0
+    #define DEBUG
+    #define _DEBUG
+    #undef NDEBUG
+#endif
+
+#include <assert.h>
+
+#include <fast_float/fast_float.h>
+
+namespace Slic3r {
+
+CoolingBuffer::CoolingBuffer(GCode &gcodegen) : m_config(gcodegen.config()), m_toolchange_prefix(gcodegen.writer().toolchange_prefix()), m_current_extruder(0)
+{
+    this->reset(gcodegen.writer().get_position());
+
+    const std::vector<Extruder> &extruders = gcodegen.writer().extruders();
+    m_extruder_ids.reserve(extruders.size());
+    for (const Extruder &ex : extruders) {
+        m_num_extruders = std::max(ex.id() + 1, m_num_extruders);
+        m_extruder_ids.emplace_back(ex.id());
+    }
+}
+
+void CoolingBuffer::reset(const Vec3d &position)
+{
+    m_current_pos.assign(5, 0.f);
+    m_current_pos[0] = float(position.x());
+    m_current_pos[1] = float(position.y());
+    m_current_pos[2] = float(position.z());
+    m_current_pos[4] = float(m_config.travel_speed.value);
+    m_fan_speed = -1;
+}
+
+struct CoolingLine
+{
+    enum Type {
+        TYPE_SET_TOOL           = 1 << 0,
+        TYPE_EXTRUDE_END        = 1 << 1,
+        TYPE_BRIDGE_FAN_START   = 1 << 2,
+        TYPE_BRIDGE_FAN_END     = 1 << 3,
+        TYPE_G0                 = 1 << 4,
+        TYPE_G1                 = 1 << 5,
+        TYPE_ADJUSTABLE         = 1 << 6,
+        TYPE_EXTERNAL_PERIMETER = 1 << 7,
+        // The line sets a feedrate.
+        TYPE_HAS_F              = 1 << 8,
+        TYPE_WIPE               = 1 << 9,
+        TYPE_G4                 = 1 << 10,
+        TYPE_G92                = 1 << 11,
+        // Would be TYPE_ADJUSTABLE, but the block of G-code lines has zero extrusion length, thus the block
+        // cannot have its speed adjusted. This should not happen (sic!).
+        TYPE_ADJUSTABLE_EMPTY   = 1 << 12,
+        // Custom fan speed (introduced for overhang fan speed)
+        TYPE_SET_FAN_SPEED      = 1 << 13,
+        TYPE_RESET_FAN_SPEED    = 1 << 14,
+    };
+
+    CoolingLine(unsigned int type, size_t  line_start, size_t  line_end) :
+        type(type), line_start(line_start), line_end(line_end),
+        length(0.f), feedrate(0.f), time(0.f), time_max(0.f), slowdown(false) {}
+
+    bool adjustable(bool slowdown_external_perimeters) const {
+        return (this->type & TYPE_ADJUSTABLE) && 
+               (! (this->type & TYPE_EXTERNAL_PERIMETER) || slowdown_external_perimeters) &&
+               this->time < this->time_max;
+    }
+
+    bool adjustable() const {
+        return (this->type & TYPE_ADJUSTABLE) && this->time < this->time_max;
+    }
+
+    size_t  type;
+    // Start of this line at the G-code snippet.
+    size_t  line_start;
+    // End of this line at the G-code snippet.
+    size_t  line_end;
+    // XY Euclidian length of this segment.
+    float   length;
+    // Current feedrate, possibly adjusted.
+    float   feedrate;
+    // Current duration of this segment.
+    float   time;
+    // Maximum duration of this segment.
+    float   time_max;
+    // Requested fan speed
+    int     fan_speed;
+    // If marked with the "slowdown" flag, the line has been slowed down.
+    bool    slowdown;
+};
+
+// Calculate the required per extruder time stretches.
+struct PerExtruderAdjustments 
+{
+    // Calculate the total elapsed time per this extruder, adjusted for the slowdown.
+    float elapsed_time_total() const {
+        float time_total = 0.f;
+        for (const CoolingLine &line : lines)
+            time_total += line.time;
+        return time_total;
+    }
+    // Calculate the total elapsed time when slowing down 
+    // to the minimum extrusion feed rate defined for the current material.
+    float maximum_time_after_slowdown(bool slowdown_external_perimeters) const {
+        float time_total = 0.f;
+        for (const CoolingLine &line : lines)
+            if (line.adjustable(slowdown_external_perimeters)) {
+                if (line.time_max == FLT_MAX)
+                    return FLT_MAX;
+                else
+                    time_total += line.time_max;
+            } else
+                time_total += line.time;
+        return time_total;
+    }
+    // Calculate the adjustable part of the total time.
+    float adjustable_time(bool slowdown_external_perimeters) const {
+        float time_total = 0.f;
+        for (const CoolingLine &line : lines)
+            if (line.adjustable(slowdown_external_perimeters))
+                time_total += line.time;
+        return time_total;
+    }
+    // Calculate the non-adjustable part of the total time.
+    float non_adjustable_time(bool slowdown_external_perimeters) const {
+        float time_total = 0.f;
+        for (const CoolingLine &line : lines)
+            if (! line.adjustable(slowdown_external_perimeters))
+                time_total += line.time;
+        return time_total;
+    }
+    // Slow down the adjustable extrusions to the minimum feedrate allowed for the current extruder material.
+    // Used by both proportional and non-proportional slow down.
+    float slowdown_to_minimum_feedrate(bool slowdown_external_perimeters) {
+        float time_total = 0.f;
+        for (CoolingLine &line : lines) {
+            if (line.adjustable(slowdown_external_perimeters)) {
+                assert(line.time_max >= 0.f && line.time_max < FLT_MAX);
+                line.slowdown = true;
+                line.time     = line.time_max;
+                assert(line.time > 0);
+                line.feedrate = line.length / line.time;
+            }
+            time_total += line.time;
+        }
+        return time_total;
+    }
+    // Slow down each adjustable G-code line proportionally by a factor.
+    // Used by the proportional slow down.
+    float slow_down_proportional(float factor, bool slowdown_external_perimeters) {
+        assert(factor >= 1.f);
+        float time_total = 0.f;
+        for (CoolingLine &line : lines) {
+            if (line.adjustable(slowdown_external_perimeters)) {
+                line.slowdown = true;
+                line.time     = std::min(line.time_max, line.time * factor);
+                assert(line.time > 0);
+                line.feedrate = line.length / line.time;
+            }
+            time_total += line.time;
+        }
+        return time_total;
+    }
+
+    // Sort the lines, adjustable first, higher feedrate first.
+    // Used by non-proportional slow down.
+    void sort_lines_by_decreasing_feedrate() {
+        std::sort(lines.begin(), lines.end(), [](const CoolingLine &l1, const CoolingLine &l2) {
+            bool adj1 = l1.adjustable();
+            bool adj2 = l2.adjustable();
+            return (adj1 == adj2) ? l1.feedrate > l2.feedrate : adj1;
+        });
+        for (n_lines_adjustable = 0; 
+            n_lines_adjustable < lines.size() && this->lines[n_lines_adjustable].adjustable();
+            ++ n_lines_adjustable);
+        time_non_adjustable = 0.f;
+        for (size_t i = n_lines_adjustable; i < lines.size(); ++ i)
+            time_non_adjustable += lines[i].time;
+    }
+
+    // Calculate the maximum time stretch when slowing down to min_feedrate.
+    // Slowdown to min_feedrate shall be allowed for this extruder's material.
+    // Used by non-proportional slow down.
+    float time_stretch_when_slowing_down_to_feedrate(float min_feedrate) const {
+        float time_stretch = 0.f;
+        assert(this->min_print_speed < min_feedrate + EPSILON);
+        for (size_t i = 0; i < n_lines_adjustable; ++ i) {
+            const CoolingLine &line = lines[i];
+            if (line.feedrate > min_feedrate) {
+                assert(min_feedrate > 0);
+                time_stretch += line.time * (line.feedrate / min_feedrate - 1.f);
+            }
+        }
+        return time_stretch;
+    }
+
+    // Slow down all adjustable lines down to min_feedrate.
+    // Slowdown to min_feedrate shall be allowed for this extruder's material.
+    // Used by non-proportional slow down.
+    void slow_down_to_feedrate(float min_feedrate) {
+        assert(this->min_print_speed < min_feedrate + EPSILON);
+        for (size_t i = 0; i < n_lines_adjustable; ++ i) {
+            CoolingLine &line = lines[i];
+            if (line.feedrate > min_feedrate) {
+                assert(min_feedrate > 0);
+                line.time *= std::max(1.f, line.feedrate / min_feedrate);
+                line.feedrate = min_feedrate;
+                line.slowdown = true;
+            }
+        }
+    }
+
+    // Extruder, for which the G-code will be adjusted.
+    unsigned int                extruder_id         = 0;
+    // Is the cooling slow down logic enabled for this extruder's material?
+    bool                        cooling_slow_down_enabled = false;
+    // Slow down the print down to min_print_speed if the total layer time is below slowdown_below_layer_time.
+    float                       slowdown_below_layer_time = 0.f;
+    // Minimum print speed allowed for this extruder.
+    float                       min_print_speed     = 0.f;
+
+    // Parsed lines.
+    std::vector<CoolingLine>    lines;
+    // The following two values are set by sort_lines_by_decreasing_feedrate():
+    // Number of adjustable lines, at the start of lines.
+    size_t                      n_lines_adjustable  = 0;
+    // Non-adjustable time of lines starting with n_lines_adjustable. 
+    float                       time_non_adjustable = 0;
+    // Current total time for this extruder.
+    float                       time_total          = 0;
+    // Maximum time for this extruder, when the maximum slow down is applied.
+    float                       time_maximum        = 0;
+
+    // Temporaries for processing the slow down. Both thresholds go from 0 to n_lines_adjustable.
+    size_t                      idx_line_begin      = 0;
+    size_t                      idx_line_end        = 0;
+};
+
+// Calculate a new feedrate when slowing down by time_stretch for segments faster than min_feedrate.
+// Used by non-proportional slow down.
+float new_feedrate_to_reach_time_stretch(
+    std::vector<PerExtruderAdjustments*>::const_iterator it_begin, std::vector<PerExtruderAdjustments*>::const_iterator it_end, 
+    float min_feedrate, float time_stretch, size_t max_iter = 20)
+{
+	float new_feedrate = min_feedrate;
+    for (size_t iter = 0; iter < max_iter; ++ iter) {
+        float nomin = 0;
+        float denom = time_stretch;
+        for (auto it = it_begin; it != it_end; ++ it) {
+			assert((*it)->min_print_speed < min_feedrate + EPSILON);
+			for (size_t i = 0; i < (*it)->n_lines_adjustable; ++i) {
+				const CoolingLine &line = (*it)->lines[i];
+                if (line.feedrate > min_feedrate) {
+                    nomin += line.time * line.feedrate;
+                    denom += line.time;
+                }
+            }
+        }
+        assert(denom > 0);
+        if (denom <= 0)
+            return min_feedrate;
+        new_feedrate = nomin / denom;
+        assert(new_feedrate > min_feedrate - EPSILON);
+        if (new_feedrate < min_feedrate + EPSILON)
+            goto finished;
+        for (auto it = it_begin; it != it_end; ++ it)
+			for (size_t i = 0; i < (*it)->n_lines_adjustable; ++i) {
+				const CoolingLine &line = (*it)->lines[i];
+                if (line.feedrate > min_feedrate && line.feedrate < new_feedrate)
+                    // Some of the line segments taken into account in the calculation of nomin / denom are now slower than new_feedrate, 
+                    // which makes the new_feedrate lower than it should be.
+                    // Re-run the calculation with a new min_feedrate limit, so that the segments with current feedrate lower than new_feedrate
+                    // are not taken into account.
+                    goto not_finished_yet;
+            }
+        goto finished;
+not_finished_yet:
+        min_feedrate = new_feedrate;
+    }
+    // Failed to find the new feedrate for the time_stretch.
+
+finished:
+    // Test whether the time_stretch was achieved.
+#ifndef NDEBUG
+    {
+        float time_stretch_final = 0.f;
+        for (auto it = it_begin; it != it_end; ++ it)
+            time_stretch_final += (*it)->time_stretch_when_slowing_down_to_feedrate(new_feedrate);
+        assert(std::abs(time_stretch - time_stretch_final) < EPSILON);
+    }
+#endif /* NDEBUG */
+
+	return new_feedrate;
+}
+
+std::string CoolingBuffer::process_layer(std::string &&gcode, size_t layer_id, bool flush)
+{
+    // Cache the input G-code.
+    if (m_gcode.empty())
+        m_gcode = std::move(gcode);
+    else
+        m_gcode += gcode;
+
+    std::string out;
+    if (flush) {
+        // This is either an object layer or the very last print layer. Calculate cool down over the collected support layers
+        // and one object layer.
+        std::vector<PerExtruderAdjustments> per_extruder_adjustments = this->parse_layer_gcode(m_gcode, m_current_pos);
+        float layer_time_stretched = this->calculate_layer_slowdown(per_extruder_adjustments);
+        out = this->apply_layer_cooldown(m_gcode, layer_id, layer_time_stretched, per_extruder_adjustments);
+        m_gcode.clear();
+    }
+    return out;
+}
+
+// Parse the layer G-code for the moves, which could be adjusted.
+// Return the list of parsed lines, bucketed by an extruder.
+std::vector<PerExtruderAdjustments> CoolingBuffer::parse_layer_gcode(const std::string &gcode, std::vector<float> &current_pos) const
+{
+    std::vector<PerExtruderAdjustments> per_extruder_adjustments(m_extruder_ids.size());
+    std::vector<size_t>                 map_extruder_to_per_extruder_adjustment(m_num_extruders, 0);
+    for (size_t i = 0; i < m_extruder_ids.size(); ++ i) {
+        PerExtruderAdjustments &adj         = per_extruder_adjustments[i];
+        unsigned int            extruder_id = m_extruder_ids[i];
+        adj.extruder_id               = extruder_id;
+        adj.cooling_slow_down_enabled = m_config.cooling.get_at(extruder_id);
+        adj.slowdown_below_layer_time = float(m_config.slowdown_below_layer_time.get_at(extruder_id));
+        adj.min_print_speed           = float(m_config.min_print_speed.get_at(extruder_id));
+        map_extruder_to_per_extruder_adjustment[extruder_id] = i;
+    }
+
+    unsigned int      current_extruder  = m_current_extruder;
+    PerExtruderAdjustments *adjustment  = &per_extruder_adjustments[map_extruder_to_per_extruder_adjustment[current_extruder]];
+    const char       *line_start = gcode.c_str();
+    const char       *line_end   = line_start;
+    const char        extrusion_axis = get_extrusion_axis(m_config)[0];
+    // Index of an existing CoolingLine of the current adjustment, which holds the feedrate setting command
+    // for a sequence of extrusion moves.
+    size_t            active_speed_modifier = size_t(-1);
+
+    std::vector<float> new_pos;
+    for (; *line_start != 0; line_start = line_end) 
+    {
+        while (*line_end != '\n' && *line_end != 0)
+            ++ line_end;
+        // sline will not contain the trailing '\n'.
+        std::string_view sline(line_start, line_end - line_start);
+        // CoolingLine will contain the trailing '\n'.
+        if (*line_end == '\n')
+            ++ line_end;
+        CoolingLine line(0, line_start - gcode.c_str(), line_end - gcode.c_str());
+        if (boost::starts_with(sline, "G0 "))
+            line.type = CoolingLine::TYPE_G0;
+        else if (boost::starts_with(sline, "G1 "))
+            line.type = CoolingLine::TYPE_G1;
+        else if (boost::starts_with(sline, "G92 "))
+            line.type = CoolingLine::TYPE_G92;
+        if (line.type) {
+            // G0, G1 or G92
+            // Parse the G-code line.
+            new_pos = current_pos;
+            for (auto c = sline.begin() + 3;;) {
+                // Skip whitespaces.
+                for (; c != sline.end() && (*c == ' ' || *c == '\t'); ++ c);
+                if (c == sline.end() || *c == ';')
+                    break;
+
+                // Parse the axis.
+                size_t axis = (*c >= 'X' && *c <= 'Z') ? (*c - 'X') :
+                              (*c == extrusion_axis) ? 3 : (*c == 'F') ? 4 : size_t(-1);
+                if (axis != size_t(-1)) {
+                    //auto [pend, ec] = 
+                        fast_float::from_chars(&*(++ c), sline.data() + sline.size(), new_pos[axis]);
+                    if (axis == 4) {
+                        // Convert mm/min to mm/sec.
+                        new_pos[4] /= 60.f;
+                        if ((line.type & CoolingLine::TYPE_G92) == 0)
+                            // This is G0 or G1 line and it sets the feedrate. This mark is used for reducing the duplicate F calls.
+                            line.type |= CoolingLine::TYPE_HAS_F;
+                    }
+                }
+                // Skip this word.
+                for (; c != sline.end() && *c != ' ' && *c != '\t'; ++ c);
+            }
+            bool external_perimeter = boost::contains(sline, ";_EXTERNAL_PERIMETER");
+            bool wipe               = boost::contains(sline, ";_WIPE");
+            if (external_perimeter)
+                line.type |= CoolingLine::TYPE_EXTERNAL_PERIMETER;
+            if (wipe)
+                line.type |= CoolingLine::TYPE_WIPE;
+            if (boost::contains(sline, ";_EXTRUDE_SET_SPEED") && ! wipe) {
+                line.type |= CoolingLine::TYPE_ADJUSTABLE;
+                active_speed_modifier = adjustment->lines.size();
+            }
+            if ((line.type & CoolingLine::TYPE_G92) == 0) {
+                // G0 or G1. Calculate the duration.
+                if (m_config.use_relative_e_distances.value)
+                    // Reset extruder accumulator.
+                    current_pos[3] = 0.f;
+                float dif[4];
+                for (size_t i = 0; i < 4; ++ i)
+                    dif[i] = new_pos[i] - current_pos[i];
+                float dxy2 = dif[0] * dif[0] + dif[1] * dif[1];
+                float dxyz2 = dxy2 + dif[2] * dif[2];
+                if (dxyz2 > 0.f) {
+                    // Movement in xyz, calculate time from the xyz Euclidian distance.
+                    line.length = sqrt(dxyz2);
+                } else if (std::abs(dif[3]) > 0.f) {
+                    // Movement in the extruder axis.
+                    line.length = std::abs(dif[3]);
+                }
+                line.feedrate = new_pos[4];
+                assert((line.type & CoolingLine::TYPE_ADJUSTABLE) == 0 || line.feedrate > 0.f);
+                if (line.length > 0) {
+                    assert(line.feedrate > 0);
+                    line.time = line.length / line.feedrate;
+                    assert(line.time > 0);
+                }
+                line.time_max = line.time;
+                if ((line.type & CoolingLine::TYPE_ADJUSTABLE) || active_speed_modifier != size_t(-1)) {
+                    assert(adjustment->min_print_speed >= 0);
+                    line.time_max = (adjustment->min_print_speed == 0.f) ? FLT_MAX : std::max(line.time, line.length / adjustment->min_print_speed);
+                }
+                if (active_speed_modifier < adjustment->lines.size() && (line.type & CoolingLine::TYPE_G1)) {
+                    // Inside the ";_EXTRUDE_SET_SPEED" blocks, there must not be a G1 Fxx entry.
+                    assert((line.type & CoolingLine::TYPE_HAS_F) == 0);
+                    CoolingLine &sm = adjustment->lines[active_speed_modifier];
+                    assert(sm.feedrate > 0.f);
+                    sm.length   += line.length;
+                    sm.time     += line.time;
+                    if (sm.time_max != FLT_MAX) {
+                        if (line.time_max == FLT_MAX)
+                            sm.time_max = FLT_MAX;
+                        else
+                            sm.time_max += line.time_max;
+                    }
+                    // Don't store this line.
+                    line.type = 0;
+                }
+            }
+            current_pos = std::move(new_pos);
+        } else if (boost::starts_with(sline, ";_EXTRUDE_END")) {
+            // Closing a block of non-zero length extrusion moves.
+            line.type = CoolingLine::TYPE_EXTRUDE_END;
+            if (active_speed_modifier != size_t(-1)) {
+                assert(active_speed_modifier < adjustment->lines.size());
+                CoolingLine &sm = adjustment->lines[active_speed_modifier];
+                // There should be at least some extrusion move inside the adjustment block.
+                // However if the block has no extrusion (which is wrong), fix it for the cooling buffer to work.
+                assert(sm.length > 0);
+                assert(sm.time > 0);
+                if (sm.time <= 0) {
+                    // Likely a zero length extrusion, it should not be emitted, however the zero extrusions should not confuse firmware either.
+                    // Prohibit time adjustment of a block of zero length extrusions by the cooling buffer.
+                    sm.type &= ~CoolingLine::TYPE_ADJUSTABLE;
+                    // But the start / end comment shall be removed.
+                    sm.type |= CoolingLine::TYPE_ADJUSTABLE_EMPTY;
+                }
+            }
+            active_speed_modifier = size_t(-1);
+        } else if (boost::starts_with(sline, m_toolchange_prefix)) {
+            unsigned int new_extruder = 0;
+            auto res = std::from_chars(sline.data() + m_toolchange_prefix.size(), sline.data() + sline.size(), new_extruder);
+            if (res.ec != std::errc::invalid_argument) {
+                // Only change extruder in case the number is meaningful. User could provide an out-of-range index through custom gcodes - those shall be ignored.
+                if (new_extruder < map_extruder_to_per_extruder_adjustment.size()) {
+                    if (new_extruder != current_extruder) {
+                        // Switch the tool.
+                        line.type = CoolingLine::TYPE_SET_TOOL;
+                        current_extruder = new_extruder;
+                        adjustment         = &per_extruder_adjustments[map_extruder_to_per_extruder_adjustment[current_extruder]];
+                    }
+                }
+                else {
+                    // Only log the error in case of MM printer. Single extruder printers likely ignore any T anyway.
+                    if (map_extruder_to_per_extruder_adjustment.size() > 1)
+                        BOOST_LOG_TRIVIAL(error) << "CoolingBuffer encountered an invalid toolchange, maybe from a custom gcode: " << sline;
+                }
+            }
+        } else if (boost::starts_with(sline, ";_BRIDGE_FAN_START")) {
+            line.type = CoolingLine::TYPE_BRIDGE_FAN_START;
+        } else if (boost::starts_with(sline, ";_BRIDGE_FAN_END")) {
+            line.type = CoolingLine::TYPE_BRIDGE_FAN_END;
+        } else if (boost::starts_with(sline, "G4 ")) {
+            // Parse the wait time.
+            line.type = CoolingLine::TYPE_G4;
+            size_t pos_S = sline.find('S', 3);
+            size_t pos_P = sline.find('P', 3);
+            bool   has_S = pos_S > 0;
+            bool   has_P = pos_P > 0;
+            if (has_S || has_P) {
+                //auto [pend, ec] = 
+                    fast_float::from_chars(sline.data() + (has_S ? pos_S : pos_P) + 1, sline.data() + sline.size(), line.time);
+                if (has_P)
+                    line.time *= 0.001f;
+            } else
+                line.time = 0;
+            line.time_max = line.time;
+        } else if (boost::contains(sline, ";_SET_FAN_SPEED")) {
+            auto speed_start = sline.find_last_of('D');
+            int  speed       = 0;
+            for (char num : sline.substr(speed_start + 1)) {
+                speed = speed * 10 + (num - '0');
+            }
+            line.type = CoolingLine::TYPE_SET_FAN_SPEED;
+            line.fan_speed = speed;
+        } else if (boost::contains(sline, ";_RESET_FAN_SPEED")) {
+            line.type = CoolingLine::TYPE_RESET_FAN_SPEED;
+        }
+
+        if (line.type != 0)
+            adjustment->lines.emplace_back(std::move(line));
+    }
+
+    return per_extruder_adjustments;
+}
+
+// Slow down an extruder range proportionally down to slowdown_below_layer_time.
+// Return the total time for the complete layer.
+static inline float extruder_range_slow_down_proportional(
+    std::vector<PerExtruderAdjustments*>::iterator it_begin,
+    std::vector<PerExtruderAdjustments*>::iterator it_end,
+    // Elapsed time for the extruders already processed.
+    float elapsed_time_total0,
+    // Initial total elapsed time before slow down.
+    float elapsed_time_before_slowdown,
+    // Target time for the complete layer (all extruders applied).
+    float slowdown_below_layer_time)
+{
+    // Total layer time after the slow down has been applied.
+    float total_after_slowdown = elapsed_time_before_slowdown;
+    // Now decide, whether the external perimeters shall be slowed down as well.
+    float max_time_nep = elapsed_time_total0;
+    for (auto it = it_begin; it != it_end; ++ it)
+        max_time_nep += (*it)->maximum_time_after_slowdown(false);
+    if (max_time_nep > slowdown_below_layer_time) {
+        // It is sufficient to slow down the non-external perimeter moves to reach the target layer time.
+        // Slow down the non-external perimeters proportionally.
+        float non_adjustable_time = elapsed_time_total0;
+        for (auto it = it_begin; it != it_end; ++ it)
+            non_adjustable_time += (*it)->non_adjustable_time(false);
+        // The following step is a linear programming task due to the minimum movement speeds of the print moves.
+        // Run maximum 5 iterations until a good enough approximation is reached.
+        for (size_t iter = 0; iter < 5; ++ iter) {
+            float factor = (slowdown_below_layer_time - non_adjustable_time) / (total_after_slowdown - non_adjustable_time);
+            assert(factor > 1.f);
+            total_after_slowdown = elapsed_time_total0;
+            for (auto it = it_begin; it != it_end; ++ it)
+                total_after_slowdown += (*it)->slow_down_proportional(factor, false);
+            if (total_after_slowdown > 0.95f * slowdown_below_layer_time)
+                break;
+        }
+    } else {
+        // Slow down everything. First slow down the non-external perimeters to maximum.
+        for (auto it = it_begin; it != it_end; ++ it)
+            (*it)->slowdown_to_minimum_feedrate(false);
+        // Slow down the external perimeters proportionally.
+        float non_adjustable_time = elapsed_time_total0;
+        for (auto it = it_begin; it != it_end; ++ it)
+            non_adjustable_time += (*it)->non_adjustable_time(true);
+        for (size_t iter = 0; iter < 5; ++ iter) {
+            float factor = (slowdown_below_layer_time - non_adjustable_time) / (total_after_slowdown - non_adjustable_time);
+            assert(factor > 1.f);
+            total_after_slowdown = elapsed_time_total0;
+            for (auto it = it_begin; it != it_end; ++ it)
+                total_after_slowdown += (*it)->slow_down_proportional(factor, true);
+            if (total_after_slowdown > 0.95f * slowdown_below_layer_time)
+                break;
+        }
+    }
+    return total_after_slowdown;
+}
+
+// Slow down an extruder range to slowdown_below_layer_time.
+// Return the total time for the complete layer.
+static inline void extruder_range_slow_down_non_proportional(
+    std::vector<PerExtruderAdjustments*>::iterator it_begin,
+    std::vector<PerExtruderAdjustments*>::iterator it_end,
+    float time_stretch)
+{
+    // Slow down. Try to equalize the feedrates.
+    std::vector<PerExtruderAdjustments*> by_min_print_speed(it_begin, it_end);
+    // Find the next highest adjustable feedrate among the extruders.
+    float feedrate = 0;
+    for (PerExtruderAdjustments *adj : by_min_print_speed) {
+        adj->idx_line_begin = 0;
+        adj->idx_line_end   = 0;
+        assert(adj->idx_line_begin < adj->n_lines_adjustable);
+        if (adj->lines[adj->idx_line_begin].feedrate > feedrate)
+            feedrate = adj->lines[adj->idx_line_begin].feedrate;
+    }
+    assert(feedrate > 0.f);
+    // Sort by min_print_speed, maximum speed first.
+    std::sort(by_min_print_speed.begin(), by_min_print_speed.end(), 
+        [](const PerExtruderAdjustments *p1, const PerExtruderAdjustments *p2){ return p1->min_print_speed > p2->min_print_speed; });
+    // Slow down, fast moves first.
+    for (;;) {
+        // For each extruder, find the span of lines with a feedrate close to feedrate.
+        for (PerExtruderAdjustments *adj : by_min_print_speed) {
+            for (adj->idx_line_end = adj->idx_line_begin;
+                adj->idx_line_end < adj->n_lines_adjustable && adj->lines[adj->idx_line_end].feedrate > feedrate - EPSILON;
+                 ++ adj->idx_line_end) ;
+        }
+        // Find the next highest adjustable feedrate among the extruders.
+        float feedrate_next = 0.f;
+        for (PerExtruderAdjustments *adj : by_min_print_speed)
+            if (adj->idx_line_end < adj->n_lines_adjustable && adj->lines[adj->idx_line_end].feedrate > feedrate_next)
+                feedrate_next = adj->lines[adj->idx_line_end].feedrate;
+        // Slow down, limited by max(feedrate_next, min_print_speed).
+        for (auto adj = by_min_print_speed.begin(); adj != by_min_print_speed.end();) {
+            // Slow down at most by time_stretch.
+            if ((*adj)->min_print_speed == 0.f) {
+                // All the adjustable speeds are now lowered to the same speed,
+                // and the minimum speed is set to zero.
+                float time_adjustable = 0.f;
+                for (auto it = adj; it != by_min_print_speed.end(); ++ it)
+                    time_adjustable += (*it)->adjustable_time(true);
+                assert(time_adjustable > 0);
+                float rate = (time_adjustable + time_stretch) / time_adjustable;
+                for (auto it = adj; it != by_min_print_speed.end(); ++ it)
+                    (*it)->slow_down_proportional(rate, true);
+                return;
+            } else {
+                float feedrate_limit = std::max(feedrate_next, (*adj)->min_print_speed);
+                bool  done           = false;
+                float time_stretch_max = 0.f;
+                for (auto it = adj; it != by_min_print_speed.end(); ++ it)
+                    time_stretch_max += (*it)->time_stretch_when_slowing_down_to_feedrate(feedrate_limit);
+                if (time_stretch_max >= time_stretch) {
+                    feedrate_limit = new_feedrate_to_reach_time_stretch(adj, by_min_print_speed.end(), feedrate_limit, time_stretch, 20);
+                    done = true;
+                } else
+                    time_stretch -= time_stretch_max;
+                for (auto it = adj; it != by_min_print_speed.end(); ++ it)
+                    (*it)->slow_down_to_feedrate(feedrate_limit);
+                if (done)
+                    return;
+            }
+            // Skip the other extruders with nearly the same min_print_speed, as they have been processed already.
+            auto next = adj;
+            for (++ next; next != by_min_print_speed.end() && (*next)->min_print_speed > (*adj)->min_print_speed - EPSILON; ++ next);
+            adj = next;
+        }
+        if (feedrate_next == 0.f)
+            // There are no other extrusions available for slow down.
+            break;
+        for (PerExtruderAdjustments *adj : by_min_print_speed) {
+            adj->idx_line_begin = adj->idx_line_end;
+            feedrate = feedrate_next;
+        }
+    }
+}
+
+// Calculate slow down for all the extruders.
+float CoolingBuffer::calculate_layer_slowdown(std::vector<PerExtruderAdjustments> &per_extruder_adjustments)
+{
+    // Sort the extruders by an increasing slowdown_below_layer_time.
+    // The layers with a lower slowdown_below_layer_time are slowed down
+    // together with all the other layers with slowdown_below_layer_time above.
+    std::vector<PerExtruderAdjustments*> by_slowdown_time;
+    by_slowdown_time.reserve(per_extruder_adjustments.size());
+    // Only insert entries, which are adjustable (have cooling enabled and non-zero stretchable time).
+    // Collect total print time of non-adjustable extruders.
+    float elapsed_time_total0 = 0.f;
+    for (PerExtruderAdjustments &adj : per_extruder_adjustments) {
+        // Curren total time for this extruder.
+        adj.time_total  = adj.elapsed_time_total();
+        // Maximum time for this extruder, when all extrusion moves are slowed down to min_extrusion_speed.
+        adj.time_maximum = adj.maximum_time_after_slowdown(true);
+        if (adj.cooling_slow_down_enabled && adj.lines.size() > 0) {
+            by_slowdown_time.emplace_back(&adj);
+            if (! m_cooling_logic_proportional)
+                // sorts the lines, also sets adj.time_non_adjustable
+                adj.sort_lines_by_decreasing_feedrate();
+        } else
+            elapsed_time_total0 += adj.elapsed_time_total();
+    }
+    std::sort(by_slowdown_time.begin(), by_slowdown_time.end(),
+        [](const PerExtruderAdjustments *adj1, const PerExtruderAdjustments *adj2)
+            { return adj1->slowdown_below_layer_time < adj2->slowdown_below_layer_time; });
+
+    for (auto cur_begin = by_slowdown_time.begin(); cur_begin != by_slowdown_time.end(); ++ cur_begin) {
+        PerExtruderAdjustments &adj = *(*cur_begin);
+        // Calculate the current adjusted elapsed_time_total over the non-finalized extruders.
+        float total = elapsed_time_total0;
+        for (auto it = cur_begin; it != by_slowdown_time.end(); ++ it)
+            total += (*it)->time_total;
+        float slowdown_below_layer_time = adj.slowdown_below_layer_time * 1.001f;
+        if (total > slowdown_below_layer_time) {
+            // The current total time is above the minimum threshold of the rest of the extruders, don't adjust anything.
+        } else {
+            // Adjust this and all the following (higher m_config.slowdown_below_layer_time) extruders.
+            // Sum maximum slow down time as if everything was slowed down including the external perimeters.
+            float max_time = elapsed_time_total0;
+            for (auto it = cur_begin; it != by_slowdown_time.end(); ++ it)
+                max_time += (*it)->time_maximum;
+            if (max_time > slowdown_below_layer_time) {
+                if (m_cooling_logic_proportional)
+                    extruder_range_slow_down_proportional(cur_begin, by_slowdown_time.end(), elapsed_time_total0, total, slowdown_below_layer_time);
+                else
+                    extruder_range_slow_down_non_proportional(cur_begin, by_slowdown_time.end(), slowdown_below_layer_time - total);
+            } else {
+                // Slow down to maximum possible.
+                for (auto it = cur_begin; it != by_slowdown_time.end(); ++ it)
+                    (*it)->slowdown_to_minimum_feedrate(true);
+            }
+        }
+        elapsed_time_total0 += adj.elapsed_time_total();
+    }
+
+    return elapsed_time_total0;
+}
+
+// Apply slow down over G-code lines stored in per_extruder_adjustments, enable fan if needed.
+// Returns the adjusted G-code.
+std::string CoolingBuffer::apply_layer_cooldown(
+    // Source G-code for the current layer.
+    const std::string                      &gcode,
+    // ID of the current layer, used to disable fan for the first n layers.
+    size_t                                  layer_id, 
+    // Total time of this layer after slow down, used to control the fan.
+    float                                   layer_time,
+    // Per extruder list of G-code lines and their cool down attributes.
+    std::vector<PerExtruderAdjustments>    &per_extruder_adjustments)
+{
+    // First sort the adjustment lines by of multiple extruders by their position in the source G-code.
+    std::vector<const CoolingLine*> lines;
+    {
+        size_t n_lines = 0;
+        for (const PerExtruderAdjustments &adj : per_extruder_adjustments)
+            n_lines += adj.lines.size();
+        lines.reserve(n_lines);
+        for (const PerExtruderAdjustments &adj : per_extruder_adjustments)
+            for (const CoolingLine &line : adj.lines)
+                lines.emplace_back(&line);
+        std::sort(lines.begin(), lines.end(), [](const CoolingLine *ln1, const CoolingLine *ln2) { return ln1->line_start < ln2->line_start; } );
+    }
+    // Second generate the adjusted G-code.
+    std::string new_gcode;
+    new_gcode.reserve(gcode.size() * 2);
+    bool bridge_fan_control = false;
+    int  bridge_fan_speed   = 0;
+    auto change_extruder_set_fan = [this, layer_id, layer_time, &new_gcode, &bridge_fan_control, &bridge_fan_speed]() {
+#define EXTRUDER_CONFIG(OPT) m_config.OPT.get_at(m_current_extruder)
+        int min_fan_speed = EXTRUDER_CONFIG(min_fan_speed);
+        //B15
+        int enable_auxiliary_fan = EXTRUDER_CONFIG(enable_auxiliary_fan);
+        int fan_speed_new = EXTRUDER_CONFIG(fan_always_on) ? min_fan_speed : 0;
+        std::pair<int, int> custom_fan_speed_limits{fan_speed_new, 100 };
+        int disable_fan_first_layers = EXTRUDER_CONFIG(disable_fan_first_layers);
+        // Is the fan speed ramp enabled?
+        int full_fan_speed_layer = EXTRUDER_CONFIG(full_fan_speed_layer);
+        if (disable_fan_first_layers <= 0 && full_fan_speed_layer > 0) {
+            // When ramping up fan speed from disable_fan_first_layers to full_fan_speed_layer, force disable_fan_first_layers above zero,
+            // so there will be a zero fan speed at least at the 1st layer.
+            disable_fan_first_layers = 1;
+        }
+        if (int(layer_id) >= disable_fan_first_layers) {
+            int   max_fan_speed             = EXTRUDER_CONFIG(max_fan_speed);
+            float slowdown_below_layer_time = float(EXTRUDER_CONFIG(slowdown_below_layer_time));
+            float fan_below_layer_time      = float(EXTRUDER_CONFIG(fan_below_layer_time));
+            if (EXTRUDER_CONFIG(cooling)) {
+                if (layer_time < slowdown_below_layer_time) {
+                    // Layer time very short. Enable the fan to a full throttle.
+                    fan_speed_new = max_fan_speed;
+                    custom_fan_speed_limits.first = fan_speed_new;
+                } else if (layer_time < fan_below_layer_time) {
+                    // Layer time quite short. Enable the fan proportionally according to the current layer time.
+                    assert(layer_time >= slowdown_below_layer_time);
+                    double t = (layer_time - slowdown_below_layer_time) / (fan_below_layer_time - slowdown_below_layer_time);
+                    fan_speed_new = int(floor(t * min_fan_speed + (1. - t) * max_fan_speed) + 0.5);
+                    custom_fan_speed_limits.first = fan_speed_new;
+                }
+            }
+            bridge_fan_speed   = EXTRUDER_CONFIG(bridge_fan_speed);
+            if (int(layer_id) >= disable_fan_first_layers && int(layer_id) + 1 < full_fan_speed_layer) {
+                // Ramp up the fan speed from disable_fan_first_layers to full_fan_speed_layer.
+                float factor = float(int(layer_id + 1) - disable_fan_first_layers) / float(full_fan_speed_layer - disable_fan_first_layers);
+                fan_speed_new    = std::clamp(int(float(fan_speed_new) * factor + 0.5f), 0, 255);
+                bridge_fan_speed = std::clamp(int(float(bridge_fan_speed) * factor + 0.5f), 0, 255);
+                custom_fan_speed_limits.second = fan_speed_new;
+            }
+#undef EXTRUDER_CONFIG
+            bridge_fan_control = bridge_fan_speed > fan_speed_new;
+        } else { // fan disabled
+            bridge_fan_control = false;
+            bridge_fan_speed   = 0;
+            fan_speed_new      = 0;
+            custom_fan_speed_limits.second = 0;
+        }
+        //B15
+        if (int(layer_id) == disable_fan_first_layers && enable_auxiliary_fan != 0 && fan_speed_new != m_fan_speed) {
+            std::ostringstream fan_gcode;
+            fan_gcode << "M106 P2 S" << 255.0 * enable_auxiliary_fan / 100.0 << "\n";
+            new_gcode += fan_gcode.str();
+        }
+        if (fan_speed_new != m_fan_speed) {
+            m_fan_speed = fan_speed_new;
+            new_gcode  += GCodeWriter::set_fan(m_config.gcode_flavor, m_config.gcode_comments, m_fan_speed);
+        }
+        custom_fan_speed_limits.first = std::min(custom_fan_speed_limits.first, custom_fan_speed_limits.second);
+        return custom_fan_speed_limits;
+    };
+
+    const char         *pos               = gcode.c_str();
+    int                 current_feedrate  = 0;
+    std::pair<int,int> fan_speed_limits = change_extruder_set_fan();
+    for (const CoolingLine *line : lines) {
+        const char *line_start  = gcode.c_str() + line->line_start;
+        const char *line_end    = gcode.c_str() + line->line_end;
+        if (line_start > pos)
+            new_gcode.append(pos, line_start - pos);
+        if (line->type & CoolingLine::TYPE_SET_TOOL) {
+            unsigned int new_extruder = 0;
+            auto res = std::from_chars(line_start + m_toolchange_prefix.size(), line_end, new_extruder);
+            if (res.ec != std::errc::invalid_argument && new_extruder != m_current_extruder) {
+                m_current_extruder = new_extruder;
+                fan_speed_limits = change_extruder_set_fan();
+            }
+            new_gcode.append(line_start, line_end - line_start);
+        } else if (line->type & CoolingLine::TYPE_SET_FAN_SPEED) {
+            int new_speed = std::clamp(line->fan_speed, fan_speed_limits.first, fan_speed_limits.second);
+            if (m_fan_speed != new_speed) {
+                new_gcode += GCodeWriter::set_fan(m_config.gcode_flavor, m_config.gcode_comments, new_speed);
+                m_fan_speed = new_speed;
+            }
+        } else if (line->type & CoolingLine::TYPE_RESET_FAN_SPEED){
+            fan_speed_limits = change_extruder_set_fan();
+        } else if (line->type & CoolingLine::TYPE_BRIDGE_FAN_START) {
+            if (bridge_fan_control)
+                new_gcode += GCodeWriter::set_fan(m_config.gcode_flavor, m_config.gcode_comments, bridge_fan_speed);
+        } else if (line->type & CoolingLine::TYPE_BRIDGE_FAN_END) {
+            if (bridge_fan_control)
+                new_gcode += GCodeWriter::set_fan(m_config.gcode_flavor, m_config.gcode_comments, m_fan_speed);
+        } else if (line->type & CoolingLine::TYPE_EXTRUDE_END) {
+            // Just remove this comment.
+        } else if (line->type & (CoolingLine::TYPE_ADJUSTABLE | CoolingLine::TYPE_ADJUSTABLE_EMPTY | CoolingLine::TYPE_EXTERNAL_PERIMETER | CoolingLine::TYPE_WIPE | CoolingLine::TYPE_HAS_F)) {
+            // Find the start of a comment, or roll to the end of line.
+            const char *end = line_start;
+            for (; end < line_end && *end != ';'; ++ end);
+            // Find the 'F' word.
+            const char *fpos            = strstr(line_start + 2, " F") + 2;
+            int         new_feedrate    = current_feedrate;
+            // Modify the F word of the current G-code line.
+            bool        modify          = false;
+            // Remove the F word from the current G-code line.
+            bool        remove          = false;
+            assert(fpos != nullptr);
+            if (line->slowdown)
+                new_feedrate = int(floor(60. * line->feedrate + 0.5));
+            else
+                //auto res = 
+                    std::from_chars(fpos, line_end, new_feedrate);
+            if (new_feedrate == current_feedrate) {
+                // No need to change the F value.
+                if ((line->type & (CoolingLine::TYPE_ADJUSTABLE | CoolingLine::TYPE_ADJUSTABLE_EMPTY | CoolingLine::TYPE_EXTERNAL_PERIMETER | CoolingLine::TYPE_WIPE)) || line->length == 0.)
+                    // Feedrate does not change and this line does not move the print head. Skip the complete G-code line including the G-code comment.
+                    end = line_end;
+                else
+                    // Remove the feedrate from the G0/G1 line. The G-code line may become empty!
+                    remove = true;
+            } else if (line->slowdown) {
+                // The F value will be overwritten.
+                modify = true;
+            } else {
+                // The F value is different from current_feedrate, but not slowed down, thus the G-code line will not be modified.
+                // Emit the line without the comment.
+                new_gcode.append(line_start, end - line_start);
+                current_feedrate = new_feedrate;
+            }
+            if (modify || remove) {
+                if (modify) {
+                    // Replace the feedrate.
+                    new_gcode.append(line_start, fpos - line_start);
+                    current_feedrate = new_feedrate;
+                    char buf[64];
+                    sprintf(buf, "%d", int(current_feedrate));
+                    new_gcode += buf;
+                } else {
+                    // Remove the feedrate word.
+                    const char *f = fpos;
+                    // Roll the pointer before the 'F' word.
+                    for (f -= 2; f > line_start && (*f == ' ' || *f == '\t'); -- f);
+                    // Append up to the F word, without the trailing whitespace.
+                    new_gcode.append(line_start, f - line_start + 1);
+                }
+                // Skip the non-whitespaces of the F parameter up the comment or end of line.
+                for (; fpos != end && *fpos != ' ' && *fpos != ';' && *fpos != '\n'; ++ fpos);
+                // Append the rest of the line without the comment.
+                if (remove && (fpos == end || *fpos == '\n') && (new_gcode == "G1" || boost::ends_with(new_gcode, "\nG1"))) {
+                    // The G-code line only contained the F word, now it is empty. Remove it completely including the comments.
+                    new_gcode.resize(new_gcode.size() - 2);
+                    end = line_end;
+                } else {
+                    // The G-code line may not be empty yet. Emit the rest of it.
+                    new_gcode.append(fpos, end - fpos);
+                }
+            }
+            // Process the rest of the line.
+            if (end < line_end) {
+                if (line->type & (CoolingLine::TYPE_ADJUSTABLE | CoolingLine::TYPE_ADJUSTABLE_EMPTY | CoolingLine::TYPE_EXTERNAL_PERIMETER | CoolingLine::TYPE_WIPE)) {
+                    // Process comments, remove ";_EXTRUDE_SET_SPEED", ";_EXTERNAL_PERIMETER", ";_WIPE"
+                    std::string comment(end, line_end);
+                    boost::replace_all(comment, ";_EXTRUDE_SET_SPEED", "");
+                    if (line->type & CoolingLine::TYPE_EXTERNAL_PERIMETER)
+                        boost::replace_all(comment, ";_EXTERNAL_PERIMETER", "");
+                    if (line->type & CoolingLine::TYPE_WIPE)
+                        boost::replace_all(comment, ";_WIPE", "");
+                    new_gcode += comment;
+                } else {
+                    // Just attach the rest of the source line.
+                    new_gcode.append(end, line_end - end);
+                }
+            }
+        } else {
+            new_gcode.append(line_start, line_end - line_start);
+        }
+        pos = line_end;
+    }
+    const char *gcode_end = gcode.c_str() + gcode.size();
+    if (pos < gcode_end)
+        new_gcode.append(pos, gcode_end - pos);
+
+    // There should be no empty G1 lines emitted.
+    assert(new_gcode.find("G1\n") == std::string::npos);
+    return new_gcode;
+}
+
+} // namespace Slic3r

src/libslic3r/GCode/CoolingBuffer.hpp

@@ -0,0 +1,65 @@
+#ifndef slic3r_CoolingBuffer_hpp_
+#define slic3r_CoolingBuffer_hpp_
+
+#include "../libslic3r.h"
+#include <map>
+#include <string>
+
+namespace Slic3r {
+
+class GCode;
+class Layer;
+struct PerExtruderAdjustments;
+
+// A standalone G-code filter, to control cooling of the print.
+// The G-code is processed per layer. Once a layer is collected, fan start / stop commands are edited
+// and the print is modified to stretch over a minimum layer time.
+//
+// The simple it sounds, the actual implementation is significantly more complex.
+// Namely, for a multi-extruder print, each material may require a different cooling logic.
+// For example, some materials may not like to print too slowly, while with some materials 
+// we may slow down significantly.
+//
+class CoolingBuffer {
+public:
+    CoolingBuffer(GCode &gcodegen);
+    void        reset(const Vec3d &position);
+    void        set_current_extruder(unsigned int extruder_id) { m_current_extruder = extruder_id; }
+    std::string process_layer(std::string &&gcode, size_t layer_id, bool flush);
+    std::string process_layer(const std::string &gcode, size_t layer_id, bool flush)
+        { return this->process_layer(std::string(gcode), layer_id, flush); }
+
+private:
+	CoolingBuffer& operator=(const CoolingBuffer&) = delete;
+    std::vector<PerExtruderAdjustments> parse_layer_gcode(const std::string &gcode, std::vector<float> &current_pos) const;
+    float       calculate_layer_slowdown(std::vector<PerExtruderAdjustments> &per_extruder_adjustments);
+    // Apply slow down over G-code lines stored in per_extruder_adjustments, enable fan if needed.
+    // Returns the adjusted G-code.
+    std::string apply_layer_cooldown(const std::string &gcode, size_t layer_id, float layer_time, std::vector<PerExtruderAdjustments> &per_extruder_adjustments);
+
+    // G-code snippet cached for the support layers preceding an object layer.
+    std::string                 m_gcode;
+    // Internal data.
+    // X,Y,Z,E,F
+    std::vector<char>           m_axis;
+    std::vector<float>          m_current_pos;
+    // Current known fan speed or -1 if not known yet.
+    int                         m_fan_speed;
+    // Cached from GCodeWriter.
+    // Printing extruder IDs, zero based.
+    std::vector<unsigned int>   m_extruder_ids;
+    // Highest of m_extruder_ids plus 1.
+    unsigned int                m_num_extruders { 0 };
+    const std::string           m_toolchange_prefix;
+    // Referencs GCode::m_config, which is FullPrintConfig. While the PrintObjectConfig slice of FullPrintConfig is being modified,
+    // the PrintConfig slice of FullPrintConfig is constant, thus no thread synchronization is required.
+    const PrintConfig          &m_config;
+    unsigned int                m_current_extruder;
+
+    // Old logic: proportional.
+    bool                        m_cooling_logic_proportional = false;
+};
+
+}
+
+#endif

src/libslic3r/GCode/DataType.h

@@ -0,0 +1,144 @@
+#ifndef _DATA_TYPE_H_
+#define _DATA_TYPE_H_
+
+//#include "framework.h"
+#include <stdlib.h> 
+
+#ifndef null
+#define null 0
+#endif
+#ifndef NULL
+#define NULL 0
+#endif
+
+
+#ifndef FALSE
+#define FALSE             0
+#endif
+#ifndef TRUE
+#define TRUE              1
+#endif
+#ifndef U8
+typedef		unsigned char		U8;
+#endif
+
+#ifndef S8
+typedef		signed char			S8;
+#endif
+
+#ifndef U16
+typedef		unsigned short		U16;
+#endif
+
+#ifndef S16
+typedef		signed short		S16;
+#endif
+
+#ifndef U32
+typedef		unsigned int		U32;
+#endif
+
+#ifndef S32
+typedef		signed int			S32;
+#endif
+
+#ifndef S64
+typedef		signed long long	S64;
+#endif
+
+#ifndef U64
+typedef		unsigned long long 	U64;
+#endif
+
+#ifndef FP32
+typedef		float				FP32;
+#endif
+
+#ifndef FP64
+typedef		double				FP64;
+#endif
+
+#ifndef Pixel_t
+typedef unsigned short Pixel_t;
+#endif
+
+#ifndef UINT32
+typedef unsigned int      UINT32;
+#endif
+
+
+#ifndef INT
+typedef int               INT;
+#endif
+
+#ifndef INT32
+typedef int               INT32;
+#endif
+
+typedef unsigned char  INT8U;                    /* Unsigned  8 bit quantity                           */
+typedef signed   char  INT8S;                    /* Signed    8 bit quantity                           */
+typedef unsigned short INT16U;                   /* Unsigned 16 bit quantity                           */
+typedef signed   short INT16S;                   /* Signed   16 bit quantity                           */
+typedef unsigned int   INT32U;                   /* Unsigned 32 bit quantity                           */
+typedef signed   int   INT32S;                   /* Signed   32 bit quantity                           */
+typedef unsigned long long   INT64U; 
+typedef signed long long   INT64S; 
+
+typedef float          FP32;                     /* Single precision floating point                    */
+typedef double         FP64;                     /* Double precision floating point                    */
+
+
+typedef struct
+{
+	U16 star;
+	U16 end;
+}PosLaction;
+typedef struct
+{
+	int a0;
+	int a1;
+	int a2;
+	int a3;
+	int a4;
+	int a5;
+	int a6;
+	int a7;
+	int a8;
+	int a9;
+	int a10;
+	int a11;
+	int a12;
+	int a13;
+	int a14;
+	int a15;
+}bytes_64Bytes;
+typedef struct
+{
+	bytes_64Bytes a0;
+	bytes_64Bytes a1;
+	bytes_64Bytes a2;
+	bytes_64Bytes a3;	
+}bytes_256Bytes;
+typedef struct
+{
+	bytes_64Bytes a0;
+	bytes_64Bytes a1;
+	bytes_64Bytes a2;
+	bytes_64Bytes a3;
+	bytes_64Bytes a4;
+	bytes_64Bytes a5;
+	bytes_64Bytes a6;
+	bytes_64Bytes a7;
+	bytes_64Bytes a8;
+	bytes_64Bytes a9;
+	bytes_64Bytes a10;
+	bytes_64Bytes a11;
+	bytes_64Bytes a12;
+	bytes_64Bytes a13;
+	bytes_64Bytes a14;
+	bytes_64Bytes a15;
+}bytes_1024Bytes;
+#endif
+
+
+

src/libslic3r/GCode/ExtrusionProcessor.hpp

@@ -0,0 +1,354 @@
+#ifndef slic3r_ExtrusionProcessor_hpp_
+#define slic3r_ExtrusionProcessor_hpp_
+
+#include "../AABBTreeLines.hpp"
+#include "../SupportSpotsGenerator.hpp"
+#include "../libslic3r.h"
+#include "../ExtrusionEntity.hpp"
+#include "../Layer.hpp"
+#include "../Point.hpp"
+#include "../SVG.hpp"
+#include "../BoundingBox.hpp"
+#include "../Polygon.hpp"
+#include "../ClipperUtils.hpp"
+#include "../Flow.hpp"
+#include "../Config.hpp"
+#include "../Line.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <iterator>
+#include <limits>
+#include <numeric>
+#include <ostream>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace Slic3r {
+
+struct ExtendedPoint
+{
+    Vec2d  position;
+    float  distance;
+    float  curvature;
+};
+
+template<bool SCALED_INPUT, bool ADD_INTERSECTIONS, bool PREV_LAYER_BOUNDARY_OFFSET, bool SIGNED_DISTANCE, typename POINTS, typename L>
+std::vector<ExtendedPoint> estimate_points_properties(const POINTS                           &input_points,
+                                                      const AABBTreeLines::LinesDistancer<L> &unscaled_prev_layer,
+                                                      float                                   flow_width,
+                                                      float                                   max_line_length = -1.0f)
+{
+    using P = typename POINTS::value_type;
+
+    using AABBScalar = typename AABBTreeLines::LinesDistancer<L>::Scalar;
+    if (input_points.empty())
+        return {};
+    float              boundary_offset = PREV_LAYER_BOUNDARY_OFFSET ? 0.5 * flow_width : 0.0f;
+    auto maybe_unscale = [](const P &p) { return SCALED_INPUT ? unscaled(p) : p.template cast<double>(); };
+
+    std::vector<ExtendedPoint> points;
+    points.reserve(input_points.size() * (ADD_INTERSECTIONS ? 1.5 : 1));
+
+    {
+        ExtendedPoint start_point{maybe_unscale(input_points.front())};
+        auto [distance, nearest_line, x]    = unscaled_prev_layer.template distance_from_lines_extra<SIGNED_DISTANCE>(start_point.position.cast<AABBScalar>());
+        start_point.distance                = distance + boundary_offset;
+        points.push_back(start_point);
+    }
+    for (size_t i = 1; i < input_points.size(); i++) {
+        ExtendedPoint next_point{maybe_unscale(input_points[i])};
+        auto [distance, nearest_line, x]   = unscaled_prev_layer.template distance_from_lines_extra<SIGNED_DISTANCE>(next_point.position.cast<AABBScalar>());
+        next_point.distance                = distance + boundary_offset;
+
+        if (ADD_INTERSECTIONS &&
+            ((points.back().distance > boundary_offset + EPSILON) != (next_point.distance > boundary_offset + EPSILON))) {
+            const ExtendedPoint &prev_point = points.back();
+            auto intersections = unscaled_prev_layer.template intersections_with_line<true>(L{prev_point.position.cast<AABBScalar>(), next_point.position.cast<AABBScalar>()});
+            for (const auto &intersection : intersections) {
+                ExtendedPoint p{};
+                p.position = intersection.first.template cast<double>();
+                p.distance = boundary_offset;
+                points.push_back(p);
+            }
+        }
+        points.push_back(next_point);
+    }
+
+    if (PREV_LAYER_BOUNDARY_OFFSET && ADD_INTERSECTIONS) {
+        std::vector<ExtendedPoint> new_points;
+        new_points.reserve(points.size()*2);
+        new_points.push_back(points.front());
+        for (int point_idx = 0; point_idx < int(points.size()) - 1; ++point_idx) {
+            const ExtendedPoint &curr = points[point_idx];
+            const ExtendedPoint &next = points[point_idx + 1];
+
+            if ((curr.distance > 0 && curr.distance < boundary_offset + 2.0f) ||
+                (next.distance > 0 && next.distance < boundary_offset + 2.0f)) {
+                double line_len = (next.position - curr.position).norm();
+                if (line_len > 4.0f) {
+                    double a0 = std::clamp((curr.distance + 2 * boundary_offset) / line_len, 0.0, 1.0);
+                    double a1 = std::clamp(1.0f - (next.distance + 2 * boundary_offset) / line_len, 0.0, 1.0);
+                    double t0 = std::min(a0, a1);
+                    double t1 = std::max(a0, a1);
+
+                    if (t0 < 1.0) {
+                        auto p0                         = curr.position + t0 * (next.position - curr.position);
+                        auto [p0_dist, p0_near_l, p0_x] = unscaled_prev_layer.template distance_from_lines_extra<SIGNED_DISTANCE>(p0.cast<AABBScalar>());
+                        ExtendedPoint new_p{};
+                        new_p.position                 = p0;
+                        new_p.distance                 = float(p0_dist + boundary_offset);
+                        new_points.push_back(new_p);
+                    }
+                    if (t1 > 0.0) {
+                        auto p1                         = curr.position + t1 * (next.position - curr.position);
+                        auto [p1_dist, p1_near_l, p1_x] = unscaled_prev_layer.template distance_from_lines_extra<SIGNED_DISTANCE>(p1.cast<AABBScalar>());
+                        ExtendedPoint new_p{};
+                        new_p.position                 = p1;
+                        new_p.distance                 = float(p1_dist + boundary_offset);
+                        new_points.push_back(new_p);
+                    }
+                }
+            }
+            new_points.push_back(next);
+        }
+        points = new_points;
+    }
+
+    if (max_line_length > 0) {
+        std::vector<ExtendedPoint> new_points;
+        new_points.reserve(points.size()*2);
+        {
+            for (size_t i = 0; i + 1 < points.size(); i++) {
+                const ExtendedPoint &curr = points[i];
+                const ExtendedPoint &next = points[i + 1];
+                new_points.push_back(curr);
+                double len             = (next.position - curr.position).squaredNorm();
+                double t               = sqrt((max_line_length * max_line_length) / len);
+                size_t new_point_count = 1.0 / t;
+                for (size_t j = 1; j < new_point_count + 1; j++) {
+                    Vec2d pos  = curr.position * (1.0 - j * t) + next.position * (j * t);
+                    auto [p_dist, p_near_l,
+                          p_x] = unscaled_prev_layer.template distance_from_lines_extra<SIGNED_DISTANCE>(pos.cast<AABBScalar>());
+                    ExtendedPoint new_p{};
+                    new_p.position                 = pos;
+                    new_p.distance                 = float(p_dist + boundary_offset);
+                    new_points.push_back(new_p);
+                }
+            }
+            new_points.push_back(points.back());
+        }
+        points = new_points;
+    }
+
+    std::vector<float> angles_for_curvature(points.size());
+    std::vector<float> distances_for_curvature(points.size());
+
+    for (int point_idx = 0; point_idx < int(points.size()); ++point_idx) {
+        ExtendedPoint &a    = points[point_idx];
+        ExtendedPoint &prev = points[point_idx > 0 ? point_idx - 1 : point_idx];
+
+        int prev_point_idx = point_idx;
+        while (prev_point_idx > 0) {
+            prev_point_idx--;
+            if ((a.position - points[prev_point_idx].position).squaredNorm() > EPSILON) {
+                break;
+            }
+        }
+
+        int next_point_index = point_idx;
+        while (next_point_index < int(points.size()) - 1) {
+            next_point_index++;
+            if ((a.position - points[next_point_index].position).squaredNorm() > EPSILON) {
+                break;
+            }
+        }
+
+        distances_for_curvature[point_idx] = (prev.position - a.position).norm();
+        if (prev_point_idx != point_idx && next_point_index != point_idx) {
+            float alfa = angle(a.position - points[prev_point_idx].position, points[next_point_index].position - a.position);
+            angles_for_curvature[point_idx] = alfa;
+        } // else keep zero
+    }
+
+    for (float window_size : {3.0f, 9.0f, 16.0f}) {
+        size_t tail_point      = 0;
+        float  tail_window_acc = 0;
+        float  tail_angle_acc  = 0;
+
+        size_t head_point      = 0;
+        float  head_window_acc = 0;
+        float  head_angle_acc  = 0;
+
+        for (int point_idx = 0; point_idx < int(points.size()); ++point_idx) {
+            if (point_idx > 0) {
+                tail_window_acc += distances_for_curvature[point_idx - 1];
+                tail_angle_acc += angles_for_curvature[point_idx - 1];
+                head_window_acc -= distances_for_curvature[point_idx - 1];
+                head_angle_acc -= angles_for_curvature[point_idx - 1];
+            }
+            while (tail_window_acc > window_size * 0.5 && tail_point < point_idx) {
+                tail_window_acc -= distances_for_curvature[tail_point];
+                tail_angle_acc -= angles_for_curvature[tail_point];
+                tail_point++;
+            }
+
+            while (head_window_acc < window_size * 0.5 && head_point < int(points.size()) - 1) {
+                head_window_acc += distances_for_curvature[head_point];
+                head_angle_acc += angles_for_curvature[head_point];
+                head_point++;
+            }
+
+            float curvature = (tail_angle_acc + head_angle_acc) / (tail_window_acc + head_window_acc);
+            if (std::abs(curvature) > std::abs(points[point_idx].curvature)) {
+                points[point_idx].curvature = curvature;
+            }
+        }
+    }
+
+    return points;
+}
+
+struct ProcessedPoint
+{
+    Point p;
+    float speed = 1.0f;
+    int fan_speed = 0;
+};
+
+class ExtrusionQualityEstimator
+{
+    std::unordered_map<const PrintObject *, AABBTreeLines::LinesDistancer<Linef>> prev_layer_boundaries;
+    std::unordered_map<const PrintObject *, AABBTreeLines::LinesDistancer<Linef>> next_layer_boundaries;
+    std::unordered_map<const PrintObject *, AABBTreeLines::LinesDistancer<CurledLine>> prev_curled_extrusions;
+    std::unordered_map<const PrintObject *, AABBTreeLines::LinesDistancer<CurledLine>> next_curled_extrusions;
+    const PrintObject                                                            *current_object;
+
+public:
+    void set_current_object(const PrintObject *object) { current_object = object; }
+
+    void prepare_for_new_layer(const Layer *layer)
+    {
+        if (layer == nullptr)
+            return;
+        const PrintObject *object      = layer->object();
+        prev_layer_boundaries[object]  = next_layer_boundaries[object];
+        next_layer_boundaries[object]  = AABBTreeLines::LinesDistancer<Linef>{to_unscaled_linesf(layer->lslices)};
+        prev_curled_extrusions[object] = next_curled_extrusions[object];
+        next_curled_extrusions[object] = AABBTreeLines::LinesDistancer<CurledLine>{layer->curled_lines};
+    }
+
+    std::vector<ProcessedPoint> estimate_speed_from_extrusion_quality(
+        const ExtrusionPath                                          &path,
+        const std::vector<std::pair<int, ConfigOptionFloatOrPercent>> overhangs_w_speeds,
+        const std::vector<std::pair<int, ConfigOptionInts>>           overhangs_w_fan_speeds,
+        size_t                                                        extruder_id,
+        float                                                         ext_perimeter_speed,
+        float                                                         original_speed)
+    {
+        float                  speed_base = ext_perimeter_speed > 0 ? ext_perimeter_speed : original_speed;
+        std::map<float, float> speed_sections;
+        for (size_t i = 0; i < overhangs_w_speeds.size(); i++) {
+            float distance           = path.width * (1.0 - (overhangs_w_speeds[i].first / 100.0));
+            float speed              = overhangs_w_speeds[i].second.percent ? (speed_base * overhangs_w_speeds[i].second.value / 100.0) :
+                                                                              overhangs_w_speeds[i].second.value;
+            if (speed < EPSILON) speed = speed_base;
+            speed_sections[distance] = speed;
+        }
+
+        std::map<float, float> fan_speed_sections;
+        for (size_t i = 0; i < overhangs_w_fan_speeds.size(); i++) {
+            float distance           = path.width * (1.0 - (overhangs_w_fan_speeds[i].first / 100.0));
+            float fan_speed            = overhangs_w_fan_speeds[i].second.get_at(extruder_id);
+            fan_speed_sections[distance] = fan_speed;
+        }
+
+        std::vector<ExtendedPoint> extended_points =
+            estimate_points_properties<true, true, true, true>(path.polyline.points, prev_layer_boundaries[current_object], path.width);
+
+        std::vector<ProcessedPoint> processed_points;
+        processed_points.reserve(extended_points.size());
+        for (size_t i = 0; i < extended_points.size(); i++) {
+            const ExtendedPoint &curr = extended_points[i];
+            const ExtendedPoint &next = extended_points[i + 1 < extended_points.size() ? i + 1 : i];
+
+            // The following code artifically increases the distance to provide slowdown for extrusions that are over curled lines
+            float artificial_distance_to_curled_lines = 0.0;
+            const double dist_limit = 10.0 * path.width;
+            {
+                Vec2d middle = 0.5 * (curr.position + next.position);
+                auto line_indices = prev_curled_extrusions[current_object].all_lines_in_radius(Point::new_scale(middle), scale_(dist_limit));
+                if (!line_indices.empty()) {
+                    double len   = (next.position - curr.position).norm();
+                    // For long lines, there is a problem with the additional slowdown. If by accident, there is small curled line near the middle of this long line
+                    //  The whole segment gets slower unnecesarily. For these long lines, we do additional check whether it is worth slowing down.
+                    // NOTE that this is still quite rough approximation, e.g. we are still checking lines only near the middle point
+                    // TODO maybe split the lines into smaller segments before running this alg? but can be demanding, and GCode will be huge
+                    if (len > 8) {
+                        Vec2d dir   = Vec2d(next.position - curr.position) / len;
+                        Vec2d right = Vec2d(-dir.y(), dir.x());
+
+                        Polygon box_of_influence = {
+                            scaled(Vec2d(curr.position + right * dist_limit)),
+                            scaled(Vec2d(next.position + right * dist_limit)),
+                            scaled(Vec2d(next.position - right * dist_limit)),
+                            scaled(Vec2d(curr.position - right * dist_limit)),
+                        };
+
+                        double projected_lengths_sum = 0;
+                        for (size_t idx : line_indices) {
+                            const CurledLine &line   = prev_curled_extrusions[current_object].get_line(idx);
+                            Lines             inside = intersection_ln({{line.a, line.b}}, {box_of_influence});
+                            if (inside.empty())
+                                continue;
+                            double projected_length = abs(dir.dot(unscaled(Vec2d((inside.back().b - inside.back().a).cast<double>()))));
+                            projected_lengths_sum += projected_length;
+                        }
+                        if (projected_lengths_sum < 0.4 * len) {
+                            line_indices.clear();
+                        }
+                    }
+
+                    for (size_t idx : line_indices) {
+                        const CurledLine &line                 = prev_curled_extrusions[current_object].get_line(idx);
+                        float             distance_from_curled = unscaled(line_alg::distance_to(line, Point::new_scale(middle)));
+                        float             dist                 = path.width * (1.0 - (distance_from_curled / dist_limit)) *
+                                     (1.0 - (distance_from_curled / dist_limit)) *
+                                     (line.curled_height / (path.height * 10.0f)); // max_curled_height_factor from SupportSpotGenerator
+                        artificial_distance_to_curled_lines = std::max(artificial_distance_to_curled_lines, dist);
+                    }
+                }
+            }
+
+            auto interpolate_speed = [](const std::map<float, float> &values, float distance) {
+                auto upper_dist = values.lower_bound(distance);
+                if (upper_dist == values.end()) {
+                    return values.rbegin()->second;
+                }
+                if (upper_dist == values.begin()) {
+                    return upper_dist->second;
+                }
+
+                auto  lower_dist = std::prev(upper_dist);
+                float t          = (distance - lower_dist->first) / (upper_dist->first - lower_dist->first);
+                return (1.0f - t) * lower_dist->second + t * upper_dist->second;
+            };
+
+            float extrusion_speed   = std::min(interpolate_speed(speed_sections, curr.distance),
+                                               interpolate_speed(speed_sections, next.distance));
+            float curled_base_speed = interpolate_speed(speed_sections, artificial_distance_to_curled_lines);
+            float final_speed       = std::min(curled_base_speed, extrusion_speed);
+            float fan_speed         = std::min(interpolate_speed(fan_speed_sections, curr.distance),
+                                               interpolate_speed(fan_speed_sections, next.distance));
+
+            processed_points.push_back({scaled(curr.position), final_speed, int(fan_speed)});
+        }
+        return processed_points;
+    }
+};
+
+} // namespace Slic3r
+
+#endif // slic3r_ExtrusionProcessor_hpp_

src/libslic3r/GCode/FindReplace.cpp

@@ -0,0 +1,156 @@
+#include "FindReplace.hpp"
+#include "../Utils.hpp"
+
+#include <cctype> // isalpha
+#include <boost/algorithm/string/replace.hpp>
+
+namespace Slic3r {
+
+// Similar to https://npp-user-manual.org/docs/searching/#extended-search-mode
+const void unescape_extended_search_mode(std::string &s)
+{
+    boost::replace_all(s, "\\n", "\n"); // Line Feed control character LF (ASCII 0x0A)
+    boost::replace_all(s, "\\r", "\r"); // Carriage Return control character CR (ASCII 0x0D)
+    boost::replace_all(s, "\\t", "\t"); // TAB control character (ASCII 0x09)
+    boost::replace_all(s, "\\0", "\0x00"); // NUL control character (ASCII 0x00)
+    boost::replace_all(s, "\\\\", "\\"); // Backslash character (ASCII 0x5C)
+
+// Notepad++ also supports:
+// \o: the octal representation of a byte, made of 3 digits in the 0-7 range
+// \d: the decimal representation of a byte, made of 3 digits in the 0-9 range
+// \x: the hexadecimal representation of a byte, made of 2 digits in the 0-9, A-F/a-f range.
+// \u: The hexadecimal representation of a two-byte character, made of 4 digits in the 0-9, A-F/a-f range.
+}
+
+GCodeFindReplace::GCodeFindReplace(const std::vector<std::string> &gcode_substitutions)
+{
+    if ((gcode_substitutions.size() % 4) != 0)
+        throw RuntimeError("Invalid length of gcode_substitutions parameter");
+
+    m_substitutions.reserve(gcode_substitutions.size() / 4);
+    for (size_t i = 0; i < gcode_substitutions.size(); i += 4) {
+        Substitution out;
+        try {
+            out.plain_pattern    = gcode_substitutions[i];
+            out.format           = gcode_substitutions[i + 1];
+            const std::string &params = gcode_substitutions[i + 2];
+            out.regexp           = strchr(params.c_str(), 'r') != nullptr || strchr(params.c_str(), 'R') != nullptr;
+            out.case_insensitive = strchr(params.c_str(), 'i') != nullptr || strchr(params.c_str(), 'I') != nullptr;
+            out.whole_word       = strchr(params.c_str(), 'w') != nullptr || strchr(params.c_str(), 'W') != nullptr;
+            out.single_line      = strchr(params.c_str(), 's') != nullptr || strchr(params.c_str(), 'S') != nullptr;
+            if (out.regexp) {
+                out.regexp_pattern.assign(
+                    out.whole_word ? 
+                        std::string("\\b") + out.plain_pattern + "\\b" :
+                        out.plain_pattern,
+                    (out.case_insensitive ? boost::regex::icase : 0) | boost::regex::optimize);
+            } else {
+                unescape_extended_search_mode(out.plain_pattern);
+                unescape_extended_search_mode(out.format);
+            }
+        } catch (const std::exception &ex) {
+            throw RuntimeError(std::string("Invalid gcode_substitutions parameter, failed to compile regular expression: ") + ex.what());
+        }
+        m_substitutions.emplace_back(std::move(out));
+    }
+}
+
+class ToStringIterator 
+{
+public:
+    using iterator_category     = std::output_iterator_tag;
+    using value_type            = void;
+    using difference_type       = void;
+    using pointer               = void;
+    using reference             = void;
+
+    ToStringIterator(std::string &data) : m_data(&data) {}
+
+    ToStringIterator& operator=(const char val) {
+        size_t needs = m_data->size() + 1;
+        if (m_data->capacity() < needs)
+            m_data->reserve(next_highest_power_of_2(needs));
+        m_data->push_back(val);
+        return *this;
+    }
+
+    ToStringIterator& operator*()     { return *this; }
+    ToStringIterator& operator++()    { return *this; }
+    ToStringIterator  operator++(int) { return *this; }
+
+private:
+    std::string *m_data;
+};
+
+template<typename FindFn>
+static void find_and_replace_whole_word(std::string &inout, const std::string &match, const std::string &replace, FindFn find_fn)
+{
+    if (! match.empty() && inout.size() >= match.size() && match != replace) {
+        std::string out;
+        auto [i, j] = find_fn(inout, 0, match);
+        size_t k = 0;
+        for (; i != std::string::npos; std::tie(i, j) = find_fn(inout, i, match)) {
+            if ((i == 0 || ! std::isalnum(inout[i - 1])) && (j == inout.size() || ! std::isalnum(inout[j]))) {
+                out.reserve(inout.size());
+                out.append(inout, k, i - k);
+                out.append(replace);
+                i = k = j;
+            } else
+                i += match.size();
+        }
+        if (k > 0) {
+            out.append(inout, k, inout.size() - k);
+            inout.swap(out);
+        }
+    }
+}
+
+std::string GCodeFindReplace::process_layer(const std::string &ain)
+{
+    std::string out;
+    const std::string *in = &ain;
+    std::string temp;
+    temp.reserve(in->size());
+
+    for (const Substitution &substitution : m_substitutions) {
+        if (substitution.regexp) {
+            temp.clear();
+            temp.reserve(in->size());
+            boost::regex_replace(ToStringIterator(temp), in->begin(), in->end(),
+                substitution.regexp_pattern, substitution.format, 
+                (substitution.single_line ? boost::match_single_line | boost::match_default : boost::match_not_dot_newline | boost::match_default) | boost::format_all);
+            std::swap(out, temp);
+        } else {
+            if (in == &ain)
+                out = ain;
+            // Plain substitution
+            if (substitution.case_insensitive) {
+                if (substitution.whole_word)
+                    find_and_replace_whole_word(out, substitution.plain_pattern, substitution.format,
+                        [](const std::string &str, size_t start_pos, const std::string &match) {
+                            auto begin = str.begin() + start_pos;
+                            boost::iterator_range<std::string::const_iterator> r1(begin, str.end());
+                            boost::iterator_range<std::string::const_iterator> r2(match.begin(), match.end());
+                            auto res = boost::ifind_first(r1, r2);
+                            return res ? std::make_pair(size_t(res.begin() - str.begin()), size_t(res.end() - str.begin())) : std::make_pair(std::string::npos, std::string::npos);
+                        });
+                else
+                    boost::ireplace_all(out, substitution.plain_pattern, substitution.format);
+            } else {
+                if (substitution.whole_word)
+                    find_and_replace_whole_word(out, substitution.plain_pattern, substitution.format,
+                        [](const std::string &str, size_t start_pos, const std::string &match) { 
+                            size_t pos = str.find(match, start_pos);
+                            return std::make_pair(pos, pos + (pos == std::string::npos ? 0 : match.size()));
+                        });
+                else
+                    boost::replace_all(out, substitution.plain_pattern, substitution.format);
+            }
+        }
+        in = &out;
+    }
+
+    return out;
+}
+
+}

src/libslic3r/GCode/FindReplace.hpp

@@ -0,0 +1,35 @@
+#ifndef slic3r_FindReplace_hpp_
+#define slic3r_FindReplace_hpp_
+
+#include "../PrintConfig.hpp"
+
+#include <boost/regex.hpp>
+
+namespace Slic3r {
+
+class GCodeFindReplace {
+public:
+    GCodeFindReplace(const PrintConfig &print_config) : GCodeFindReplace(print_config.gcode_substitutions.values) {}
+    GCodeFindReplace(const std::vector<std::string> &gcode_substitutions);
+
+
+    std::string process_layer(const std::string &gcode);
+    
+private:
+    struct Substitution {
+        std::string     plain_pattern;
+        boost::regex    regexp_pattern;
+        std::string     format;
+
+        bool            regexp { false };
+        bool            case_insensitive { false };
+        bool            whole_word { false };
+        // Valid for regexp only. Equivalent to Perl's /s modifier.
+        bool            single_line { false };
+    };
+    std::vector<Substitution> m_substitutions;
+};
+
+}
+
+#endif // slic3r_FindReplace_hpp_

src/libslic3r/GCode/GCodeProcessor.hpp

@@ -0,0 +1,802 @@
+#ifndef slic3r_GCodeProcessor_hpp_
+#define slic3r_GCodeProcessor_hpp_
+
+#include "libslic3r/GCodeReader.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/CustomGCode.hpp"
+
+#include <cstdint>
+#include <array>
+#include <vector>
+#include <string>
+#include <string_view>
+#include <optional>
+
+namespace Slic3r {
+
+  class Print;
+
+    enum class EMoveType : unsigned char
+    {
+        Noop,
+        Retract,
+        Unretract,
+        Seam,
+        Tool_change,
+        Color_change,
+        Pause_Print,
+        Custom_GCode,
+        Travel,
+        Wipe,
+        Extrude,
+        Count
+    };
+
+    struct PrintEstimatedStatistics
+    {
+        enum class ETimeMode : unsigned char
+        {
+            Normal,
+            Stealth,
+            Count
+        };
+
+        struct Mode
+        {
+            float time;
+            float travel_time;
+            std::vector<std::pair<CustomGCode::Type, std::pair<float, float>>> custom_gcode_times;
+            std::vector<std::pair<EMoveType, float>> moves_times;
+            std::vector<std::pair<GCodeExtrusionRole, float>> roles_times;
+            std::vector<float> layers_times;
+
+            void reset() {
+                time = 0.0f;
+                travel_time = 0.0f;
+                custom_gcode_times.clear();
+                moves_times.clear();
+                roles_times.clear();
+                layers_times.clear();
+            }
+        };
+
+        std::vector<double>                                 volumes_per_color_change;
+        std::map<size_t, double>                            volumes_per_extruder;
+        std::map<GCodeExtrusionRole, std::pair<double, double>> used_filaments_per_role;
+        std::map<size_t, double>                            cost_per_extruder;
+
+        std::array<Mode, static_cast<size_t>(ETimeMode::Count)> modes;
+
+        PrintEstimatedStatistics() { reset(); }
+
+        void reset() {
+            for (auto m : modes) {
+                m.reset();
+            }
+            volumes_per_color_change.clear();
+            volumes_per_extruder.clear();
+            used_filaments_per_role.clear();
+            cost_per_extruder.clear();
+        }
+    };
+
+    struct GCodeProcessorResult
+    {
+        struct SettingsIds
+        {
+            std::string print;
+            std::vector<std::string> filament;
+            std::string printer;
+
+            void reset() {
+                print.clear();
+                filament.clear();
+                printer.clear();
+            }
+        };
+
+        struct MoveVertex
+        {
+            unsigned int gcode_id{ 0 };
+            EMoveType type{ EMoveType::Noop };
+            GCodeExtrusionRole extrusion_role{ GCodeExtrusionRole::None };
+            unsigned char extruder_id{ 0 };
+            unsigned char cp_color_id{ 0 };
+            Vec3f position{ Vec3f::Zero() }; // mm
+            float delta_extruder{ 0.0f }; // mm
+            float feedrate{ 0.0f }; // mm/s
+            float width{ 0.0f }; // mm
+            float height{ 0.0f }; // mm
+            float mm3_per_mm{ 0.0f };
+            float fan_speed{ 0.0f }; // percentage
+            float temperature{ 0.0f }; // Celsius degrees
+            float time{ 0.0f }; // s
+            bool internal_only{ false };
+
+            float volumetric_rate() const { return feedrate * mm3_per_mm; }
+        };
+
+        std::string filename;
+        unsigned int id;
+        std::vector<MoveVertex> moves;
+        // Positions of ends of lines of the final G-code this->filename after TimeProcessor::post_process() finalizes the G-code.
+        std::vector<size_t> lines_ends;
+        Pointfs bed_shape;
+        float max_print_height;
+        SettingsIds settings_ids;
+        size_t extruders_count;
+        bool backtrace_enabled;
+        std::vector<std::string> extruder_colors;
+        std::vector<float> filament_diameters;
+        std::vector<float> filament_densities;
+        std::vector<float> filament_cost;
+
+        PrintEstimatedStatistics print_statistics;
+        std::vector<CustomGCode::Item> custom_gcode_per_print_z;
+        std::vector<std::pair<float, std::pair<size_t, size_t>>> spiral_vase_layers;
+
+#if ENABLE_GCODE_VIEWER_STATISTICS
+        int64_t time{ 0 };
+#endif // ENABLE_GCODE_VIEWER_STATISTICS
+        void reset();
+    };
+
+
+    class GCodeProcessor
+    {
+        static const std::vector<std::string> Reserved_Tags;
+
+    public:
+        enum class ETags : unsigned char
+        {
+            Role,
+            Wipe_Start,
+            Wipe_End,
+            Height,
+            Width,
+            Layer_Change,
+            Color_Change,
+            Pause_Print,
+            Custom_Code,
+            First_Line_M73_Placeholder,
+            Last_Line_M73_Placeholder,
+            Estimated_Printing_Time_Placeholder
+        };
+
+        static const std::string& reserved_tag(ETags tag) { return Reserved_Tags[static_cast<unsigned char>(tag)]; }
+        // checks the given gcode for reserved tags and returns true when finding the 1st (which is returned into found_tag) 
+        static bool contains_reserved_tag(const std::string& gcode, std::string& found_tag);
+        // checks the given gcode for reserved tags and returns true when finding any
+        // (the first max_count found tags are returned into found_tag)
+        static bool contains_reserved_tags(const std::string& gcode, unsigned int max_count, std::vector<std::string>& found_tag);
+
+        static const float Wipe_Width;
+        static const float Wipe_Height;
+
+#if ENABLE_GCODE_VIEWER_DATA_CHECKING
+        static const std::string Mm3_Per_Mm_Tag;
+#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
+
+    private:
+        using AxisCoords = std::array<double, 4>;
+        using ExtruderColors = std::vector<unsigned char>;
+        using ExtruderTemps = std::vector<float>;
+
+        enum class EUnits : unsigned char
+        {
+            Millimeters,
+            Inches
+        };
+
+        enum class EPositioningType : unsigned char
+        {
+            Absolute,
+            Relative
+        };
+
+        struct CachedPosition
+        {
+            AxisCoords position; // mm
+            float feedrate; // mm/s
+
+            void reset();
+        };
+
+        struct CpColor
+        {
+            unsigned char counter;
+            unsigned char current;
+
+            void reset();
+        };
+
+    public:
+        struct FeedrateProfile
+        {
+            float entry{ 0.0f }; // mm/s
+            float cruise{ 0.0f }; // mm/s
+            float exit{ 0.0f }; // mm/s
+        };
+
+        struct Trapezoid
+        {
+            float accelerate_until{ 0.0f }; // mm
+            float decelerate_after{ 0.0f }; // mm
+            float cruise_feedrate{ 0.0f }; // mm/sec
+
+            float acceleration_time(float entry_feedrate, float acceleration) const;
+            float cruise_time() const;
+            float deceleration_time(float distance, float acceleration) const;
+            float cruise_distance() const;
+        };
+
+        struct TimeBlock
+        {
+            struct Flags
+            {
+                bool recalculate{ false };
+                bool nominal_length{ false };
+            };
+
+            EMoveType move_type{ EMoveType::Noop };
+            GCodeExtrusionRole role{ GCodeExtrusionRole::None };
+            unsigned int g1_line_id{ 0 };
+            unsigned int layer_id{ 0 };
+            float distance{ 0.0f }; // mm
+            float acceleration{ 0.0f }; // mm/s^2
+            float max_entry_speed{ 0.0f }; // mm/s
+            float safe_feedrate{ 0.0f }; // mm/s
+            Flags flags;
+            FeedrateProfile feedrate_profile;
+            Trapezoid trapezoid;
+
+            // Calculates this block's trapezoid
+            void calculate_trapezoid();
+
+            float time() const;
+        };
+
+    private:
+        struct TimeMachine
+        {
+            struct State
+            {
+                float feedrate; // mm/s
+                float safe_feedrate; // mm/s
+                AxisCoords axis_feedrate; // mm/s
+                AxisCoords abs_axis_feedrate; // mm/s
+
+                void reset();
+            };
+
+            struct CustomGCodeTime
+            {
+                bool needed;
+                float cache;
+                std::vector<std::pair<CustomGCode::Type, float>> times;
+
+                void reset();
+            };
+
+            struct G1LinesCacheItem
+            {
+                unsigned int id;
+                float elapsed_time;
+            };
+
+            bool enabled;
+            float acceleration; // mm/s^2
+            // hard limit for the acceleration, to which the firmware will clamp.
+            float max_acceleration; // mm/s^2
+            float retract_acceleration; // mm/s^2
+            // hard limit for the acceleration, to which the firmware will clamp.
+            float max_retract_acceleration; // mm/s^2
+            float travel_acceleration; // mm/s^2
+            // hard limit for the travel acceleration, to which the firmware will clamp.
+            float max_travel_acceleration; // mm/s^2
+            float extrude_factor_override_percentage;
+            float time; // s
+            float travel_time; // s
+            struct StopTime
+            {
+                unsigned int g1_line_id;
+                float elapsed_time;
+            };
+            std::vector<StopTime> stop_times;
+            std::string line_m73_main_mask;
+            std::string line_m73_stop_mask;
+            State curr;
+            State prev;
+            CustomGCodeTime gcode_time;
+            std::vector<TimeBlock> blocks;
+            std::vector<G1LinesCacheItem> g1_times_cache;
+            std::array<float, static_cast<size_t>(EMoveType::Count)> moves_time;
+            std::array<float, static_cast<size_t>(GCodeExtrusionRole::Count)> roles_time;
+            std::vector<float> layers_time;
+
+            void reset();
+
+            // Simulates firmware st_synchronize() call
+            void simulate_st_synchronize(float additional_time = 0.0f);
+            void calculate_time(size_t keep_last_n_blocks = 0, float additional_time = 0.0f);
+        };
+
+        struct TimeProcessor
+        {
+            struct Planner
+            {
+                // Size of the firmware planner queue. The old 8-bit Marlins usually just managed 16 trapezoidal blocks.
+                // Let's be conservative and plan for newer boards with more memory.
+                static constexpr size_t queue_size = 64;
+                // The firmware recalculates last planner_queue_size trapezoidal blocks each time a new block is added.
+                // We are not simulating the firmware exactly, we calculate a sequence of blocks once a reasonable number of blocks accumulate.
+                static constexpr size_t refresh_threshold = queue_size * 4;
+            };
+
+            // extruder_id is currently used to correctly calculate filament load / unload times into the total print time.
+            // This is currently only really used by the MK3 MMU2:
+            // extruder_unloaded = true means no filament is loaded yet, all the filaments are parked in the MK3 MMU2 unit.
+            bool extruder_unloaded;
+            // whether or not to export post-process the gcode to export lines M73 in it
+            bool export_remaining_time_enabled;
+            // allow to skip the lines M201/M203/M204/M205 generated by GCode::print_machine_envelope() for non-Normal time estimate mode
+            bool machine_envelope_processing_enabled;
+            MachineEnvelopeConfig machine_limits;
+            // Additional load / unload times for a filament exchange sequence.
+            std::vector<float> filament_load_times;
+            std::vector<float> filament_unload_times;
+            std::array<TimeMachine, static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count)> machines;
+
+            void reset();
+
+            friend class GCodeProcessor;
+        };
+
+        struct UsedFilaments  // filaments per ColorChange
+        {
+            double color_change_cache;
+            std::vector<double> volumes_per_color_change;
+
+            double tool_change_cache;
+            std::map<size_t, double> volumes_per_extruder;
+
+            double role_cache;
+            std::map<GCodeExtrusionRole, std::pair<double, double>> filaments_per_role; // ExtrusionRole -> (m, g)
+
+            void reset();
+
+            void increase_caches(double extruded_volume, unsigned char extruder_id, double parking_volume, double extra_loading_volume);
+
+            void process_color_change_cache();
+            void process_extruder_cache(unsigned char extruder_id);
+            void process_role_cache(const GCodeProcessor* processor);
+            void process_caches(const GCodeProcessor* processor);
+       private:
+            std::vector<double> extruder_retracted_volume;
+            bool recent_toolchange = false;
+        };
+
+    public:
+        class SeamsDetector
+        {
+            bool m_active{ false };
+            std::optional<Vec3f> m_first_vertex;
+
+        public:
+            void activate(bool active) {
+                if (m_active != active) {
+                    m_active = active;
+                    if (m_active)
+                        m_first_vertex.reset();
+                }
+            }
+
+            std::optional<Vec3f> get_first_vertex() const { return m_first_vertex; }
+            void set_first_vertex(const Vec3f& vertex) { m_first_vertex = vertex; }
+
+            bool is_active() const { return m_active; }
+            bool has_first_vertex() const { return m_first_vertex.has_value(); }
+        };
+
+        // Helper class used to fix the z for color change, pause print and
+        // custom gcode markes
+        class OptionsZCorrector
+        {
+            GCodeProcessorResult& m_result;
+            std::optional<size_t> m_move_id;
+            std::optional<size_t> m_custom_gcode_per_print_z_id;
+
+        public:
+            explicit OptionsZCorrector(GCodeProcessorResult& result) : m_result(result) {
+            }
+
+            void set() {
+                m_move_id = m_result.moves.size() - 1;
+                m_custom_gcode_per_print_z_id = m_result.custom_gcode_per_print_z.size() - 1;
+            }
+
+            void update(float height) {
+                if (!m_move_id.has_value() || !m_custom_gcode_per_print_z_id.has_value())
+                    return;
+
+                const Vec3f position = m_result.moves.back().position;
+
+                GCodeProcessorResult::MoveVertex& move = m_result.moves.emplace_back(m_result.moves[*m_move_id]);
+                move.position = position;
+                move.height = height;
+                m_result.moves.erase(m_result.moves.begin() + *m_move_id);
+                m_result.custom_gcode_per_print_z[*m_custom_gcode_per_print_z_id].print_z = position.z();
+                reset();
+            }
+
+            void reset() {
+                m_move_id.reset();
+                m_custom_gcode_per_print_z_id.reset();
+            }
+        };
+
+#if ENABLE_GCODE_VIEWER_DATA_CHECKING
+        struct DataChecker
+        {
+            struct Error
+            {
+                float value;
+                float tag_value;
+                GCodeExtrusionRole role;
+            };
+
+            std::string type;
+            float threshold{ 0.01f };
+            float last_tag_value{ 0.0f };
+            unsigned int count{ 0 };
+            std::vector<Error> errors;
+
+            DataChecker(const std::string& type, float threshold)
+                : type(type), threshold(threshold)
+            {}
+
+            void update(float value, GCodeExtrusionRole role) {
+                if (role != GCodeExtrusionRole::Custom) {
+                    ++count;
+                    if (last_tag_value != 0.0f) {
+                        if (std::abs(value - last_tag_value) / last_tag_value > threshold)
+                            errors.push_back({ value, last_tag_value, role });
+                    }
+                }
+            }
+
+            void reset() { last_tag_value = 0.0f; errors.clear(); count = 0; }
+
+            std::pair<float, float> get_min() const {
+                float delta_min = FLT_MAX;
+                float perc_min = 0.0f;
+                for (const Error& e : errors) {
+                    if (delta_min > e.value - e.tag_value) {
+                        delta_min = e.value - e.tag_value;
+                        perc_min = 100.0f * delta_min / e.tag_value;
+                    }
+                }
+                return { delta_min, perc_min };
+            }
+
+            std::pair<float, float> get_max() const {
+                float delta_max = -FLT_MAX;
+                float perc_max = 0.0f;
+                for (const Error& e : errors) {
+                    if (delta_max < e.value - e.tag_value) {
+                        delta_max = e.value - e.tag_value;
+                        perc_max = 100.0f * delta_max / e.tag_value;
+                    }
+                }
+                return { delta_max, perc_max };
+            }
+
+            void output() const {
+                if (!errors.empty()) {
+                    std::cout << type << ":\n";
+                    std::cout << "Errors: " << errors.size() << " (" << 100.0f * float(errors.size()) / float(count) << "%)\n";
+                    auto [min, perc_min] = get_min();
+                    auto [max, perc_max] = get_max();
+                    std::cout << "min: " << min << "(" << perc_min << "%) - max: " << max << "(" << perc_max << "%)\n";
+                }
+            }
+        };
+#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
+
+    private:
+        GCodeReader m_parser;
+
+        EUnits m_units;
+        EPositioningType m_global_positioning_type;
+        EPositioningType m_e_local_positioning_type;
+        std::vector<Vec3f> m_extruder_offsets;
+        GCodeFlavor m_flavor;
+
+        AxisCoords m_start_position; // mm
+        AxisCoords m_end_position; // mm
+        AxisCoords m_saved_position; // mm
+        AxisCoords m_origin; // mm
+        CachedPosition m_cached_position;
+        bool m_wiping;
+
+        unsigned int m_line_id;
+        unsigned int m_last_line_id;
+        float m_feedrate; // mm/s
+        struct FeedMultiply
+        {
+            float current; // percentage
+            float saved;   // percentage
+
+            void reset() {
+                current = 1.0f;
+                saved = 1.0f;
+            }
+        };
+        FeedMultiply m_feed_multiply;
+        float m_width; // mm
+        float m_height; // mm
+        float m_forced_width; // mm
+        float m_forced_height; // mm
+        float m_mm3_per_mm;
+        float m_fan_speed; // percentage
+        float m_z_offset; // mm
+        GCodeExtrusionRole m_extrusion_role;
+        unsigned char m_extruder_id;
+        ExtruderColors m_extruder_colors;
+        ExtruderTemps m_extruder_temps;
+        ExtruderTemps m_extruder_temps_config;
+        ExtruderTemps m_extruder_temps_first_layer_config;
+        bool  m_is_XL_printer = false;
+        float m_parking_position;
+        float m_extra_loading_move;
+        float m_extruded_last_z;
+        float m_first_layer_height; // mm
+        unsigned int m_g1_line_id;
+        unsigned int m_layer_id;
+        CpColor m_cp_color;
+        bool m_use_volumetric_e;
+        SeamsDetector m_seams_detector;
+        OptionsZCorrector m_options_z_corrector;
+        size_t m_last_default_color_id;
+        bool m_spiral_vase_active;
+        float m_kissslicer_toolchange_time_correction;
+#if ENABLE_GCODE_VIEWER_STATISTICS
+        std::chrono::time_point<std::chrono::high_resolution_clock> m_start_time;
+#endif // ENABLE_GCODE_VIEWER_STATISTICS
+        bool m_single_extruder_multi_material;
+
+        enum class EProducer
+        {
+            Unknown,
+            QIDISlicer,
+            Slic3rPE,
+            Slic3r,
+            SuperSlicer,
+            Cura,
+            Simplify3D,
+            CraftWare,
+            ideaMaker,
+            KissSlicer,
+            BambuStudio
+        };
+
+        static const std::vector<std::pair<GCodeProcessor::EProducer, std::string>> Producers;
+        EProducer m_producer;
+
+        TimeProcessor m_time_processor;
+        UsedFilaments m_used_filaments;
+
+        Print* m_print{ nullptr };
+
+        GCodeProcessorResult m_result;
+        static unsigned int s_result_id;
+
+#if ENABLE_GCODE_VIEWER_DATA_CHECKING
+        DataChecker m_mm3_per_mm_compare{ "mm3_per_mm", 0.01f };
+        DataChecker m_height_compare{ "height", 0.01f };
+        DataChecker m_width_compare{ "width", 0.01f };
+#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
+
+    public:
+        GCodeProcessor();
+
+        void apply_config(const PrintConfig& config);
+        void set_print(Print* print) { m_print = print; }
+
+        void enable_stealth_time_estimator(bool enabled);
+        bool is_stealth_time_estimator_enabled() const {
+            return m_time_processor.machines[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Stealth)].enabled;
+        }
+        void enable_machine_envelope_processing(bool enabled) { m_time_processor.machine_envelope_processing_enabled = enabled; }
+        void reset();
+
+        const GCodeProcessorResult& get_result() const { return m_result; }
+        GCodeProcessorResult&& extract_result() { return std::move(m_result); }
+
+        // Load a G-code into a stand-alone G-code viewer.
+        // throws CanceledException through print->throw_if_canceled() (sent by the caller as callback).
+        void process_file(const std::string& filename, std::function<void()> cancel_callback = nullptr);
+
+        // Streaming interface, for processing G-codes just generated by QIDISlicer in a pipelined fashion.
+        void initialize(const std::string& filename);
+        void process_buffer(const std::string& buffer);
+        void finalize(bool post_process);
+
+        float get_time(PrintEstimatedStatistics::ETimeMode mode) const;
+        std::string get_time_dhm(PrintEstimatedStatistics::ETimeMode mode) const;
+        float get_travel_time(PrintEstimatedStatistics::ETimeMode mode) const;
+        std::string get_travel_time_dhm(PrintEstimatedStatistics::ETimeMode mode) const;
+        std::vector<std::pair<CustomGCode::Type, std::pair<float, float>>> get_custom_gcode_times(PrintEstimatedStatistics::ETimeMode mode, bool include_remaining) const;
+
+        std::vector<std::pair<EMoveType, float>> get_moves_time(PrintEstimatedStatistics::ETimeMode mode) const;
+        std::vector<std::pair<GCodeExtrusionRole, float>> get_roles_time(PrintEstimatedStatistics::ETimeMode mode) const;
+        std::vector<float> get_layers_time(PrintEstimatedStatistics::ETimeMode mode) const;
+
+    private:
+        void apply_config(const DynamicPrintConfig& config);
+        void apply_config_simplify3d(const std::string& filename);
+        void apply_config_superslicer(const std::string& filename);
+        void apply_config_kissslicer(const std::string& filename);
+        void process_gcode_line(const GCodeReader::GCodeLine& line, bool producers_enabled);
+
+        // Process tags embedded into comments
+        void process_tags(const std::string_view comment, bool producers_enabled);
+        bool process_producers_tags(const std::string_view comment);
+        bool process_qidislicer_tags(const std::string_view comment);
+        bool process_cura_tags(const std::string_view comment);
+        bool process_simplify3d_tags(const std::string_view comment);
+        bool process_craftware_tags(const std::string_view comment);
+        bool process_ideamaker_tags(const std::string_view comment);
+        bool process_kissslicer_tags(const std::string_view comment);
+        bool process_bambustudio_tags(const std::string_view comment);
+
+        bool detect_producer(const std::string_view comment);
+
+        // Move
+        void process_G0(const GCodeReader::GCodeLine& line);
+        void process_G1(const GCodeReader::GCodeLine& line);
+
+        // Arc Move
+        void process_G2_G3(const GCodeReader::GCodeLine& line, bool clockwise);
+
+        // Retract or Set tool temperature
+        void process_G10(const GCodeReader::GCodeLine& line);
+
+        // Unretract
+        void process_G11(const GCodeReader::GCodeLine& line);
+
+        // Set Units to Inches
+        void process_G20(const GCodeReader::GCodeLine& line);
+
+        // Set Units to Millimeters
+        void process_G21(const GCodeReader::GCodeLine& line);
+
+        // Firmware controlled Retract
+        void process_G22(const GCodeReader::GCodeLine& line);
+
+        // Firmware controlled Unretract
+        void process_G23(const GCodeReader::GCodeLine& line);
+
+        // Move to origin
+        void process_G28(const GCodeReader::GCodeLine& line);
+
+        // Save Current Position
+        void process_G60(const GCodeReader::GCodeLine& line);
+
+        // Return to Saved Position
+        void process_G61(const GCodeReader::GCodeLine& line);
+ 
+        // Set to Absolute Positioning
+        void process_G90(const GCodeReader::GCodeLine& line);
+
+        // Set to Relative Positioning
+        void process_G91(const GCodeReader::GCodeLine& line);
+
+        // Set Position
+        void process_G92(const GCodeReader::GCodeLine& line);
+
+        // Sleep or Conditional stop
+        void process_M1(const GCodeReader::GCodeLine& line);
+
+        // Set extruder to absolute mode
+        void process_M82(const GCodeReader::GCodeLine& line);
+
+        // Set extruder to relative mode
+        void process_M83(const GCodeReader::GCodeLine& line);
+
+        // Set extruder temperature
+        void process_M104(const GCodeReader::GCodeLine& line);
+
+        // Set fan speed
+        void process_M106(const GCodeReader::GCodeLine& line);
+
+        // Disable fan
+        void process_M107(const GCodeReader::GCodeLine& line);
+
+        // Set tool (Sailfish)
+        void process_M108(const GCodeReader::GCodeLine& line);
+
+        // Set extruder temperature and wait
+        void process_M109(const GCodeReader::GCodeLine& line);
+
+        // Recall stored home offsets
+        void process_M132(const GCodeReader::GCodeLine& line);
+
+        // Set tool (MakerWare)
+        void process_M135(const GCodeReader::GCodeLine& line);
+
+        // Set max printing acceleration
+        void process_M201(const GCodeReader::GCodeLine& line);
+
+        // Set maximum feedrate
+        void process_M203(const GCodeReader::GCodeLine& line);
+
+        // Set default acceleration
+        void process_M204(const GCodeReader::GCodeLine& line);
+
+        // Advanced settings
+        void process_M205(const GCodeReader::GCodeLine& line);
+
+        // Set Feedrate Percentage
+        void process_M220(const GCodeReader::GCodeLine& line);
+
+        // Set extrude factor override percentage
+        void process_M221(const GCodeReader::GCodeLine& line);
+
+        // Repetier: Store x, y and z position
+        void process_M401(const GCodeReader::GCodeLine& line);
+
+        // Repetier: Go to stored position
+        void process_M402(const GCodeReader::GCodeLine& line);
+
+        // Set allowable instantaneous speed change
+        void process_M566(const GCodeReader::GCodeLine& line);
+
+        // Unload the current filament into the MK3 MMU2 unit at the end of print.
+        void process_M702(const GCodeReader::GCodeLine& line);
+
+        // Processes T line (Select Tool)
+        void process_T(const GCodeReader::GCodeLine& line);
+        void process_T(const std::string_view command);
+
+        // post process the file with the given filename to:
+        // 1) add remaining time lines M73 and update moves' gcode ids accordingly
+        // 2) update used filament data
+        void post_process();
+
+        void store_move_vertex(EMoveType type, bool internal_only = false);
+
+        void set_extrusion_role(GCodeExtrusionRole role);
+
+        float minimum_feedrate(PrintEstimatedStatistics::ETimeMode mode, float feedrate) const;
+        float minimum_travel_feedrate(PrintEstimatedStatistics::ETimeMode mode, float feedrate) const;
+        float get_axis_max_feedrate(PrintEstimatedStatistics::ETimeMode mode, Axis axis) const;
+        float get_axis_max_acceleration(PrintEstimatedStatistics::ETimeMode mode, Axis axis) const;
+        float get_axis_max_jerk(PrintEstimatedStatistics::ETimeMode mode, Axis axis) const;
+        float get_retract_acceleration(PrintEstimatedStatistics::ETimeMode mode) const;
+        void  set_retract_acceleration(PrintEstimatedStatistics::ETimeMode mode, float value);
+        float get_acceleration(PrintEstimatedStatistics::ETimeMode mode) const;
+        void  set_acceleration(PrintEstimatedStatistics::ETimeMode mode, float value);
+        float get_travel_acceleration(PrintEstimatedStatistics::ETimeMode mode) const;
+        void  set_travel_acceleration(PrintEstimatedStatistics::ETimeMode mode, float value);
+        float get_filament_load_time(size_t extruder_id);
+        float get_filament_unload_time(size_t extruder_id);
+
+        void process_custom_gcode_time(CustomGCode::Type code);
+        void process_filaments(CustomGCode::Type code);
+
+        // Simulates firmware st_synchronize() call
+        void simulate_st_synchronize(float additional_time = 0.0f);
+
+        void update_estimated_times_stats();
+
+        double extract_absolute_position_on_axis(Axis axis, const GCodeReader::GCodeLine& line, double area_filament_cross_section);
+   };
+
+} /* namespace Slic3r */
+
+#endif /* slic3r_GCodeProcessor_hpp_ */
+
+

src/libslic3r/GCode/PostProcessor.cpp

@@ -0,0 +1,339 @@
+#include "PostProcessor.hpp"
+
+#include "libslic3r/Utils.hpp"
+#include "libslic3r/format.hpp"
+#include "libslic3r/I18N.hpp"
+
+#include <boost/algorithm/string.hpp>
+#include <boost/log/trivial.hpp>
+#include <boost/format.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/nowide/convert.hpp>
+#include <boost/nowide/cenv.hpp>
+#include <boost/nowide/fstream.hpp>
+
+#ifdef WIN32
+
+// The standard Windows includes.
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <Windows.h>
+#include <shellapi.h>
+
+// https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23/everyone-quotes-command-line-arguments-the-wrong-way/
+// This routine appends the given argument to a command line such that CommandLineToArgvW will return the argument string unchanged.
+// Arguments in a command line should be separated by spaces; this function does not add these spaces.
+// Argument    - Supplies the argument to encode.
+// CommandLine - Supplies the command line to which we append the encoded argument string.
+static void quote_argv_winapi(const std::wstring &argument, std::wstring &commmand_line_out)
+{
+	// Don't quote unless we actually need to do so --- hopefully avoid problems if programs won't parse quotes properly.
+	if (argument.empty() == false && argument.find_first_of(L" \t\n\v\"") == argument.npos)
+		commmand_line_out.append(argument);
+	else {
+		commmand_line_out.push_back(L'"');
+		for (auto it = argument.begin(); ; ++ it) {
+			unsigned number_backslashes = 0;
+			while (it != argument.end() && *it == L'\\') {
+				++ it;
+				++ number_backslashes;
+			}
+			if (it == argument.end()) {
+				// Escape all backslashes, but let the terminating double quotation mark we add below be interpreted as a metacharacter.
+				commmand_line_out.append(number_backslashes * 2, L'\\');
+				break;
+			} else if (*it == L'"') {
+				// Escape all backslashes and the following double quotation mark.
+				commmand_line_out.append(number_backslashes * 2 + 1, L'\\');
+				commmand_line_out.push_back(*it);
+			} else {
+				// Backslashes aren't special here.
+				commmand_line_out.append(number_backslashes, L'\\');
+				commmand_line_out.push_back(*it);
+			}
+		}
+		commmand_line_out.push_back(L'"');
+	}
+}
+
+static DWORD execute_process_winapi(const std::wstring &command_line)
+{
+    // Extract the current environment to be passed to the child process.
+	std::wstring envstr;
+	{
+		wchar_t *env = GetEnvironmentStrings();
+		assert(env != nullptr);
+		const wchar_t* var = env;
+		size_t totallen = 0;
+		size_t len;
+		while ((len = wcslen(var)) > 0) {
+			totallen += len + 1;
+			var += len + 1;
+		}
+		envstr = std::wstring(env, totallen);
+		FreeEnvironmentStrings(env);
+	}
+
+	STARTUPINFOW startup_info;
+	memset(&startup_info, 0, sizeof(startup_info));
+	startup_info.cb			 = sizeof(STARTUPINFO);
+#if 0
+	startup_info.dwFlags	 = STARTF_USESHOWWINDOW;
+	startup_info.wShowWindow = SW_HIDE;
+#endif
+	PROCESS_INFORMATION process_info;
+	if (! ::CreateProcessW(
+            nullptr /* lpApplicationName */, (LPWSTR)command_line.c_str(), nullptr /* lpProcessAttributes */, nullptr /* lpThreadAttributes */, false /* bInheritHandles */,
+			CREATE_UNICODE_ENVIRONMENT /* | CREATE_NEW_CONSOLE */ /* dwCreationFlags */, (LPVOID)envstr.c_str(), nullptr /* lpCurrentDirectory */, &startup_info, &process_info))
+		throw Slic3r::RuntimeError(std::string("Failed starting the script ") + boost::nowide::narrow(command_line) + ", Win32 error: " + std::to_string(int(::GetLastError())));
+	::WaitForSingleObject(process_info.hProcess, INFINITE);
+	ULONG rc = 0;
+	::GetExitCodeProcess(process_info.hProcess, &rc);
+	::CloseHandle(process_info.hThread);
+	::CloseHandle(process_info.hProcess);
+	return rc;
+}
+
+// Run the script. If it is a perl script, run it through the bundled perl interpreter.
+// If it is a batch file, run it through the cmd.exe.
+// Otherwise run it directly.
+static int run_script(const std::string &script, const std::string &gcode, std::string &/*std_err*/)
+{
+    // Unpack the argument list provided by the user.
+    int     nArgs;
+    LPWSTR *szArglist = CommandLineToArgvW(boost::nowide::widen(script).c_str(), &nArgs);
+    if (szArglist == nullptr || nArgs <= 0) {
+        // CommandLineToArgvW failed. Maybe the command line escapment is invalid?
+		throw Slic3r::RuntimeError(std::string("Post processing script ") + script + " on file " + gcode + " failed. CommandLineToArgvW() refused to parse the command line path.");
+    }
+
+    std::wstring command_line;
+    std::wstring command = szArglist[0];
+	if (! boost::filesystem::exists(boost::filesystem::path(command)))
+		throw Slic3r::RuntimeError(std::string("The configured post-processing script does not exist: ") + boost::nowide::narrow(command));
+    if (boost::iends_with(command, L".pl")) {
+        // This is a perl script. Run it through the perl interpreter.
+        // The current process may be slic3r.exe or slic3r-console.exe.
+        // Find the path of the process:
+        wchar_t wpath_exe[_MAX_PATH + 1];
+        ::GetModuleFileNameW(nullptr, wpath_exe, _MAX_PATH);
+        boost::filesystem::path path_exe(wpath_exe);
+        boost::filesystem::path path_perl = path_exe.parent_path() / "perl" / "perl.exe";
+        if (! boost::filesystem::exists(path_perl)) {
+			LocalFree(szArglist);
+			throw Slic3r::RuntimeError(std::string("Perl interpreter ") + path_perl.string() + " does not exist.");
+        }
+        // Replace it with the current perl interpreter.
+        quote_argv_winapi(boost::nowide::widen(path_perl.string()), command_line);
+        command_line += L" ";
+    } else if (boost::iends_with(command, ".bat")) {
+        // Run a batch file through the command line interpreter.
+        command_line = L"cmd.exe /C ";
+    }
+
+    for (int i = 0; i < nArgs; ++ i) {
+        quote_argv_winapi(szArglist[i], command_line);
+        command_line += L" ";
+    }
+    LocalFree(szArglist);
+	quote_argv_winapi(boost::nowide::widen(gcode), command_line);
+    return (int)execute_process_winapi(command_line);
+}
+
+#else
+    // POSIX
+
+#include <cstdlib>   // getenv()
+#include <sstream>
+#include <boost/process.hpp>
+
+namespace process = boost::process;
+
+static int run_script(const std::string &script, const std::string &gcode, std::string &std_err)
+{
+    // Try to obtain user's default shell
+    const char *shell = ::getenv("SHELL");
+    if (shell == nullptr) { shell = "/bin/sh"; }
+
+    // Quote and escape the gcode path argument
+    std::string command { script };
+    command.append(" '");
+    for (char c : gcode) {
+        if (c == '\'') { command.append("'\\''"); }
+        else { command.push_back(c); }
+    }
+    command.push_back('\'');
+
+    BOOST_LOG_TRIVIAL(debug) << boost::format("Executing script, shell: %1%, command: %2%") % shell % command;
+
+    process::ipstream istd_err;
+    process::child child(shell, "-c", command, process::std_err > istd_err);
+
+    std_err.clear();
+    std::string line;
+
+    while (child.running() && std::getline(istd_err, line)) {
+        std_err.append(line);
+        std_err.push_back('\n');
+    }
+
+    child.wait();
+    return child.exit_code();
+}
+
+#endif
+
+namespace Slic3r {
+
+// Run post processing script / scripts if defined.
+// Returns true if a post-processing script was executed.
+// Returns false if no post-processing script was defined.
+// Throws an exception on error.
+// host is one of "File", "QIDILink", "Repetier", "SL1Host", "OctoPrint", "FlashAir", "Duet", "AstroBox" ...
+// For a "File" target, a temp file will be created for src_path by adding a ".pp" suffix and src_path will be updated.
+// In that case the caller is responsible to delete the temp file created.
+// output_name is the final name of the G-code on SD card or when uploaded to QIDILink or OctoPrint.
+// If uploading to QIDILink or OctoPrint, then the file will be renamed to output_name first on the target host.
+// The post-processing script may change the output_name.
+bool run_post_process_scripts(std::string &src_path, bool make_copy, const std::string &host, std::string &output_name, const DynamicPrintConfig &config)
+{
+    const auto *post_process = config.opt<ConfigOptionStrings>("post_process");
+    if (// likely running in SLA mode
+        post_process == nullptr || 
+        // no post-processing script
+        post_process->values.empty())
+        return false;
+
+    std::string path;
+    if (make_copy) {
+        // Don't run the post-processing script on the input file, it will be memory mapped by the G-code viewer.
+        // Make a copy.
+        path = src_path + ".pp";
+        // First delete an old file if it exists.
+        try {
+            if (boost::filesystem::exists(path))
+                boost::filesystem::remove(path);
+        } catch (const std::exception &err) {
+            BOOST_LOG_TRIVIAL(error) << Slic3r::format("Failed deleting an old temporary file %1% before running a post-processing script: %2%", path, err.what());
+        }
+        // Second make a copy.
+        std::string error_message;
+        if (copy_file(src_path, path, error_message, false) != SUCCESS)
+            throw Slic3r::RuntimeError(Slic3r::format("Failed making a temporary copy of G-code file %1% before running a post-processing script: %2%", src_path, error_message));
+    } else {
+        // Don't make a copy of the G-code before running the post-processing script.
+        path = src_path;
+    }
+
+    auto delete_copy = [&path, &src_path, make_copy]() {
+        if (make_copy)
+            try {
+                if (boost::filesystem::exists(path))
+                    boost::filesystem::remove(path);
+            } catch (const std::exception &err) {
+                BOOST_LOG_TRIVIAL(error) << Slic3r::format("Failed deleting a temporary copy %1% of a G-code file %2% : %3%", path, src_path, err.what());
+            }
+    };
+
+    auto gcode_file = boost::filesystem::path(path);
+    if (! boost::filesystem::exists(gcode_file))
+        throw Slic3r::RuntimeError(std::string("Post-processor can't find exported gcode file"));
+
+    // Store print configuration into environment variables.
+    config.setenv_();
+    // Let the post-processing script know the target host ("File", "QIDILink", "Repetier", "SL1Host", "OctoPrint", "FlashAir", "Duet", "AstroBox" ...)
+    boost::nowide::setenv("SLIC3R_PP_HOST", host.c_str(), 1);
+    // Let the post-processing script know the final file name. For "File" host, it is a full path of the target file name and its location, for example pointing to an SD card.
+    // For "QIDILink" or "OctoPrint", it is a file name optionally with a directory on the target host.
+    boost::nowide::setenv("SLIC3R_PP_OUTPUT_NAME", output_name.c_str(), 1);
+
+    // Path to an optional file that the post-processing script may create and populate it with a single line containing the output_name replacement.
+    std::string path_output_name = path + ".output_name";
+    auto remove_output_name_file = [&path_output_name, &src_path]() {
+        try {
+            if (boost::filesystem::exists(path_output_name))
+                boost::filesystem::remove(path_output_name);
+        } catch (const std::exception &err) {
+            BOOST_LOG_TRIVIAL(error) << Slic3r::format("Failed deleting a file %1% carrying the final name / path of a G-code file %2%: %3%", path_output_name, src_path, err.what());
+        }
+    };
+    // Remove possible stalled path_output_name of the previous run.
+    remove_output_name_file();
+
+    try {
+        for (const std::string &scripts : post_process->values) {
+    		std::vector<std::string> lines;
+    		boost::split(lines, scripts, boost::is_any_of("\r\n"));
+            for (std::string script : lines) {
+                // Ignore empty post processing script lines.
+                boost::trim(script);
+                if (script.empty())
+                    continue;
+                BOOST_LOG_TRIVIAL(info) << "Executing script " << script << " on file " << path;
+                std::string std_err;
+                const int result = run_script(script, gcode_file.string(), std_err);
+                if (result != 0) {
+                    const std::string msg = std_err.empty() ? (boost::format("Post-processing script %1% on file %2% failed.\nError code: %3%") % script % path % result).str()
+                        : (boost::format("Post-processing script %1% on file %2% failed.\nError code: %3%\nOutput:\n%4%") % script % path % result % std_err).str();
+                    BOOST_LOG_TRIVIAL(error) << msg;
+                    delete_copy();
+                    throw Slic3r::RuntimeError(msg);
+                }
+                if (! boost::filesystem::exists(gcode_file)) {
+                    const std::string msg = (boost::format(_u8L(
+                        "Post-processing script %1% failed.\n\n"
+                        "The post-processing script is expected to change the G-code file %2% in place, but the G-code file was deleted and likely saved under a new name.\n"
+                        "Please adjust the post-processing script to change the G-code in place and consult the manual on how to optionally rename the post-processed G-code file.\n"))
+                        % script % path).str();
+                    BOOST_LOG_TRIVIAL(error) << msg;
+                    throw Slic3r::RuntimeError(msg);
+                }
+            }
+        }
+        if (boost::filesystem::exists(path_output_name)) {
+            try {
+                // Read a single line from path_output_name, which should contain the new output name of the post-processed G-code.
+                boost::nowide::fstream f;
+                f.open(path_output_name, std::ios::in);
+                std::string new_output_name;
+                std::getline(f, new_output_name);
+                f.close();
+
+                if (host == "File") {
+                    namespace fs = boost::filesystem;
+                    fs::path op(new_output_name);
+                    if (op.is_relative() && op.has_filename() && op.parent_path().empty()) {
+                        // Is this just a filename? Make it an absolute path.
+                        auto outpath = fs::path(output_name).parent_path();
+                        outpath /= op.string();
+                        new_output_name = outpath.string();
+                    }
+                    else {
+                        if (! op.is_absolute() || ! op.has_filename())
+                            throw Slic3r::RuntimeError("Unable to parse desired new path from output name file");
+                    }
+                    if (! fs::exists(fs::path(new_output_name).parent_path()))
+                        throw Slic3r::RuntimeError(Slic3r::format("Output directory does not exist: %1%",
+                                                                  fs::path(new_output_name).parent_path().string()));
+                }
+
+                BOOST_LOG_TRIVIAL(trace) << "Post-processing script changed the file name from " << output_name << " to " << new_output_name;
+                output_name = new_output_name;
+            } catch (const std::exception &err) {
+                throw Slic3r::RuntimeError(Slic3r::format("run_post_process_scripts: Failed reading a file %1% "
+                                                          "carrying the final name / path of a G-code file: %2%",
+                                                          path_output_name, err.what()));
+            }
+            remove_output_name_file();
+        }
+    } catch (...) {
+        remove_output_name_file();
+        delete_copy();
+        throw;
+    }
+
+    src_path = std::move(path);
+    return true;
+}
+
+} // namespace Slic3r

src/libslic3r/GCode/PostProcessor.hpp

@@ -0,0 +1,31 @@
+#ifndef slic3r_GCode_PostProcessor_hpp_
+#define slic3r_GCode_PostProcessor_hpp_
+
+#include <string>
+
+#include "../libslic3r.h"
+#include "../PrintConfig.hpp"
+
+namespace Slic3r {
+
+// Run post processing script / scripts if defined.
+// Returns true if a post-processing script was executed.
+// Returns false if no post-processing script was defined.
+// Throws an exception on error.
+// host is one of "File", "QIDILink", "Repetier", "SL1Host", "OctoPrint", "FlashAir", "Duet", "AstroBox" ...
+// If make_copy, then a temp file will be created for src_path by adding a ".pp" suffix and src_path will be updated.
+// In that case the caller is responsible to delete the temp file created.
+// output_name is the final name of the G-code on SD card or when uploaded to QIDILink or OctoPrint.
+// If uploading to QIDILink or OctoPrint, then the file will be renamed to output_name first on the target host.
+// The post-processing script may change the output_name.
+extern bool run_post_process_scripts(std::string &src_path, bool make_copy, const std::string &host, std::string &output_name, const DynamicPrintConfig &config);
+
+inline bool run_post_process_scripts(std::string &src_path, const DynamicPrintConfig &config)
+{
+	std::string src_path_name = src_path;
+	return run_post_process_scripts(src_path, false, "File", src_path_name, config);
+}
+
+} // namespace Slic3r
+
+#endif /* slic3r_GCode_PostProcessor_hpp_ */

src/libslic3r/GCode/PressureEqualizer.cpp

@@ -0,0 +1,732 @@
+#include <memory.h>
+#include <cstring>
+#include <cfloat>
+
+#include "../libslic3r.h"
+#include "../PrintConfig.hpp"
+#include "../LocalesUtils.hpp"
+#include "../GCode.hpp"
+
+#include "PressureEqualizer.hpp"
+#include "fast_float/fast_float.h"
+#include "GCodeWriter.hpp"
+
+namespace Slic3r {
+
+static const std::string EXTRUSION_ROLE_TAG = ";_EXTRUSION_ROLE:";
+static const std::string EXTRUDE_END_TAG = ";_EXTRUDE_END";
+static const std::string EXTRUDE_SET_SPEED_TAG = ";_EXTRUDE_SET_SPEED";
+static const std::string EXTERNAL_PERIMETER_TAG = ";_EXTERNAL_PERIMETER";
+
+// Maximum segment length to split a long segment if the initial and the final flow rate differ.
+// Smaller value means a smoother transition between two different flow rates.
+static constexpr float max_segment_length = 5.f;
+
+// For how many GCode lines back will adjust a flow rate from the latest line.
+// Bigger values affect the GCode export speed a lot, and smaller values could
+// affect how distant will be propagated a flow rate adjustment.
+static constexpr int max_look_back_limit = 128;
+
+PressureEqualizer::PressureEqualizer(const Slic3r::GCodeConfig &config) : m_use_relative_e_distances(config.use_relative_e_distances.value)
+{
+    // Preallocate some data, so that output_buffer.data() will return an empty string.
+    output_buffer.assign(32, 0);
+    output_buffer_length      = 0;
+    output_buffer_prev_length = 0;
+
+    m_current_extruder = 0;
+    // Zero the position of the XYZE axes + the current feed
+    memset(m_current_pos, 0, sizeof(float) * 5);
+    m_current_extrusion_role = GCodeExtrusionRole::None;
+    // Expect the first command to fill the nozzle (deretract).
+    m_retracted = true;
+
+    // Calculate filamet crossections for the multiple extruders.
+    m_filament_crossections.clear();
+    for (double r : config.filament_diameter.values) {
+        double a = 0.25f * M_PI * r * r;
+        m_filament_crossections.push_back(float(a));
+    }
+
+    // Volumetric rate of a 0.45mm x 0.2mm extrusion at 60mm/s XY movement: 0.45*0.2*60*60=5.4*60 = 324 mm^3/min
+    // Volumetric rate of a 0.45mm x 0.2mm extrusion at 20mm/s XY movement: 0.45*0.2*20*60=1.8*60 = 108 mm^3/min
+    // Slope of the volumetric rate, changing from 20mm/s to 60mm/s over 2 seconds: (5.4-1.8)*60*60/2=60*60*1.8 = 6480 mm^3/min^2 = 1.8 mm^3/s^2
+    m_max_volumetric_extrusion_rate_slope_positive = float(config.max_volumetric_extrusion_rate_slope_positive.value) * 60.f * 60.f;
+    m_max_volumetric_extrusion_rate_slope_negative = float(config.max_volumetric_extrusion_rate_slope_negative.value) * 60.f * 60.f;
+
+    for (ExtrusionRateSlope &extrusion_rate_slope : m_max_volumetric_extrusion_rate_slopes) {
+        extrusion_rate_slope.negative = m_max_volumetric_extrusion_rate_slope_negative;
+        extrusion_rate_slope.positive = m_max_volumetric_extrusion_rate_slope_positive;
+    }
+
+    // Don't regulate the pressure before and after gap-fill and ironing.
+    for (const GCodeExtrusionRole er : {GCodeExtrusionRole::GapFill, GCodeExtrusionRole::Ironing}) {
+        m_max_volumetric_extrusion_rate_slopes[size_t(er)].negative = 0;
+        m_max_volumetric_extrusion_rate_slopes[size_t(er)].positive = 0;
+    }
+
+    opened_extrude_set_speed_block = false;
+
+#ifdef PRESSURE_EQUALIZER_STATISTIC
+    m_stat.reset();
+#endif
+
+#ifdef PRESSURE_EQUALIZER_DEBUG
+    line_idx = 0;
+#endif
+}
+
+void PressureEqualizer::process_layer(const std::string &gcode)
+{
+    if (!gcode.empty()) {
+        const char *gcode_begin = gcode.c_str();
+        while (*gcode_begin != 0) {
+            // Find end of the line.
+            const char *gcode_end = gcode_begin;
+            // Slic3r always generates end of lines in a Unix style.
+            for (; *gcode_end != 0 && *gcode_end != '\n'; ++gcode_end);
+
+            m_gcode_lines.emplace_back();
+            if (!this->process_line(gcode_begin, gcode_end, m_gcode_lines.back())) {
+                // The line has to be forgotten. It contains comment marks, which shall be filtered out of the target g-code.
+                m_gcode_lines.pop_back();
+            }
+            gcode_begin = gcode_end;
+            if (*gcode_begin == '\n')
+                ++gcode_begin;
+        }
+        assert(!this->opened_extrude_set_speed_block);
+    }
+}
+
+LayerResult PressureEqualizer::process_layer(LayerResult &&input)
+{
+    const bool   is_first_layer       = m_layer_results.empty();
+    const size_t next_layer_first_idx = m_gcode_lines.size();
+
+    if (!input.nop_layer_result) {
+        this->process_layer(input.gcode);
+        input.gcode.clear(); // GCode is already processed, so it isn't needed to store it.
+        m_layer_results.emplace(new LayerResult(input));
+    }
+
+    if (is_first_layer) // Buffer previous input result and output NOP.
+        return LayerResult::make_nop_layer_result();
+
+    // Export previous layer.
+    LayerResult *prev_layer_result = m_layer_results.front();
+    m_layer_results.pop();
+
+    output_buffer_length      = 0;
+    output_buffer_prev_length = 0;
+    for (size_t line_idx = 0; line_idx < next_layer_first_idx; ++line_idx)
+        output_gcode_line(line_idx);
+    m_gcode_lines.erase(m_gcode_lines.begin(), m_gcode_lines.begin() + int(next_layer_first_idx));
+
+    if (output_buffer_length > 0)
+        prev_layer_result->gcode = std::string(output_buffer.data());
+
+    assert(!input.nop_layer_result || m_layer_results.empty());
+    LayerResult out = *prev_layer_result;
+    delete prev_layer_result;
+    return out;
+}
+
+// Is a white space?
+static inline bool is_ws(const char c) { return c == ' ' || c == '\t'; }
+// Is it an end of line? Consider a comment to be an end of line as well.
+static inline bool is_eol(const char c) { return c == 0 || c == '\r' || c == '\n' || c == ';'; }
+// Is it a white space or end of line?
+static inline bool is_ws_or_eol(const char c) { return is_ws(c) || is_eol(c); }
+
+// Eat whitespaces.
+static void eatws(const char *&line)
+{
+    while (is_ws(*line)) 
+        ++ line;
+}
+
+// Parse an int starting at the current position of a line.
+// If succeeded, the line pointer is advanced.
+static inline int parse_int(const char *&line)
+{
+    char *endptr = nullptr;
+    long result = strtol(line, &endptr, 10);
+    if (endptr == nullptr || !is_ws_or_eol(*endptr))
+        throw Slic3r::InvalidArgument("PressureEqualizer: Error parsing an int");
+    line = endptr;
+    return int(result);
+}
+
+float string_to_float_decimal_point(const char *line, const size_t str_len, size_t* pos)
+{
+    float out;
+    size_t p = fast_float::from_chars(line, line + str_len, out).ptr - line;
+    if (pos)
+        *pos = p;
+    return out;
+}
+
+// Parse an int starting at the current position of a line.
+// If succeeded, the line pointer is advanced.
+static inline float parse_float(const char *&line, const size_t line_length)
+{
+    size_t endptr = 0;
+    auto   result = string_to_float_decimal_point(line, line_length, &endptr);
+    if (endptr == 0 || !is_ws_or_eol(*(line + endptr)))
+        throw Slic3r::RuntimeError("PressureEqualizer: Error parsing a float");
+    line = line + endptr;
+    return result;
+}
+
+bool PressureEqualizer::process_line(const char *line, const char *line_end, GCodeLine &buf)
+{
+    const size_t len = line_end - line;
+    if (strncmp(line, EXTRUSION_ROLE_TAG.data(), EXTRUSION_ROLE_TAG.length()) == 0) {
+        line += EXTRUSION_ROLE_TAG.length();
+        int role = atoi(line);
+        m_current_extrusion_role = GCodeExtrusionRole(role);
+#ifdef PRESSURE_EQUALIZER_DEBUG
+        ++line_idx;
+#endif
+        return false;
+    }
+
+    // Set the type, copy the line to the buffer.
+    buf.type = GCODELINETYPE_OTHER;
+    buf.modified = false;
+    if (buf.raw.size() < len + 1)
+        buf.raw.assign(line, line + len + 1);
+    else
+        memcpy(buf.raw.data(), line, len);
+    buf.raw[len] = 0;
+    buf.raw_length = len;
+
+    memcpy(buf.pos_start, m_current_pos, sizeof(float)*5);
+    memcpy(buf.pos_end, m_current_pos, sizeof(float)*5);
+    memset(buf.pos_provided, 0, 5);
+
+    buf.volumetric_extrusion_rate = 0.f;
+    buf.volumetric_extrusion_rate_start = 0.f;
+    buf.volumetric_extrusion_rate_end = 0.f;
+    buf.max_volumetric_extrusion_rate_slope_positive = 0.f;
+    buf.max_volumetric_extrusion_rate_slope_negative = 0.f;
+	buf.extrusion_role = m_current_extrusion_role;
+
+    std::string str_line(line, line_end);
+    const bool found_extrude_set_speed_tag = boost::contains(str_line, EXTRUDE_SET_SPEED_TAG);
+    const bool found_extrude_end_tag = boost::contains(str_line, EXTRUDE_END_TAG);
+    assert(!found_extrude_set_speed_tag || !found_extrude_end_tag);
+
+    if (found_extrude_set_speed_tag)
+        this->opened_extrude_set_speed_block = true;
+    else if (found_extrude_end_tag)
+        this->opened_extrude_set_speed_block = false;
+
+    // Parse the G-code line, store the result into the buf.
+    switch (toupper(*line ++)) {
+    case 'G': {
+        int gcode = -1;
+        try {
+            gcode = parse_int(line);
+        } catch (Slic3r::InvalidArgument &) {
+            // Ignore invalid GCodes.
+            eatws(line);
+            break;
+        }
+
+        assert(gcode != -1);
+        eatws(line);
+        switch (gcode) {
+        case 0:
+        case 1:
+        {
+            // G0, G1: A FFF 3D printer does not make a difference between the two.
+            buf.adjustable_flow = this->opened_extrude_set_speed_block;
+            buf.extrude_set_speed_tag = found_extrude_set_speed_tag;
+            buf.extrude_end_tag = found_extrude_end_tag;
+            float new_pos[5];
+            memcpy(new_pos, m_current_pos, sizeof(float)*5);
+            bool  changed[5] = { false, false, false, false, false };
+            while (!is_eol(*line)) {
+                const char axis = toupper(*line++);
+                int  i = -1;
+                switch (axis) {
+                case 'X':
+                case 'Y':
+                case 'Z':
+                    i = axis - 'X';
+                    break;
+                case 'E':
+                    i = 3;
+                    break;
+                case 'F':
+                    i = 4;
+                    break;
+                default:
+                    break;
+                }
+                if (i != -1) {
+                    buf.pos_provided[i] = true;
+                    new_pos[i] = parse_float(line, line_end - line);
+                    if (i == 3 && m_use_relative_e_distances)
+                        new_pos[i] += m_current_pos[i];
+                    changed[i] = new_pos[i] != m_current_pos[i];
+                    eatws(line);
+                }
+            }
+            if (changed[3]) {
+                // Extrusion, retract or unretract.
+                float diff = new_pos[3] - m_current_pos[3];
+                if (diff < 0) {
+                    buf.type = GCODELINETYPE_RETRACT;
+                    m_retracted = true;
+                } else if (! changed[0] && ! changed[1] && ! changed[2]) {
+                    // assert(m_retracted);
+                    buf.type = GCODELINETYPE_UNRETRACT;
+                    m_retracted = false;
+                } else {
+                    assert(changed[0] || changed[1]);
+                    // Moving in XY plane.
+                    buf.type = GCODELINETYPE_EXTRUDE;
+                    // Calculate the volumetric extrusion rate.
+                    float diff[4];
+                    for (size_t i = 0; i < 4; ++ i)
+                        diff[i] = new_pos[i] - m_current_pos[i];
+                    // volumetric extrusion rate = A_filament * F_xyz * L_e / L_xyz [mm^3/min]
+                    float len2 = diff[0]*diff[0]+diff[1]*diff[1]+diff[2]*diff[2];
+                    float rate = m_filament_crossections[m_current_extruder] * new_pos[4] * sqrt((diff[3]*diff[3])/len2);
+                    buf.volumetric_extrusion_rate       = rate;
+                    buf.volumetric_extrusion_rate_start = rate;
+                    buf.volumetric_extrusion_rate_end   = rate;
+
+#ifdef PRESSURE_EQUALIZER_STATISTIC
+                    m_stat.update(rate, sqrt(len2));
+#endif
+#ifdef PRESSURE_EQUALIZER_DEBUG
+                    if (rate < 40.f) {
+                        printf("Extremely low flow rate: %f. Line %d, Length: %f, extrusion: %f Old position: (%f, %f, %f), new position: (%f, %f, %f)\n",
+                               rate, int(line_idx), sqrt(len2), sqrt((diff[3] * diff[3]) / len2), m_current_pos[0], m_current_pos[1], m_current_pos[2],
+                               new_pos[0], new_pos[1], new_pos[2]);
+                    }
+#endif
+                }
+            } else if (changed[0] || changed[1] || changed[2]) {
+                // Moving without extrusion.
+                buf.type = GCODELINETYPE_MOVE;
+            }
+            memcpy(m_current_pos, new_pos, sizeof(float) * 5);
+            break;
+        }
+        case 92: 
+        {
+            // G92 : Set Position
+            // Set a logical coordinate position to a new value without actually moving the machine motors.
+            // Which axes to set?
+            while (!is_eol(*line)) {
+                const char axis = toupper(*line++);
+                switch (axis) {
+                case 'X':
+                case 'Y':
+                case 'Z':
+                    m_current_pos[axis - 'X'] = (!is_ws_or_eol(*line)) ? parse_float(line, line_end - line) : 0.f;
+                    break;
+                case 'E':
+                    m_current_pos[3] = (!is_ws_or_eol(*line)) ? parse_float(line, line_end - line) : 0.f;
+                    break;
+                default:
+                    break;
+                }
+                eatws(line);
+            }
+            break;
+        }
+        case 10:
+        case 22:
+            // Firmware retract.
+            buf.type = GCODELINETYPE_RETRACT;
+            m_retracted = true;
+            break;
+        case 11:
+        case 23:
+            // Firmware unretract.
+            buf.type = GCODELINETYPE_UNRETRACT;
+            m_retracted = false;
+            break;
+        default:
+            // Ignore the rest.
+        break;
+        }
+        break;
+    }
+    case 'M': {
+        eatws(line);
+        // Ignore the rest of the M-codes.
+        break;
+    }
+    case 'T':
+    {
+        // Activate an extruder head.
+        int new_extruder = -1;
+        try {
+            new_extruder = parse_int(line);
+        } catch (Slic3r::InvalidArgument &) {
+            // Ignore invalid GCodes starting with T.
+            eatws(line);
+            break;
+        }
+        assert(new_extruder != -1);
+
+        if (new_extruder != int(m_current_extruder)) {
+            m_current_extruder = new_extruder;
+            m_retracted = true;
+            buf.type = GCODELINETYPE_TOOL_CHANGE;
+        } else {
+            buf.type = GCODELINETYPE_NOOP;
+        }
+        break;
+    }
+    }
+
+    buf.extruder_id = m_current_extruder;
+    memcpy(buf.pos_end, m_current_pos, sizeof(float)*5);
+
+    adjust_volumetric_rate();
+#ifdef PRESSURE_EQUALIZER_DEBUG
+    ++line_idx;
+#endif
+    return true;
+}
+
+void PressureEqualizer::output_gcode_line(const size_t line_idx)
+{
+    GCodeLine &line = m_gcode_lines[line_idx];
+    if (!line.modified) {
+        push_to_output(line.raw.data(), line.raw_length, true);
+        return;
+    }
+
+    // The line was modified.
+    // Find the comment.
+    const char *comment = line.raw.data();
+    while (*comment != ';' && *comment != 0) ++comment;
+    if (*comment != ';')
+        comment = nullptr;
+
+    // Emit the line with lowered extrusion rates.
+    float l = line.dist_xyz();
+    if (auto nSegments = size_t(ceil(l / max_segment_length)); nSegments == 1) { // Just update this segment.
+        push_line_to_output(line_idx, line.feedrate() * line.volumetric_correction_avg(), comment);
+    } else {
+        bool accelerating = line.volumetric_extrusion_rate_start < line.volumetric_extrusion_rate_end;
+        // Update the initial and final feed rate values.
+        line.pos_start[4] = line.volumetric_extrusion_rate_start * line.pos_end[4] / line.volumetric_extrusion_rate;
+        line.pos_end  [4] = line.volumetric_extrusion_rate_end   * line.pos_end[4] / line.volumetric_extrusion_rate;
+        float feed_avg = 0.5f * (line.pos_start[4] + line.pos_end[4]);
+        // Limiting volumetric extrusion rate slope for this segment.
+        float max_volumetric_extrusion_rate_slope = accelerating ? line.max_volumetric_extrusion_rate_slope_positive :
+                                                                   line.max_volumetric_extrusion_rate_slope_negative;
+        // Total time for the segment, corrected for the possibly lowered volumetric feed rate,
+        // if accelerating / decelerating over the complete segment.
+        float t_total = line.dist_xyz() / feed_avg;
+        // Time of the acceleration / deceleration part of the segment, if accelerating / decelerating
+        // with the maximum volumetric extrusion rate slope.
+        float t_acc    = 0.5f * (line.volumetric_extrusion_rate_start + line.volumetric_extrusion_rate_end) / max_volumetric_extrusion_rate_slope;
+        float l_acc    = l;
+        float l_steady = 0.f;
+        if (t_acc < t_total) {
+            // One may achieve higher print speeds if part of the segment is not speed limited.
+            l_acc    = t_acc * feed_avg;
+            l_steady = l - l_acc;
+            if (l_steady < 0.5f * max_segment_length) {
+                l_acc    = l;
+                l_steady = 0.f;
+            } else
+                nSegments = size_t(ceil(l_acc / max_segment_length));
+        }
+        float pos_start[5];
+        float pos_end[5];
+        float pos_end2[4];
+        memcpy(pos_start, line.pos_start, sizeof(float) * 5);
+        memcpy(pos_end, line.pos_end, sizeof(float) * 5);
+        if (l_steady > 0.f) {
+            // There will be a steady feed segment emitted.
+            if (accelerating) {
+                // Prepare the final steady feed rate segment.
+                memcpy(pos_end2, pos_end, sizeof(float)*4);
+                float t = l_acc / l;
+                for (int i = 0; i < 4; ++ i) {
+                    pos_end[i] = pos_start[i] + (pos_end[i] - pos_start[i]) * t;
+                    line.pos_provided[i] = true;
+                }
+            } else {
+                // Emit the steady feed rate segment.
+                float t = l_steady / l;
+                for (int i = 0; i < 4; ++ i) {
+                    line.pos_end[i] = pos_start[i] + (pos_end[i] - pos_start[i]) * t;
+                    line.pos_provided[i] = true;
+                }
+                push_line_to_output(line_idx, pos_start[4], comment);
+                comment = nullptr;
+
+                float new_pos_start_feedrate = pos_start[4];
+
+                memcpy(line.pos_start, line.pos_end, sizeof(float)*5);
+                memcpy(pos_start, line.pos_end, sizeof(float)*5);
+
+                line.pos_start[4] = new_pos_start_feedrate;
+                pos_start[4] = new_pos_start_feedrate;
+            }
+        }
+        // Split the segment into pieces.
+        for (size_t i = 1; i < nSegments; ++ i) {
+            float t = float(i) / float(nSegments);
+            for (size_t j = 0; j < 4; ++ j) {
+                line.pos_end[j] = pos_start[j] + (pos_end[j] - pos_start[j]) * t;
+                line.pos_provided[j] = true;
+            } 
+            // Interpolate the feed rate at the center of the segment.
+            push_line_to_output(line_idx, pos_start[4] + (pos_end[4] - pos_start[4]) * (float(i) - 0.5f) / float(nSegments), comment);
+            comment = nullptr;
+            memcpy(line.pos_start, line.pos_end, sizeof(float)*5);
+        }
+		if (l_steady > 0.f && accelerating) {
+            for (int i = 0; i < 4; ++ i) {
+                line.pos_end[i] = pos_end2[i];
+                line.pos_provided[i] = true;
+            }
+            push_line_to_output(line_idx, pos_end[4], comment);
+        } else {
+            for (int i = 0; i < 4; ++ i) {
+                line.pos_end[i] = pos_end[i];
+                line.pos_provided[i] = true;
+            }
+            push_line_to_output(line_idx, pos_end[4], comment);
+        }
+    }
+}
+
+void PressureEqualizer::adjust_volumetric_rate()
+{
+    if (m_gcode_lines.size() < 2)
+        return;
+
+    // Go back from the current circular_buffer_pos and lower the feedtrate to decrease the slope of the extrusion rate changes.
+    size_t       fist_line_idx = size_t(std::max<int>(0, int(m_gcode_lines.size()) - max_look_back_limit));
+    const size_t last_line_idx = m_gcode_lines.size() - 1;
+    size_t       line_idx      = last_line_idx;
+    if (line_idx == fist_line_idx || !m_gcode_lines[line_idx].extruding())
+        // Nothing to do, the last move is not extruding.
+        return;
+
+    std::array<float, size_t(GCodeExtrusionRole::Count)> feedrate_per_extrusion_role{};
+    feedrate_per_extrusion_role.fill(std::numeric_limits<float>::max());
+    feedrate_per_extrusion_role[int(m_gcode_lines[line_idx].extrusion_role)] = m_gcode_lines[line_idx].volumetric_extrusion_rate_start;
+
+    while (line_idx != fist_line_idx) {
+        size_t idx_prev = line_idx - 1;
+        for (; !m_gcode_lines[idx_prev].extruding() && idx_prev != fist_line_idx; --idx_prev);
+        if (!m_gcode_lines[idx_prev].extruding())
+            break;
+        // Don't decelerate before ironing and gap-fill.
+        if (m_gcode_lines[line_idx].extrusion_role == GCodeExtrusionRole::Ironing || m_gcode_lines[line_idx].extrusion_role == GCodeExtrusionRole::GapFill) {
+            line_idx = idx_prev;
+            continue;
+        }
+        // Volumetric extrusion rate at the start of the succeding segment.
+        float rate_succ = m_gcode_lines[line_idx].volumetric_extrusion_rate_start;
+        // What is the gradient of the extrusion rate between idx_prev and idx?
+        line_idx        = idx_prev;
+        GCodeLine &line = m_gcode_lines[line_idx];
+
+        for (size_t iRole = 1; iRole < size_t(GCodeExtrusionRole::Count); ++ iRole) {
+            const float &rate_slope = m_max_volumetric_extrusion_rate_slopes[iRole].negative;
+            if (rate_slope == 0 || feedrate_per_extrusion_role[iRole] == std::numeric_limits<float>::max())
+                continue; // The negative rate is unlimited or the rate for GCodeExtrusionRole iRole is unlimited.
+
+            float rate_end = feedrate_per_extrusion_role[iRole];
+            if (iRole == size_t(line.extrusion_role) && rate_succ < rate_end)
+                // Limit by the succeeding volumetric flow rate.
+                rate_end = rate_succ;
+
+            if (!line.adjustable_flow || line.extrusion_role == GCodeExtrusionRole::ExternalPerimeter || line.extrusion_role == GCodeExtrusionRole::GapFill || line.extrusion_role == GCodeExtrusionRole::BridgeInfill || line.extrusion_role == GCodeExtrusionRole::Ironing) {
+                rate_end = line.volumetric_extrusion_rate_end;
+            } else if (line.volumetric_extrusion_rate_end > rate_end) {
+                line.volumetric_extrusion_rate_end = rate_end;
+                line.max_volumetric_extrusion_rate_slope_negative = rate_slope;
+                line.modified = true;
+            } else if (iRole == size_t(line.extrusion_role)) {
+                rate_end = line.volumetric_extrusion_rate_end;
+            } else {
+                // Use the original, 'floating' extrusion rate as a starting point for the limiter.
+            }
+
+            if (line.adjustable_flow) {
+                float rate_start = rate_end + rate_slope * line.time_corrected();
+                if (rate_start < line.volumetric_extrusion_rate_start) {
+                    // Limit the volumetric extrusion rate at the start of this segment due to a segment
+                    // of ExtrusionType iRole, which will be extruded in the future.
+                    line.volumetric_extrusion_rate_start = rate_start;
+                    line.max_volumetric_extrusion_rate_slope_negative = rate_slope;
+                    line.modified = true;
+                }
+            }
+//            feedrate_per_extrusion_role[iRole] = (iRole == line.extrusion_role) ? line.volumetric_extrusion_rate_start : rate_start;
+            // Don't store feed rate for ironing and gap-fill.
+            if (line.extrusion_role != GCodeExtrusionRole::Ironing && line.extrusion_role != GCodeExtrusionRole::GapFill)
+                feedrate_per_extrusion_role[iRole] = line.volumetric_extrusion_rate_start;
+        }
+    }
+
+    feedrate_per_extrusion_role.fill(std::numeric_limits<float>::max());
+    feedrate_per_extrusion_role[size_t(m_gcode_lines[line_idx].extrusion_role)] = m_gcode_lines[line_idx].volumetric_extrusion_rate_end;
+
+    assert(m_gcode_lines[line_idx].extruding());
+    while (line_idx != last_line_idx) {
+        size_t idx_next = line_idx + 1;
+        for (; !m_gcode_lines[idx_next].extruding() && idx_next != last_line_idx; ++idx_next);
+        if (!m_gcode_lines[idx_next].extruding())
+            break;
+        // Don't accelerate after ironing and gap-fill.
+        if (m_gcode_lines[line_idx].extrusion_role == GCodeExtrusionRole::Ironing || m_gcode_lines[line_idx].extrusion_role == GCodeExtrusionRole::GapFill) {
+            line_idx = idx_next;
+            continue;
+        }
+        float rate_prec = m_gcode_lines[line_idx].volumetric_extrusion_rate_end;
+        // What is the gradient of the extrusion rate between idx_prev and idx?
+        line_idx = idx_next;
+        GCodeLine &line = m_gcode_lines[line_idx];
+
+        for (size_t iRole = 1; iRole < size_t(GCodeExtrusionRole::Count); ++ iRole) {
+            const float &rate_slope = m_max_volumetric_extrusion_rate_slopes[iRole].positive;
+            if (rate_slope == 0 || feedrate_per_extrusion_role[iRole] == std::numeric_limits<float>::max())
+                continue; // The positive rate is unlimited or the rate for GCodeExtrusionRole iRole is unlimited.
+
+            float rate_start = feedrate_per_extrusion_role[iRole];
+            if (!line.adjustable_flow || line.extrusion_role == GCodeExtrusionRole::ExternalPerimeter || line.extrusion_role == GCodeExtrusionRole::GapFill || line.extrusion_role == GCodeExtrusionRole::BridgeInfill || line.extrusion_role == GCodeExtrusionRole::Ironing) {
+                rate_start = line.volumetric_extrusion_rate_start;
+            } else if (iRole == size_t(line.extrusion_role) && rate_prec < rate_start)
+                rate_start = rate_prec;
+            if (line.volumetric_extrusion_rate_start > rate_start) {
+                line.volumetric_extrusion_rate_start = rate_start;
+                line.max_volumetric_extrusion_rate_slope_positive = rate_slope;
+                line.modified = true;
+            } else if (iRole == size_t(line.extrusion_role)) {
+                rate_start = line.volumetric_extrusion_rate_start;
+            } else {
+                // Use the original, 'floating' extrusion rate as a starting point for the limiter.
+            }
+
+            if (line.adjustable_flow) {
+                float rate_end = rate_start + rate_slope * line.time_corrected();
+                if (rate_end < line.volumetric_extrusion_rate_end) {
+                    // Limit the volumetric extrusion rate at the start of this segment due to a segment
+                    // of ExtrusionType iRole, which was extruded before.
+                    line.volumetric_extrusion_rate_end                = rate_end;
+                    line.max_volumetric_extrusion_rate_slope_positive = rate_slope;
+                    line.modified                                     = true;
+                }
+            }
+//            feedrate_per_extrusion_role[iRole] = (iRole == line.extrusion_role) ? line.volumetric_extrusion_rate_end : rate_end;
+            // Don't store feed rate for ironing and gap-fill.
+            if (line.extrusion_role != GCodeExtrusionRole::Ironing && line.extrusion_role != GCodeExtrusionRole::GapFill)
+                feedrate_per_extrusion_role[iRole] = line.volumetric_extrusion_rate_end;
+        }
+    }
+}
+
+inline void PressureEqualizer::push_to_output(GCodeG1Formatter &formatter)
+{
+    return this->push_to_output(formatter.string(), false);
+}
+
+inline void PressureEqualizer::push_to_output(const std::string &text, bool add_eol)
+{
+    return this->push_to_output(text.data(), text.size(), add_eol);
+}
+
+inline void PressureEqualizer::push_to_output(const char *text, const size_t len, bool add_eol)
+{
+    // New length of the output buffer content.
+    size_t len_new = output_buffer_length + len + 1;
+    if (add_eol)
+        ++len_new;
+
+    // Resize the output buffer to a power of 2 higher than the required memory.
+    if (output_buffer.size() < len_new) {
+        size_t v = len_new;
+        // Compute the next highest power of 2 of 32-bit v
+        // http://graphics.stanford.edu/~seander/bithacks.html
+        v--;
+        v |= v >> 1;
+        v |= v >> 2;
+        v |= v >> 4;
+        v |= v >> 8;
+        v |= v >> 16;
+        v++;
+        output_buffer.resize(v);
+    }
+
+    // Copy the text to the output.
+    if (len != 0) {
+        memcpy(output_buffer.data() + output_buffer_length, text, len);
+        this->output_buffer_prev_length = this->output_buffer_length;
+        output_buffer_length += len;
+    }
+    if (add_eol)
+        output_buffer[output_buffer_length++] = '\n';
+    output_buffer[output_buffer_length] = 0;
+}
+
+inline bool is_just_line_with_extrude_set_speed_tag(const std::string &line)
+{
+    if (line.empty() && !boost::starts_with(line, "G1 ") && !boost::ends_with(line, EXTRUDE_SET_SPEED_TAG))
+        return false;
+
+    const char       *p_line   = line.data() + 3;
+    const char *const line_end = line.data() + line.length() - 1;
+    while (!is_eol(*p_line)) {
+        if (toupper(*p_line++) == 'F')
+            break;
+        else
+            return false;
+    }
+    parse_float(p_line, line_end - p_line);
+    eatws(p_line);
+    p_line += EXTRUDE_SET_SPEED_TAG.length();
+    return p_line <= line_end && is_eol(*p_line);
+}
+
+void PressureEqualizer::push_line_to_output(const size_t line_idx, const float new_feedrate, const char *comment)
+{
+    const GCodeLine &line = m_gcode_lines[line_idx];
+    if (line_idx > 0 && output_buffer_length > 0) {
+        const std::string prev_line_str = std::string(output_buffer.begin() + int(this->output_buffer_prev_length),
+                                                      output_buffer.begin() + int(this->output_buffer_length) + 1);
+        if (is_just_line_with_extrude_set_speed_tag(prev_line_str))
+            this->output_buffer_length = this->output_buffer_prev_length; // Remove the last line because it only sets the speed for an empty block of g-code lines, so it is useless.
+        else
+            push_to_output(EXTRUDE_END_TAG.data(), EXTRUDE_END_TAG.length(), true);
+    } else
+        push_to_output(EXTRUDE_END_TAG.data(), EXTRUDE_END_TAG.length(), true);
+
+    GCodeG1Formatter feedrate_formatter;
+    feedrate_formatter.emit_f(new_feedrate);
+    feedrate_formatter.emit_string(std::string(EXTRUDE_SET_SPEED_TAG.data(), EXTRUDE_SET_SPEED_TAG.length()));
+    if (line.extrusion_role == GCodeExtrusionRole::ExternalPerimeter)
+        feedrate_formatter.emit_string(std::string(EXTERNAL_PERIMETER_TAG.data(), EXTERNAL_PERIMETER_TAG.length()));
+    push_to_output(feedrate_formatter);
+
+    GCodeG1Formatter extrusion_formatter;
+    for (size_t axis_idx = 0; axis_idx < 3; ++axis_idx)
+        if (line.pos_provided[axis_idx])
+            extrusion_formatter.emit_axis(char('X' + axis_idx), line.pos_end[axis_idx], GCodeFormatter::XYZF_EXPORT_DIGITS);
+    extrusion_formatter.emit_axis('E', m_use_relative_e_distances ? (line.pos_end[3] - line.pos_start[3]) : line.pos_end[3], GCodeFormatter::E_EXPORT_DIGITS);
+
+    if (comment != nullptr)
+        extrusion_formatter.emit_string(std::string(comment));
+
+    push_to_output(extrusion_formatter);
+}
+
+} // namespace Slic3r

src/libslic3r/GCode/PressureEqualizer.hpp

@@ -0,0 +1,204 @@
+#ifndef slic3r_GCode_PressureEqualizer_hpp_
+#define slic3r_GCode_PressureEqualizer_hpp_
+
+#include "../libslic3r.h"
+#include "../PrintConfig.hpp"
+#include "../ExtrusionRole.hpp"
+
+#include <queue>
+
+namespace Slic3r {
+
+struct LayerResult;
+
+class GCodeG1Formatter;
+
+//#define PRESSURE_EQUALIZER_STATISTIC
+//#define PRESSURE_EQUALIZER_DEBUG
+
+// Processes a G-code. Finds changes in the volumetric extrusion speed and adjusts the transitions
+// between these paths to limit fast changes in the volumetric extrusion speed.
+class PressureEqualizer
+{
+public:
+    PressureEqualizer() = delete;
+    explicit PressureEqualizer(const Slic3r::GCodeConfig &config);
+    ~PressureEqualizer() = default;
+
+    // Process a next batch of G-code lines.
+    // The last LayerResult must be LayerResult::make_nop_layer_result() because it always returns GCode for the previous layer.
+    // When process_layer is called for the first layer, then LayerResult::make_nop_layer_result() is returned.
+    LayerResult process_layer(LayerResult &&input);
+private:
+
+    void process_layer(const std::string &gcode);
+
+#ifdef PRESSURE_EQUALIZER_STATISTIC
+    struct Statistics
+    {
+        void reset()
+        {
+            volumetric_extrusion_rate_min = std::numeric_limits<float>::max();
+            volumetric_extrusion_rate_max = 0.f;
+            volumetric_extrusion_rate_avg = 0.f;
+            extrusion_length              = 0.f;
+        }
+        void update(float volumetric_extrusion_rate, float length)
+        {
+            volumetric_extrusion_rate_min  = std::min(volumetric_extrusion_rate_min, volumetric_extrusion_rate);
+            volumetric_extrusion_rate_max  = std::max(volumetric_extrusion_rate_max, volumetric_extrusion_rate);
+            volumetric_extrusion_rate_avg += volumetric_extrusion_rate * length;
+            extrusion_length              += length;
+        }
+        float volumetric_extrusion_rate_min;
+        float volumetric_extrusion_rate_max;
+        float volumetric_extrusion_rate_avg;
+        float extrusion_length;
+    };
+
+    struct Statistics m_stat;
+#endif
+
+    // Private configuration values
+    // How fast could the volumetric extrusion rate increase / decrase? mm^3/sec^2
+    struct ExtrusionRateSlope {
+        float positive;
+        float negative;
+    };
+    ExtrusionRateSlope              m_max_volumetric_extrusion_rate_slopes[size_t(GCodeExtrusionRole::Count)];
+    float                           m_max_volumetric_extrusion_rate_slope_positive;
+    float                           m_max_volumetric_extrusion_rate_slope_negative;
+
+    // Configuration extracted from config.
+    // Area of the crossestion of each filament. Necessary to calculate the volumetric flow rate.
+    std::vector<float>              m_filament_crossections;
+
+    // Internal data.
+    // X,Y,Z,E,F
+    float                           m_current_pos[5];
+    size_t                          m_current_extruder;
+    GCodeExtrusionRole     m_current_extrusion_role;
+    bool                            m_retracted;
+    bool                            m_use_relative_e_distances;
+
+    // Indicate if extrude set speed block was opened using the tag ";_EXTRUDE_SET_SPEED"
+    // or not (not opened, or it was closed using the tag ";_EXTRUDE_END").
+    bool                            opened_extrude_set_speed_block = false;
+
+    enum GCodeLineType {
+        GCODELINETYPE_INVALID,
+        GCODELINETYPE_NOOP,
+        GCODELINETYPE_OTHER,
+        GCODELINETYPE_RETRACT,
+        GCODELINETYPE_UNRETRACT,
+        GCODELINETYPE_TOOL_CHANGE,
+        GCODELINETYPE_MOVE,
+        GCODELINETYPE_EXTRUDE,
+    };
+
+    struct GCodeLine
+    {
+        GCodeLine() : 
+            type(GCODELINETYPE_INVALID),
+            raw_length(0),
+            modified(false),
+            extruder_id(0), 
+            volumetric_extrusion_rate(0.f), 
+            volumetric_extrusion_rate_start(0.f), 
+            volumetric_extrusion_rate_end(0.f) 
+            {}
+
+        bool        moving_xy()     const { return fabs(pos_end[0] - pos_start[0]) > 0.f || fabs(pos_end[1] - pos_start[1]) > 0.f; }
+        bool        moving_z ()     const { return fabs(pos_end[2] - pos_start[2]) > 0.f; }
+        bool        extruding()     const { return moving_xy() && pos_end[3] > pos_start[3]; }
+        bool        retracting()    const { return pos_end[3] < pos_start[3]; }
+        bool        deretracting()  const { return ! moving_xy() && pos_end[3] > pos_start[3]; }
+
+        float       dist_xy2()      const { return (pos_end[0] - pos_start[0]) * (pos_end[0] - pos_start[0]) + (pos_end[1] - pos_start[1]) * (pos_end[1] - pos_start[1]); }
+        float       dist_xyz2()     const { return (pos_end[0] - pos_start[0]) * (pos_end[0] - pos_start[0]) + (pos_end[1] - pos_start[1]) * (pos_end[1] - pos_start[1]) + (pos_end[2] - pos_start[2]) * (pos_end[2] - pos_start[2]); }
+        float       dist_xy()       const { return sqrt(dist_xy2()); }
+        float       dist_xyz()      const { return sqrt(dist_xyz2()); }
+        float       dist_e()        const { return fabs(pos_end[3] - pos_start[3]); }
+
+        float       feedrate()      const { return pos_end[4]; }
+        float       time()          const { return dist_xyz() / feedrate(); }
+        float       time_inv()      const { return feedrate() / dist_xyz(); }
+        float       volumetric_correction_avg() const { 
+            float avg_correction = 0.5f * (volumetric_extrusion_rate_start + volumetric_extrusion_rate_end) / volumetric_extrusion_rate; 
+            assert(avg_correction > 0.f);
+            assert(avg_correction <= 1.00000001f);
+            return avg_correction;
+        }
+        float       time_corrected()  const { return time() * volumetric_correction_avg(); }
+
+        GCodeLineType type;
+
+        // We try to keep the string buffer once it has been allocated, so it will not be reallocated over and over.
+        std::vector<char>   raw;
+        size_t              raw_length;
+        // If modified, the raw text has to be adapted by the new extrusion rate,
+        // or maybe the line needs to be split into multiple lines.
+        bool                modified;
+
+        // X,Y,Z,E,F. Storing the state of the currently active extruder only.
+        float       pos_start[5];
+        float       pos_end[5];
+        // Was the axis found on the G-code line? X,Y,Z,E,F
+        bool        pos_provided[5];
+
+        // Index of the active extruder.
+        size_t      extruder_id;
+        // Extrusion role of this segment.
+        GCodeExtrusionRole extrusion_role;
+
+        // Current volumetric extrusion rate.
+        float       volumetric_extrusion_rate;
+        // Volumetric extrusion rate at the start of this segment.
+        float       volumetric_extrusion_rate_start;
+        // Volumetric extrusion rate at the end of this segment.
+        float       volumetric_extrusion_rate_end;
+
+        // Volumetric extrusion rate slope limiting this segment.
+        // If set to zero, the slope is unlimited.
+        float       max_volumetric_extrusion_rate_slope_positive;
+        float       max_volumetric_extrusion_rate_slope_negative;
+
+        bool        adjustable_flow       = false;
+
+        bool        extrude_set_speed_tag = false;
+        bool        extrude_end_tag       = false;
+    };
+
+    // Output buffer will only grow. It will not be reallocated over and over.
+    std::vector<char>               output_buffer;
+    size_t                          output_buffer_length;
+    size_t                          output_buffer_prev_length;
+
+#ifdef PRESSURE_EQUALIZER_DEBUG
+    // For debugging purposes. Index of the G-code line processed.
+    size_t                          line_idx;
+#endif
+
+    bool process_line(const char *line, const char *line_end, GCodeLine &buf);
+    void output_gcode_line(size_t line_idx);
+
+    // Go back from the current circular_buffer_pos and lower the feedtrate to decrease the slope of the extrusion rate changes.
+    // Then go forward and adjust the feedrate to decrease the slope of the extrusion rate changes.
+    void adjust_volumetric_rate();
+
+    // Push the text to the end of the output_buffer.
+    inline void push_to_output(GCodeG1Formatter &formatter);
+    inline void push_to_output(const std::string &text, bool add_eol);
+    inline void push_to_output(const char *text, size_t len, bool add_eol = true);
+    // Push a G-code line to the output.
+    void push_line_to_output(size_t line_idx, float new_feedrate, const char *comment);
+
+public:
+    std::queue<LayerResult*> m_layer_results;
+
+    std::vector<GCodeLine> m_gcode_lines;
+};
+
+} // namespace Slic3r
+
+#endif /* slic3r_GCode_PressureEqualizer_hpp_ */

src/libslic3r/GCode/PrintExtents.cpp

@@ -0,0 +1,188 @@
+// Calculate extents of the extrusions assigned to Print / PrintObject.
+// The extents are used for assessing collisions of the print with the priming towers,
+// to decide whether to pause the print after the priming towers are extruded
+// to let the operator remove them from the print bed.
+
+#include "../BoundingBox.hpp"
+#include "../ExtrusionEntity.hpp"
+#include "../ExtrusionEntityCollection.hpp"
+#include "../Layer.hpp"
+#include "../Print.hpp"
+
+#include "PrintExtents.hpp"
+#include "WipeTower.hpp"
+
+namespace Slic3r {
+
+static inline BoundingBox extrusion_polyline_extents(const Polyline &polyline, const coord_t radius)
+{
+    BoundingBox bbox;
+    if (! polyline.points.empty())
+        bbox.merge(polyline.points.front());
+    for (const Point &pt : polyline.points) {
+        bbox.min(0) = std::min(bbox.min(0), pt(0) - radius);
+        bbox.min(1) = std::min(bbox.min(1), pt(1) - radius);
+        bbox.max(0) = std::max(bbox.max(0), pt(0) + radius);
+        bbox.max(1) = std::max(bbox.max(1), pt(1) + radius);
+    }
+    return bbox;
+}
+
+static inline BoundingBoxf extrusionentity_extents(const ExtrusionPath &extrusion_path)
+{
+    BoundingBox bbox = extrusion_polyline_extents(extrusion_path.polyline, coord_t(scale_(0.5 * extrusion_path.width)));
+    BoundingBoxf bboxf;
+    if (! empty(bbox)) {
+        bboxf.min = unscale(bbox.min);
+        bboxf.max = unscale(bbox.max);
+		bboxf.defined = true;
+    }
+    return bboxf;
+}
+
+static inline BoundingBoxf extrusionentity_extents(const ExtrusionLoop &extrusion_loop)
+{
+    BoundingBox bbox;
+    for (const ExtrusionPath &extrusion_path : extrusion_loop.paths)
+        bbox.merge(extrusion_polyline_extents(extrusion_path.polyline, coord_t(scale_(0.5 * extrusion_path.width))));
+    BoundingBoxf bboxf;
+    if (! empty(bbox)) {
+        bboxf.min = unscale(bbox.min);
+        bboxf.max = unscale(bbox.max);
+		bboxf.defined = true;
+	}
+    return bboxf;
+}
+
+static inline BoundingBoxf extrusionentity_extents(const ExtrusionMultiPath &extrusion_multi_path)
+{
+    BoundingBox bbox;
+    for (const ExtrusionPath &extrusion_path : extrusion_multi_path.paths)
+        bbox.merge(extrusion_polyline_extents(extrusion_path.polyline, coord_t(scale_(0.5 * extrusion_path.width))));
+    BoundingBoxf bboxf;
+    if (! empty(bbox)) {
+        bboxf.min = unscale(bbox.min);
+        bboxf.max = unscale(bbox.max);
+		bboxf.defined = true;
+	}
+    return bboxf;
+}
+
+static BoundingBoxf extrusionentity_extents(const ExtrusionEntity *extrusion_entity);
+
+static inline BoundingBoxf extrusionentity_extents(const ExtrusionEntityCollection &extrusion_entity_collection)
+{
+    BoundingBoxf bbox;
+    for (const ExtrusionEntity *extrusion_entity : extrusion_entity_collection.entities)
+        bbox.merge(extrusionentity_extents(extrusion_entity));
+    return bbox;
+}
+
+static BoundingBoxf extrusionentity_extents(const ExtrusionEntity *extrusion_entity)
+{
+    if (extrusion_entity == nullptr)
+        return BoundingBoxf();
+    auto *extrusion_path = dynamic_cast<const ExtrusionPath*>(extrusion_entity);
+    if (extrusion_path != nullptr)
+        return extrusionentity_extents(*extrusion_path);
+    auto *extrusion_loop = dynamic_cast<const ExtrusionLoop*>(extrusion_entity);
+    if (extrusion_loop != nullptr)
+        return extrusionentity_extents(*extrusion_loop);
+    auto *extrusion_multi_path = dynamic_cast<const ExtrusionMultiPath*>(extrusion_entity);
+    if (extrusion_multi_path != nullptr)
+        return extrusionentity_extents(*extrusion_multi_path);
+    auto *extrusion_entity_collection = dynamic_cast<const ExtrusionEntityCollection*>(extrusion_entity);
+    if (extrusion_entity_collection != nullptr)
+        return extrusionentity_extents(*extrusion_entity_collection);
+    throw Slic3r::RuntimeError("Unexpected extrusion_entity type in extrusionentity_extents()");
+    return BoundingBoxf();
+}
+
+BoundingBoxf get_print_extrusions_extents(const Print &print)
+{
+    BoundingBoxf bbox(extrusionentity_extents(print.brim()));
+    bbox.merge(extrusionentity_extents(print.skirt()));
+    return bbox;
+}
+
+BoundingBoxf get_print_object_extrusions_extents(const PrintObject &print_object, const coordf_t max_print_z)
+{
+    BoundingBoxf bbox;
+    for (const Layer *layer : print_object.layers()) {
+        if (layer->print_z > max_print_z)
+            break;
+        BoundingBoxf bbox_this;
+        for (const LayerRegion *layerm : layer->regions()) {
+            bbox_this.merge(extrusionentity_extents(layerm->perimeters()));
+            for (const ExtrusionEntity *ee : layerm->fills())
+                // fill represents infill extrusions of a single island.
+                bbox_this.merge(extrusionentity_extents(*dynamic_cast<const ExtrusionEntityCollection*>(ee)));
+        }
+        const SupportLayer *support_layer = dynamic_cast<const SupportLayer*>(layer);
+        if (support_layer)
+            for (const ExtrusionEntity *extrusion_entity : support_layer->support_fills.entities)
+                bbox_this.merge(extrusionentity_extents(extrusion_entity));
+        for (const PrintInstance &instance : print_object.instances()) {
+            BoundingBoxf bbox_translated(bbox_this);
+            bbox_translated.translate(unscale(instance.shift));
+            bbox.merge(bbox_translated);
+        }
+    }
+    return bbox;
+}
+
+// Returns a bounding box of a projection of the wipe tower for the layers <= max_print_z.
+// The projection does not contain the priming regions.
+BoundingBoxf get_wipe_tower_extrusions_extents(const Print &print, const coordf_t max_print_z)
+{
+    // Wipe tower extrusions are saved as if the tower was at the origin with no rotation
+    // We need to get position and angle of the wipe tower to transform them to actual position.
+    Transform2d trafo =
+        Eigen::Translation2d(print.config().wipe_tower_x.value, print.config().wipe_tower_y.value) *
+        Eigen::Rotation2Dd(Geometry::deg2rad(print.config().wipe_tower_rotation_angle.value));
+
+    BoundingBoxf bbox;
+    for (const std::vector<WipeTower::ToolChangeResult> &tool_changes : print.wipe_tower_data().tool_changes) {
+        if (! tool_changes.empty() && tool_changes.front().print_z > max_print_z)
+            break;
+        for (const WipeTower::ToolChangeResult &tcr : tool_changes) {
+            for (size_t i = 1; i < tcr.extrusions.size(); ++ i) {
+                const WipeTower::Extrusion &e = tcr.extrusions[i];
+                if (e.width > 0) {
+                    Vec2d delta = 0.5 * Vec2d(e.width, e.width);
+                    Vec2d p1 = trafo * (&e - 1)->pos.cast<double>();
+                    Vec2d p2 = trafo * e.pos.cast<double>();
+                    bbox.merge(p1.cwiseMin(p2) - delta);
+                    bbox.merge(p1.cwiseMax(p2) + delta);
+                }
+            }
+        }
+    }
+    return bbox;
+}
+
+// Returns a bounding box of the wipe tower priming extrusions.
+BoundingBoxf get_wipe_tower_priming_extrusions_extents(const Print &print)
+{
+    BoundingBoxf bbox;
+    if (print.wipe_tower_data().priming != nullptr) {
+        for (const WipeTower::ToolChangeResult &tcr : *print.wipe_tower_data().priming) {
+            for (size_t i = 1; i < tcr.extrusions.size(); ++ i) {
+                const WipeTower::Extrusion &e = tcr.extrusions[i];
+                if (e.width > 0) {
+                    const Vec2d& p1 = (&e - 1)->pos.cast<double>();
+                    const Vec2d& p2 = e.pos.cast<double>();
+                    bbox.merge(p1);
+                    coordf_t radius = 0.5 * e.width;
+                    bbox.min(0) = std::min(bbox.min(0), std::min(p1(0), p2(0)) - radius);
+                    bbox.min(1) = std::min(bbox.min(1), std::min(p1(1), p2(1)) - radius);
+                    bbox.max(0) = std::max(bbox.max(0), std::max(p1(0), p2(0)) + radius);
+                    bbox.max(1) = std::max(bbox.max(1), std::max(p1(1), p2(1)) + radius);
+                }
+            }
+        }
+    }
+    return bbox;
+}
+
+}

src/libslic3r/GCode/PrintExtents.hpp

@@ -0,0 +1,30 @@
+// Measure extents of the planned extrusions.
+// To be used for collision reporting.
+
+#ifndef slic3r_PrintExtents_hpp_
+#define slic3r_PrintExtents_hpp_
+
+#include "libslic3r.h"
+
+namespace Slic3r {
+
+class Print;
+class PrintObject;
+class BoundingBoxf;
+
+// Returns a bounding box of a projection of the brim and skirt.
+BoundingBoxf get_print_extrusions_extents(const Print &print);
+
+// Returns a bounding box of a projection of the object extrusions at z <= max_print_z.
+BoundingBoxf get_print_object_extrusions_extents(const PrintObject &print_object, const coordf_t max_print_z);
+
+// Returns a bounding box of a projection of the wipe tower for the layers <= max_print_z.
+// The projection does not contain the priming regions.
+BoundingBoxf get_wipe_tower_extrusions_extents(const Print &print, const coordf_t max_print_z);
+
+// Returns a bounding box of the wipe tower priming extrusions.
+BoundingBoxf get_wipe_tower_priming_extrusions_extents(const Print &print);
+
+};
+
+#endif /* slic3r_PrintExtents_hpp_ */

src/libslic3r/GCode/RetractWhenCrossingPerimeters.cpp

@@ -0,0 +1,54 @@
+#include "../ClipperUtils.hpp"
+#include "../Layer.hpp"
+#include "../Polyline.hpp"
+
+#include "RetractWhenCrossingPerimeters.hpp"
+
+namespace Slic3r {
+
+bool RetractWhenCrossingPerimeters::travel_inside_internal_regions(const Layer &layer, const Polyline &travel)
+{
+    if (m_layer != &layer) {
+        // Update cache.
+        m_layer = &layer;
+        m_internal_islands.clear();
+        m_aabbtree_internal_islands.clear();
+        // Collect expolygons of internal slices.
+        for (const LayerRegion *layerm : layer.regions())
+            for (const Surface &surface : layerm->slices().surfaces)
+                if (surface.is_internal())
+                    m_internal_islands.emplace_back(&surface.expolygon);
+        // Calculate bounding boxes of internal slices.
+        std::vector<AABBTreeIndirect::BoundingBoxWrapper> bboxes;
+        bboxes.reserve(m_internal_islands.size());
+        for (size_t i = 0; i < m_internal_islands.size(); ++ i)
+            bboxes.emplace_back(i, get_extents(*m_internal_islands[i]));
+        // Build AABB tree over bounding boxes of internal slices.
+        m_aabbtree_internal_islands.build_modify_input(bboxes);
+    }
+
+    BoundingBox           bbox_travel = get_extents(travel);
+    AABBTree::BoundingBox bbox_travel_eigen{ bbox_travel.min, bbox_travel.max };
+    int result = -1;
+    bbox_travel.offset(SCALED_EPSILON);
+    AABBTreeIndirect::traverse(m_aabbtree_internal_islands, 
+        [&bbox_travel_eigen](const AABBTree::Node &node) {
+            return bbox_travel_eigen.intersects(node.bbox);
+        },
+        [&travel, &bbox_travel, &result, &islands = m_internal_islands](const AABBTree::Node &node) {
+            assert(node.is_leaf());
+            assert(node.is_valid());
+            Polygons clipped = ClipperUtils::clip_clipper_polygons_with_subject_bbox(*islands[node.idx], bbox_travel);
+            if (diff_pl(travel, clipped).empty()) {
+                // Travel path is completely inside an "internal" island. Don't retract.
+                result = int(node.idx);
+                // Stop traversal.
+                return false;
+            }
+            // Continue traversal.
+            return true;
+        });
+    return result != -1;
+}
+
+} // namespace Slic3r

src/libslic3r/GCode/RetractWhenCrossingPerimeters.hpp

@@ -0,0 +1,32 @@
+#ifndef slic3r_RetractWhenCrossingPerimeters_hpp_
+#define slic3r_RetractWhenCrossingPerimeters_hpp_
+
+#include <vector>
+
+#include "../AABBTreeIndirect.hpp"
+
+namespace Slic3r {
+
+// Forward declarations.
+class ExPolygon;
+class Layer;
+class Polyline;
+
+class RetractWhenCrossingPerimeters
+{
+public:
+    bool    travel_inside_internal_regions(const Layer &layer, const Polyline &travel);
+
+private:
+    // Last object layer visited, for which a cache of internal islands was created.
+    const Layer                        *m_layer;
+    // Internal islands only, referencing data owned by m_layer->regions()->surfaces().
+    std::vector<const ExPolygon*>       m_internal_islands;
+    // Search structure over internal islands.
+    using AABBTree = AABBTreeIndirect::Tree<2, coord_t>;
+    AABBTree                            m_aabbtree_internal_islands;
+};
+
+} // namespace Slic3r
+
+#endif // slic3r_RetractWhenCrossingPerimeters_hpp_

src/libslic3r/GCode/SeamPlacer.hpp

@@ -0,0 +1,164 @@
+#ifndef libslic3r_SeamPlacer_hpp_
+#define libslic3r_SeamPlacer_hpp_
+
+#include <optional>
+#include <vector>
+#include <memory>
+#include <atomic>
+
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/AABBTreeIndirect.hpp"
+#include "libslic3r/KDTreeIndirect.hpp"
+
+namespace Slic3r {
+
+class PrintObject;
+class ExtrusionLoop;
+class Print;
+class Layer;
+
+namespace EdgeGrid {
+class Grid;
+}
+
+namespace SeamPlacerImpl {
+
+
+struct GlobalModelInfo;
+struct SeamComparator;
+
+enum class EnforcedBlockedSeamPoint {
+    Blocked = 0,
+    Neutral = 1,
+    Enforced = 2,
+};
+
+// struct representing single perimeter loop
+struct Perimeter {
+    size_t start_index{};
+    size_t end_index{}; //inclusive!
+    size_t seam_index{};
+    float flow_width{};
+
+    // During alignment, a final position may be stored here. In that case, finalized is set to true.
+    // Note that final seam position is not limited to points of the perimeter loop. In theory it can be any position
+    // Random position also uses this flexibility to set final seam point position
+    bool finalized = false;
+    Vec3f final_seam_position = Vec3f::Zero();
+};
+
+//Struct over which all processing of perimeters is done. For each perimeter point, its respective candidate is created,
+// then all the needed attributes are computed and finally, for each perimeter one point is chosen as seam.
+// This seam position can be then further aligned
+struct SeamCandidate {
+    SeamCandidate(const Vec3f &pos, Perimeter &perimeter,
+            float local_ccw_angle,
+            EnforcedBlockedSeamPoint type) :
+            position(pos), perimeter(perimeter), visibility(0.0f), overhang(0.0f), embedded_distance(0.0f), local_ccw_angle(
+                    local_ccw_angle), type(type), central_enforcer(false) {
+    }
+    const Vec3f position;
+    // pointer to Perimeter loop of this point. It is shared across all points of the loop
+    Perimeter &perimeter;
+    float visibility;
+    float overhang;
+    // distance inside the merged layer regions, for detecting perimeter points which are hidden indside the print (e.g. multimaterial join)
+    // Negative sign means inside the print, comes from EdgeGrid structure
+    float embedded_distance;
+    float local_ccw_angle;
+    EnforcedBlockedSeamPoint type;
+    bool central_enforcer; //marks this candidate as central point of enforced segment on the perimeter - important for alignment
+};
+
+struct SeamCandidateCoordinateFunctor {
+    SeamCandidateCoordinateFunctor(const std::vector<SeamCandidate> &seam_candidates) :
+            seam_candidates(seam_candidates) {
+    }
+    const std::vector<SeamCandidate> &seam_candidates;
+    float operator()(size_t index, size_t dim) const {
+        return seam_candidates[index].position[dim];
+    }
+};
+} // namespace SeamPlacerImpl
+
+struct PrintObjectSeamData
+{
+    using SeamCandidatesTree = KDTreeIndirect<3, float, SeamPlacerImpl::SeamCandidateCoordinateFunctor>;
+
+    struct LayerSeams
+    {
+        Slic3r::deque<SeamPlacerImpl::Perimeter> perimeters;
+        std::vector<SeamPlacerImpl::SeamCandidate> points;
+        std::unique_ptr<SeamCandidatesTree> points_tree;
+    };
+    // Map of PrintObjects (PO) -> vector of layers of PO -> vector of perimeter
+    std::vector<LayerSeams> layers;
+    // Map of PrintObjects (PO) -> vector of layers of PO -> unique_ptr to KD
+    // tree of all points of the given layer
+
+    void clear()
+    {
+        layers.clear();
+    }
+};
+
+class SeamPlacer {
+public:
+    // Number of samples generated on the mesh. There are sqr_rays_per_sample_point*sqr_rays_per_sample_point rays casted from each samples
+    static constexpr size_t raycasting_visibility_samples_count = 30000;
+    static constexpr size_t fast_decimation_triangle_count_target = 16000;
+    //square of number of rays per sample point
+    static constexpr size_t sqr_rays_per_sample_point = 5;
+
+    // snapping angle - angles larger than this value will be snapped to during seam painting
+    static constexpr float sharp_angle_snapping_threshold = 55.0f * float(PI) / 180.0f;
+    // overhang angle for seam placement that still yields good results, in degrees, measured from vertical direction
+    static constexpr float overhang_angle_threshold = 50.0f * float(PI) / 180.0f;
+
+    // determines angle importance compared to visibility ( neutral value is 1.0f. )
+    static constexpr float angle_importance_aligned = 0.6f;
+    static constexpr float angle_importance_nearest = 1.0f; // use much higher angle importance for nearest mode, to combat the visibility info noise
+
+    // For long polygon sides, if they are close to the custom seam drawings, they are oversampled with this step size
+    static constexpr float enforcer_oversampling_distance = 0.2f;
+
+    // When searching for seam clusters for alignment:
+    // following value describes, how much worse score can point have and still be picked into seam cluster instead of original seam point on the same layer
+    static constexpr float seam_align_score_tolerance = 0.3f;
+    // seam_align_tolerable_dist_factor - how far to search for seam from current position, final dist is seam_align_tolerable_dist_factor * flow_width
+    static constexpr float seam_align_tolerable_dist_factor = 4.0f;
+    // minimum number of seams needed in cluster to make alignment happen
+    static constexpr size_t seam_align_minimum_string_seams = 6;
+    // millimeters covered by spline; determines number of splines for the given string
+    static constexpr size_t seam_align_mm_per_segment = 4.0f;
+
+    //The following data structures hold all perimeter points for all PrintObject.
+    std::unordered_map<const PrintObject*, PrintObjectSeamData> m_seam_per_object;
+
+    void init(const Print &print, std::function<void(void)> throw_if_canceled_func);
+
+    void place_seam(const Layer *layer, ExtrusionLoop &loop, bool external_first, const Point &last_pos) const;
+
+private:
+    void gather_seam_candidates(const PrintObject *po, const SeamPlacerImpl::GlobalModelInfo &global_model_info);
+    void calculate_candidates_visibility(const PrintObject *po,
+            const SeamPlacerImpl::GlobalModelInfo &global_model_info);
+    void calculate_overhangs_and_layer_embedding(const PrintObject *po);
+    void align_seam_points(const PrintObject *po, const SeamPlacerImpl::SeamComparator &comparator);
+    std::vector<std::pair<size_t, size_t>> find_seam_string(const PrintObject *po,
+            std::pair<size_t, size_t> start_seam,
+            const SeamPlacerImpl::SeamComparator &comparator) const;
+    std::optional<std::pair<size_t, size_t>> find_next_seam_in_layer(
+            const std::vector<PrintObjectSeamData::LayerSeams> &layers,
+            const Vec3f& projected_position,
+            const size_t layer_idx, const float max_distance,
+            const SeamPlacerImpl::SeamComparator &comparator) const;
+};
+
+} // namespace Slic3r
+
+#endif // libslic3r_SeamPlacer_hpp_

src/libslic3r/GCode/SpiralVase.cpp

@@ -0,0 +1,97 @@
+#include "SpiralVase.hpp"
+#include "GCode.hpp"
+#include <sstream>
+
+namespace Slic3r {
+
+std::string SpiralVase::process_layer(const std::string &gcode)
+{
+    /*  This post-processor relies on several assumptions:
+        - all layers are processed through it, including those that are not supposed
+          to be transformed, in order to update the reader with the XY positions
+        - each call to this method includes a full layer, with a single Z move
+          at the beginning
+        - each layer is composed by suitable geometry (i.e. a single complete loop)
+        - loops were not clipped before calling this method  */
+    
+    // If we're not going to modify G-code, just feed it to the reader
+    // in order to update positions.
+    if (! m_enabled) {
+        m_reader.parse_buffer(gcode);
+        return gcode;
+    }
+    
+    // Get total XY length for this layer by summing all extrusion moves.
+    float total_layer_length = 0;
+    float layer_height = 0;
+    float z = 0.f;
+    
+    {
+        //FIXME Performance warning: This copies the GCodeConfig of the reader.
+        GCodeReader r = m_reader;  // clone
+        bool set_z = false;
+        r.parse_buffer(gcode, [&total_layer_length, &layer_height, &z, &set_z]
+            (GCodeReader &reader, const GCodeReader::GCodeLine &line) {
+            if (line.cmd_is("G1")) {
+                if (line.extruding(reader)) {
+                    total_layer_length += line.dist_XY(reader);
+                } else if (line.has(Z)) {
+                    layer_height += line.dist_Z(reader);
+                    if (!set_z) {
+                        z = line.new_Z(reader);
+                        set_z = true;
+                    }
+                }
+            }
+        });
+    }
+    
+    // Remove layer height from initial Z.
+    z -= layer_height;
+    
+    std::string new_gcode;
+    //FIXME Tapering of the transition layer only works reliably with relative extruder distances.
+    // For absolute extruder distances it will be switched off.
+    // Tapering the absolute extruder distances requires to process every extrusion value after the first transition
+    // layer.
+    bool  transition = m_transition_layer && m_config.use_relative_e_distances.value;
+    float layer_height_factor = layer_height / total_layer_length;
+    float len = 0.f;
+    m_reader.parse_buffer(gcode, [&new_gcode, &z, total_layer_length, layer_height_factor, transition, &len]
+        (GCodeReader &reader, GCodeReader::GCodeLine line) {
+        if (line.cmd_is("G1")) {
+            if (line.has_z()) {
+                // If this is the initial Z move of the layer, replace it with a
+                // (redundant) move to the last Z of previous layer.
+                line.set(reader, Z, z);
+                new_gcode += line.raw() + '\n';
+                return;
+            } else {
+                float dist_XY = line.dist_XY(reader);
+                if (dist_XY > 0) {
+                    // horizontal move
+                    if (line.extruding(reader)) {
+                        len += dist_XY;
+                        line.set(reader, Z, z + len * layer_height_factor);
+                        if (transition && line.has(E))
+                            // Transition layer, modulate the amount of extrusion from zero to the final value.
+                            line.set(reader, E, line.value(E) * len / total_layer_length);
+                        new_gcode += line.raw() + '\n';
+                    }
+                    return;
+                
+                    /*  Skip travel moves: the move to first perimeter point will
+                        cause a visible seam when loops are not aligned in XY; by skipping
+                        it we blend the first loop move in the XY plane (although the smoothness
+                        of such blend depend on how long the first segment is; maybe we should
+                        enforce some minimum length?).  */
+                }
+            }
+        }
+        new_gcode += line.raw() + '\n';
+    });
+    
+    return new_gcode;
+}
+
+}

src/libslic3r/GCode/SpiralVase.hpp

@@ -0,0 +1,35 @@
+#ifndef slic3r_SpiralVase_hpp_
+#define slic3r_SpiralVase_hpp_
+
+#include "../libslic3r.h"
+#include "../GCodeReader.hpp"
+
+namespace Slic3r {
+
+class SpiralVase {
+public:
+    SpiralVase(const PrintConfig &config) : m_config(config)
+    {
+        m_reader.z() = (float)m_config.z_offset;
+        m_reader.apply_config(m_config);
+    };
+
+    void 		enable(bool en) {
+   		m_transition_layer = en && ! m_enabled;
+    	m_enabled 		   = en;
+    }
+
+    std::string process_layer(const std::string &gcode);
+    
+private:
+    const PrintConfig  &m_config;
+    GCodeReader 		m_reader;
+
+    bool 				m_enabled = false;
+    // First spiral vase layer. Layer height has to be ramped up from zero to the target layer height.
+    bool 				m_transition_layer = false;
+};
+
+}
+
+#endif // slic3r_SpiralVase_hpp_

src/libslic3r/GCode/ThumbnailData.cpp

@@ -0,0 +1,31 @@
+#include "ThumbnailData.hpp"
+
+namespace Slic3r {
+
+void ThumbnailData::set(unsigned int w, unsigned int h)
+{
+    if ((w == 0) || (h == 0))
+        return;
+
+    if ((width != w) || (height != h))
+    {
+        width = w;
+        height = h;
+        // defaults to white texture
+        pixels = std::vector<unsigned char>(width * height * 4, 255);
+    }
+}
+
+void ThumbnailData::reset()
+{
+    width = 0;
+    height = 0;
+    pixels.clear();
+}
+
+bool ThumbnailData::is_valid() const
+{
+    return (width != 0) && (height != 0) && ((unsigned int)pixels.size() == 4 * width * height);
+}
+
+} // namespace Slic3r

src/libslic3r/GCode/ThumbnailData.hpp

@@ -0,0 +1,37 @@
+#ifndef slic3r_ThumbnailData_hpp_
+#define slic3r_ThumbnailData_hpp_
+
+#include <vector>
+#include "libslic3r/Point.hpp"
+
+namespace Slic3r {
+
+struct ThumbnailData
+{
+    unsigned int width;
+    unsigned int height;
+    std::vector<unsigned char> pixels;
+
+    ThumbnailData() { reset(); }
+    void set(unsigned int w, unsigned int h);
+    void reset();
+
+    bool is_valid() const;
+};
+
+using ThumbnailsList = std::vector<ThumbnailData>;
+
+struct ThumbnailsParams
+{
+	const Vec2ds 	sizes;
+	bool 			printable_only;
+	bool 			parts_only;
+	bool 			show_bed;
+	bool 			transparent_background;
+};
+
+typedef std::function<ThumbnailsList(const ThumbnailsParams&)> ThumbnailsGeneratorCallback;
+
+} // namespace Slic3r
+
+#endif // slic3r_ThumbnailData_hpp_

src/libslic3r/GCode/Thumbnails.cpp

@@ -0,0 +1,436 @@
+#include "Thumbnails.hpp"
+#include "../miniz_extension.hpp"
+
+#include <qoi/qoi.h>
+#include <jpeglib.h>
+#include <jerror.h>
+#include<stdio.h>
+#include<string.h>
+// #include "colpic3.h"
+namespace Slic3r::GCodeThumbnails {
+
+using namespace std::literals;
+
+struct CompressedPNG : CompressedImageBuffer 
+{
+    ~CompressedPNG() override { if (data) mz_free(data); }
+    std::string_view tag() const override { return "thumbnail"sv; }
+};
+
+struct CompressedJPG : CompressedImageBuffer
+{
+    ~CompressedJPG() override { free(data); }
+    std::string_view tag() const override { return "thumbnail_JPG"sv; }
+};
+
+struct CompressedQOI : CompressedImageBuffer 
+{
+    ~CompressedQOI() override { free(data); }
+    std::string_view tag() const override { return "thumbnail_QOI"sv; }
+};
+
+
+std::unique_ptr<CompressedImageBuffer> compress_thumbnail_png(
+    const ThumbnailData& data){
+    auto out = std::make_unique<CompressedPNG>();
+     out->data = tdefl_write_image_to_png_file_in_memory_ex((const
+     void*)data.pixels.data(), data.width, data.height, 4, &out->size,
+     MZ_DEFAULT_LEVEL, 1);
+    return out;
+}
+// B3
+std::string compress_qidi_thumbnail_png(const ThumbnailData &data)
+{
+    auto out = std::make_unique<CompressedPNG>();
+    //BOOST_LOG_TRIVIAL(error) << data.width;
+    int width = int(data.width);
+    int height = int(data.height);
+
+    if (data.width * data.height > 500 * 500) {
+        width  = 500;
+        height = 500;
+    }
+    U16 color16[500*500];
+    //U16 *color16 = new U16[data.width * data.height];
+    //for (int i = 0; i < 200*200; i++) color16[i] = 522240;
+    unsigned char outputdata[500 * 500 * 10];
+    //unsigned char *outputdata = new unsigned char[data.width * data.height * 10];
+
+    std::vector<uint8_t> rgba_pixels(data.pixels.size() * 4);
+    size_t  row_size = width * 4; 
+    for (size_t y = 0; y <height; ++y)
+        memcpy(rgba_pixels.data() + (height - y - 1) * row_size,
+               data.pixels.data() + y * row_size, row_size);
+    const unsigned char *pixels;
+    pixels = (const unsigned char *) rgba_pixels.data();
+    int rrrr=0, gggg=0, bbbb=0, aaaa=0,rgb=0;
+
+    int time = width * height-1; // 200*200-1;
+
+    for (unsigned int r = 0; r < height; ++r) {
+        unsigned int rr = (height - 1 - r) * width;
+        for (unsigned int c = 0; c < width; ++c) {
+            rrrr = int(pixels[4 * (rr + c) + 0]) >> 3;
+            gggg = int(pixels[4 * (rr + c) + 1]) >> 2;
+            bbbb = int(pixels[4 * (rr + c) + 2]) >> 3;
+            aaaa = int(pixels[4 * (rr + c) + 3]);
+            if (aaaa == 0) {
+                rrrr = 239 >> 3;
+                gggg = 243 >> 2;
+                bbbb = 247 >> 3;
+            }
+            rgb  = (rrrr << 11) | (gggg << 5) | bbbb;
+            color16[time--] = rgb;
+        }
+    }
+
+    int res = ColPic_EncodeStr(color16, width, height, outputdata,
+                               height * width * 10,
+                               1024);
+    std::string temp;
+
+    //for (unsigned char i : outputdata) { temp += i; }
+    for (unsigned int i = 0; i < sizeof(outputdata); ++i) {
+            temp +=outputdata[i];
+        // unsigned char strr = outputdata[i];
+        // temp += strr;
+    }
+    //out->data = tdefl_write_image_to_png_file_in_memory_ex((const void*)data.pixels.data(), data.width, data.height, 4, &out->size, MZ_DEFAULT_LEVEL, 1);
+    return temp;
+}
+
+std::unique_ptr<CompressedImageBuffer> compress_thumbnail_jpg(const ThumbnailData& data)
+{
+    // Take vector of RGBA pixels and flip the image vertically
+    std::vector<unsigned char> rgba_pixels(data.pixels.size());
+    const unsigned int row_size = data.width * 4;
+    for (unsigned int y = 0; y < data.height; ++y) {
+        ::memcpy(rgba_pixels.data() + (data.height - y - 1) * row_size, data.pixels.data() + y * row_size, row_size);
+    }
+
+    // Store pointers to scanlines start for later use
+    std::vector<unsigned char*> rows_ptrs;
+    rows_ptrs.reserve(data.height);
+    for (unsigned int y = 0; y < data.height; ++y) {
+        rows_ptrs.emplace_back(&rgba_pixels[y * row_size]);
+    }
+
+    std::vector<unsigned char> compressed_data(data.pixels.size());
+    unsigned char* compressed_data_ptr = compressed_data.data();
+    unsigned long compressed_data_size = data.pixels.size();
+
+    jpeg_error_mgr err;
+    jpeg_compress_struct info;
+    info.err = jpeg_std_error(&err);
+    jpeg_create_compress(&info);
+    jpeg_mem_dest(&info, &compressed_data_ptr, &compressed_data_size);
+
+    info.image_width = data.width;
+    info.image_height = data.height;
+    info.input_components = 4;
+    info.in_color_space = JCS_EXT_RGBA;
+
+    jpeg_set_defaults(&info);
+    jpeg_set_quality(&info, 85, TRUE);
+    jpeg_start_compress(&info, TRUE);
+
+    jpeg_write_scanlines(&info, rows_ptrs.data(), data.height);
+    jpeg_finish_compress(&info);
+    jpeg_destroy_compress(&info);
+
+    // FIXME -> Add error checking
+
+    auto out = std::make_unique<CompressedJPG>();
+    out->data = malloc(compressed_data_size);
+    out->size = size_t(compressed_data_size);
+    ::memcpy(out->data, (const void*)compressed_data.data(), out->size);
+    return out;
+}
+
+std::unique_ptr<CompressedImageBuffer> compress_thumbnail_qoi(const ThumbnailData &data)
+{
+    qoi_desc desc;
+    desc.width      = data.width;
+    desc.height     = data.height;
+    desc.channels   = 4;
+    desc.colorspace = QOI_SRGB;
+
+    // Take vector of RGBA pixels and flip the image vertically
+    std::vector<uint8_t> rgba_pixels(data.pixels.size() * 4);
+    size_t row_size = data.width * 4;
+    for (size_t y = 0; y < data.height; ++ y)
+        memcpy(rgba_pixels.data() + (data.height - y - 1) * row_size, data.pixels.data() + y * row_size, row_size);
+    
+    auto out = std::make_unique<CompressedQOI>();
+    int  size;
+    out->data = qoi_encode((const void*)rgba_pixels.data(), &desc, &size);
+    out->size = size;
+    return out;
+}
+
+//B3
+std::string compress_qidi_thumbnail(const ThumbnailData& data,
+    GCodeThumbnailsFormat format)
+{
+    return compress_qidi_thumbnail_png(data);
+}
+
+//B3
+std::unique_ptr<CompressedImageBuffer> compress_thumbnail(const ThumbnailData &data, GCodeThumbnailsFormat format)
+{
+    switch (format) {
+        case GCodeThumbnailsFormat::PNG:
+        default:
+            return compress_thumbnail_png(data);
+        case GCodeThumbnailsFormat::JPG:
+            return compress_thumbnail_jpg(data);
+        case GCodeThumbnailsFormat::QOI:
+            return compress_thumbnail_qoi(data);
+    }
+}
+static void colmemmove(U8 *dec, U8 *src, int lenth)
+{
+    if (src < dec) {
+        dec += lenth - 1;
+        src += lenth - 1;
+        while (lenth > 0) {
+            *(dec--) = *(src--);
+            lenth--;
+        }
+    } else {
+        while (lenth > 0) {
+            *(dec++) = *(src++);
+            lenth--;
+        }
+    }
+}
+static void colmemcpy(U8 *dec, U8 *src, int lenth)
+{
+    while (lenth > 0) {
+        *(dec++) = *(src++);
+        lenth--;
+    }
+}
+static void colmemset(U8 *dec, U8 val, int lenth)
+{
+    while (lenth > 0) {
+        *(dec++) = val;
+        lenth--;
+    }
+}
+static void ADList0(U16 val, U16HEAD *listu16, int *listqty, int maxqty)
+{
+    U8  A0;
+    U8  A1;
+    U8  A2;
+    int qty = *listqty;
+    if (qty >= maxqty) return;
+    for (int i = 0; i < qty; i++) {
+        if (listu16[i].colo16 == val) {
+            listu16[i].qty++;
+            return;
+        }
+    }
+    A0         = (U8) (val >> 11);
+    A1         = (U8) ((val << 5) >> 10);
+    A2         = (U8) ((val << 11) >> 11);
+    U16HEAD *a = &listu16[qty];
+    a->colo16  = val;
+    a->A0      = A0;
+    a->A1      = A1;
+    a->A2      = A2;
+    a->qty     = 1;
+    *listqty   = qty + 1;
+}
+static int Byte8bitEncode(U16 *fromcolor16,
+                          U16 *listu16,
+                          int  listqty,
+                          int  dotsqty,
+                          U8 * outputdata,
+                          int  decMaxBytesize)
+{
+    U8  tid, sid;
+    int dots     = 0;
+    int srcindex = 0;
+    int decindex = 0;
+    int lastid   = 0;
+    int temp     = 0;
+    while (dotsqty > 0) {
+        dots = 1;
+        for (int i = 0; i < (dotsqty - 1); i++) {
+            if (fromcolor16[srcindex + i] != fromcolor16[srcindex + i + 1])
+                break;
+            dots++;
+            if (dots == 255) break;
+        }
+        temp = 0;
+        for (int i = 0; i < listqty; i++) {
+            if (listu16[i] == fromcolor16[srcindex]) {
+                temp = i;
+                break;
+            }
+        }
+        tid = (U8) (temp % 32);
+        sid = (U8) (temp / 32);
+        if (lastid != sid) {
+            if (decindex >= decMaxBytesize) goto IL_END;
+            outputdata[decindex] = 7;
+            outputdata[decindex] <<= 5;
+            outputdata[decindex] += sid;
+            decindex++;
+            lastid = sid;
+        }
+        if (dots <= 6) {
+            if (decindex >= decMaxBytesize) goto IL_END;
+            outputdata[decindex] = (U8) dots;
+            outputdata[decindex] <<= 5;
+            outputdata[decindex] += tid;
+            decindex++;
+        } else {
+            if (decindex >= decMaxBytesize) goto IL_END;
+            outputdata[decindex] = 0;
+            outputdata[decindex] += tid;
+            decindex++;
+            if (decindex >= decMaxBytesize) goto IL_END;
+            outputdata[decindex] = (U8) dots;
+            decindex++;
+        }
+        srcindex += dots;
+        dotsqty -= dots;
+    }
+IL_END:
+    return decindex;
+}
+static int ColPicEncode(U16 *fromcolor16,
+                        int  picw,
+                        int  pich,
+                        U8 * outputdata,
+                        int  outputmaxtsize,
+                        int  colorsmax)
+{
+    U16HEAD      l0;
+    int          cha0, cha1, cha2, fid, minval;
+    ColPicHead3 *Head0 = null;
+    U16HEAD      Listu16[1024];
+    int          ListQty = 0;
+    int          enqty   = 0;
+    int          dotsqty = picw * pich;
+    if (colorsmax > 1024) colorsmax = 1024;
+    for (int i = 0; i < dotsqty; i++) {
+        int ch = (int) fromcolor16[i];
+        ADList0(ch, Listu16, &ListQty, 1024);
+    }
+
+
+    for (int index = 1; index < ListQty; index++) {
+        l0 = Listu16[index];
+        for (int i = 0; i < index; i++) {
+            if (l0.qty >= Listu16[i].qty) {
+                colmemmove((U8 *) &Listu16[i + 1], (U8 *) &Listu16[i],
+                           (index - i) * sizeof(U16HEAD));
+                colmemcpy((U8 *) &Listu16[i], (U8 *) &l0, sizeof(U16HEAD));
+                break;
+            }
+        }
+    }
+    while (ListQty > colorsmax) {
+        l0     = Listu16[ListQty - 1];
+        minval = 255;
+        fid    = -1;
+        for (int i = 0; i < colorsmax; i++) {
+            cha0 = Listu16[i].A0 - l0.A0;
+            if (cha0 < 0) cha0 = 0 - cha0;
+            cha1 = Listu16[i].A1 - l0.A1;
+            if (cha1 < 0) cha1 = 0 - cha1;
+            cha2 = Listu16[i].A2 - l0.A2;
+            if (cha2 < 0) cha2 = 0 - cha2;
+            int chall = cha0 + cha1 + cha2;
+            if (chall < minval) {
+                minval = chall;
+                fid    = i;
+            }
+        }
+        for (int i = 0; i < dotsqty; i++) {
+            if (fromcolor16[i] == l0.colo16)
+                fromcolor16[i] = Listu16[fid].colo16;
+        }
+        ListQty = ListQty - 1;
+    }
+    Head0 = ((ColPicHead3 *) outputdata);
+    colmemset(outputdata, 0, sizeof(ColPicHead3));
+    Head0->encodever    = 3;
+    Head0->oncelistqty  = 0;
+    Head0->mark         = 0x05DDC33C;
+    Head0->ListDataSize = ListQty * 2;
+    for (int i = 0; i < ListQty; i++) {
+        U16 *l0 = (U16 *) &outputdata[sizeof(ColPicHead3)];
+        l0[i]   = Listu16[i].colo16;
+    }
+    enqty =
+        Byte8bitEncode(fromcolor16, (U16 *) &outputdata[sizeof(ColPicHead3)],
+                       Head0->ListDataSize >> 1, dotsqty,
+                       &outputdata[sizeof(ColPicHead3) + Head0->ListDataSize],
+                       outputmaxtsize - sizeof(ColPicHead3) -
+                           Head0->ListDataSize);
+    Head0->ColorDataSize = enqty;
+    Head0->PicW          = picw;
+    Head0->PicH          = pich;
+    return sizeof(ColPicHead3) + Head0->ListDataSize + Head0->ColorDataSize;
+}
+int ColPic_EncodeStr(U16 *fromcolor16,
+                     int  picw,
+                     int  pich,
+                     U8 * outputdata,
+                     int  outputmaxtsize,
+                     int  colorsmax)
+{
+    int qty      = 0;
+    int temp     = 0;
+    int strindex = 0;
+    int hexindex = 0;
+    U8  TempBytes[4];
+    qty = ColPicEncode(fromcolor16, picw, pich, outputdata, outputmaxtsize,
+                       colorsmax);
+    if (qty == 0) return 0;
+    temp = 3 - (qty % 3);
+    while (temp > 0) {
+        outputdata[qty] = 0;
+        qty++;
+        temp--;
+    }
+    if ((qty * 4 / 3) >= outputmaxtsize) return 0;
+    hexindex = qty;
+    strindex = (qty * 4 / 3);
+    while (hexindex > 0) {
+        hexindex -= 3;
+        strindex -= 4;
+
+        TempBytes[0] = (U8) (outputdata[hexindex] >> 2);
+        TempBytes[1] = (U8) (outputdata[hexindex] & 3);
+        TempBytes[1] <<= 4;
+        TempBytes[1] += ((U8) (outputdata[hexindex + 1] >> 4));
+        TempBytes[2] = (U8) (outputdata[hexindex + 1] & 15);
+        TempBytes[2] <<= 2;
+        TempBytes[2] += ((U8) (outputdata[hexindex + 2] >> 6));
+        TempBytes[3] = (U8) (outputdata[hexindex + 2] & 63);
+
+        TempBytes[0] += 48;
+        if (TempBytes[0] == (U8) '\\') TempBytes[0] = 126;
+        TempBytes[0 + 1] += 48;
+        if (TempBytes[0 + 1] == (U8) '\\') TempBytes[0 + 1] = 126;
+        TempBytes[0 + 2] += 48;
+        if (TempBytes[0 + 2] == (U8) '\\') TempBytes[0 + 2] = 126;
+        TempBytes[0 + 3] += 48;
+        if (TempBytes[0 + 3] == (U8) '\\') TempBytes[0 + 3] = 126;
+
+        outputdata[strindex]     = TempBytes[0];
+        outputdata[strindex + 1] = TempBytes[1];
+        outputdata[strindex + 2] = TempBytes[2];
+        outputdata[strindex + 3] = TempBytes[3];
+    }
+    qty             = qty * 4 / 3;
+    outputdata[qty] = 0;
+    return qty;
+}
+
+} // namespace Slic3r::GCodeThumbnails

src/libslic3r/GCode/Thumbnails.hpp

@@ -0,0 +1,136 @@
+#ifndef slic3r_GCodeThumbnails_hpp_
+#define slic3r_GCodeThumbnails_hpp_
+
+#include "../Point.hpp"
+#include "../PrintConfig.hpp"
+#include "ThumbnailData.hpp"
+
+#include <vector>
+#include <memory>
+#include <string_view>
+
+#include <boost/beast/core/detail/base64.hpp>
+
+#include "DataType.h"
+
+typedef struct
+{
+    U16 colo16;
+    U8 A0;
+    U8 A1;
+    U8 A2;
+    U8 res0;
+    U16 res1;
+    U32 qty;
+}U16HEAD;
+typedef struct
+{
+    U8 encodever;
+    U8 res0;
+    U16 oncelistqty;
+    U32 PicW;
+    U32 PicH;
+    U32 mark;
+    U32 ListDataSize;
+    U32 ColorDataSize;
+    U32 res1;
+    U32 res2;
+}ColPicHead3;
+
+namespace Slic3r::GCodeThumbnails {
+
+struct CompressedImageBuffer
+{
+    void       *data { nullptr };
+    size_t      size { 0 };
+    virtual ~CompressedImageBuffer() {}
+    virtual std::string_view tag() const = 0;
+};
+
+std::unique_ptr<CompressedImageBuffer> compress_thumbnail(const ThumbnailData &data, GCodeThumbnailsFormat format);
+//B3
+std::string compress_qidi_thumbnail(
+    const ThumbnailData &data, GCodeThumbnailsFormat format);
+int ColPic_EncodeStr(U16* fromcolor16, int picw, int pich, U8* outputdata, int outputmaxtsize, int colorsmax);
+template<typename WriteToOutput, typename ThrowIfCanceledCallback>
+inline void export_thumbnails_to_file(ThumbnailsGeneratorCallback &thumbnail_cb, const std::vector<Vec2d> &sizes, GCodeThumbnailsFormat format, WriteToOutput output, ThrowIfCanceledCallback throw_if_canceled)
+{
+    // Write thumbnails using base64 encoding
+    if (thumbnail_cb != nullptr) {
+        static constexpr const size_t max_row_length = 78;
+        // ThumbnailsList thumbnails = thumbnail_cb(ThumbnailsParams{ sizes, true, true, true, true });
+        //B3
+        ThumbnailsList thumbnails = thumbnail_cb(ThumbnailsParams{ sizes, false, false, false, true });
+        int count = 0;
+        for (const ThumbnailData& data : thumbnails)
+            if (data.is_valid()) {
+                //B3
+                switch (format) {
+                case GCodeThumbnailsFormat::QIDI:
+                {
+                    auto compressed = compress_qidi_thumbnail(data,
+                                                                  format);
+                    if (count == 0) {
+                        output(
+                            (boost::format("\n\n;gimage:%s\n\n") % compressed)
+                                .str()
+                                .c_str());
+                        count++;
+                        break;
+                    } else {
+                        output(
+                            (boost::format("\n\n;simage:%s\n\n") % compressed)
+                                .str()
+                                .c_str());
+                        count++;
+                        break;
+                    }
+                }
+                case GCodeThumbnailsFormat::JPG:
+                default: {
+                    auto compressed = compress_thumbnail(data, format);
+                    if (compressed->data && compressed->size) {
+                        std::string encoded;
+                        encoded.resize(
+                            boost::beast::detail::base64::encoded_size(
+                                compressed->size));
+                        encoded.resize(boost::beast::detail::base64::encode(
+                            (void *) encoded.data(),
+                            (const void *) compressed->data,
+                            compressed->size));
+                        output((boost::format("\n;\n; %s begin %dx%d %d\n") %
+                                compressed->tag() % data.width % data.height %
+                                encoded.size())
+                                   .str()
+                                   .c_str());
+
+                        while (encoded.size() > max_row_length) {
+                            output((boost::format("; %s\n") %
+                                    encoded.substr(0, max_row_length))
+                                       .str()
+                                       .c_str());
+                            encoded = encoded.substr(max_row_length);
+                        }
+
+                        if (encoded.size() > 0)
+                            output((boost::format("; %s\n") % encoded)
+                                       .str()
+                                       .c_str());
+
+                        output((boost::format("; %s end\n;\n") %
+                                compressed->tag())
+                                   .str()
+                                   .c_str());
+                    }
+                }
+
+                }
+
+                throw_if_canceled();
+            }
+    }
+}
+
+} // namespace Slic3r::GCodeThumbnails
+
+#endif // slic3r_GCodeThumbnails_hpp_

src/libslic3r/GCode/ToolOrdering.cpp

@@ -0,0 +1,834 @@
+#include "Print.hpp"
+#include "ToolOrdering.hpp"
+#include "Layer.hpp"
+
+// #define SLIC3R_DEBUG
+
+// Make assert active if SLIC3R_DEBUG
+#ifdef SLIC3R_DEBUG
+    #define DEBUG
+    #define _DEBUG
+    #undef NDEBUG
+#endif
+
+#include <cassert>
+#include <limits>
+
+#include <boost/log/trivial.hpp>
+
+#include <libslic3r.h>
+
+namespace Slic3r {
+
+
+// Returns true in case that extruder a comes before b (b does not have to be present). False otherwise.
+bool LayerTools::is_extruder_order(unsigned int a, unsigned int b) const
+{
+    if (a == b)
+        return false;
+
+    for (auto extruder : extruders) {
+        if (extruder == a)
+            return true;
+        if (extruder == b)
+            return false;
+    }
+
+    return false;
+}
+
+// Return a zero based extruder from the region, or extruder_override if overriden.
+unsigned int LayerTools::perimeter_extruder(const PrintRegion &region) const
+{
+	assert(region.config().perimeter_extruder.value > 0);
+	return ((this->extruder_override == 0) ? region.config().perimeter_extruder.value : this->extruder_override) - 1;
+}
+
+unsigned int LayerTools::infill_extruder(const PrintRegion &region) const
+{
+	assert(region.config().infill_extruder.value > 0);
+	return ((this->extruder_override == 0) ? region.config().infill_extruder.value : this->extruder_override) - 1;
+}
+
+unsigned int LayerTools::solid_infill_extruder(const PrintRegion &region) const
+{
+	assert(region.config().solid_infill_extruder.value > 0);
+	return ((this->extruder_override == 0) ? region.config().solid_infill_extruder.value : this->extruder_override) - 1;
+}
+
+// Returns a zero based extruder this eec should be printed with, according to PrintRegion config or extruder_override if overriden.
+unsigned int LayerTools::extruder(const ExtrusionEntityCollection &extrusions, const PrintRegion &region) const
+{
+	assert(region.config().perimeter_extruder.value > 0);
+	assert(region.config().infill_extruder.value > 0);
+	assert(region.config().solid_infill_extruder.value > 0);
+	// 1 based extruder ID.
+	unsigned int extruder = this->extruder_override == 0 ?
+	    (extrusions.role().is_infill() ?
+	    	(extrusions.entities.front()->role().is_solid_infill() ? region.config().solid_infill_extruder : region.config().infill_extruder) :
+			region.config().perimeter_extruder.value) :
+		this->extruder_override;
+	return (extruder == 0) ? 0 : extruder - 1;
+}
+
+static double calc_max_layer_height(const PrintConfig &config, double max_object_layer_height)
+{
+    double max_layer_height = std::numeric_limits<double>::max();
+    for (size_t i = 0; i < config.nozzle_diameter.values.size(); ++ i) {
+        double mlh = config.max_layer_height.get_at(i);
+        if (mlh == 0.)
+            mlh = 0.75 * config.nozzle_diameter.values[i];
+        max_layer_height = std::min(max_layer_height, mlh);
+    }
+    // The QIDI3D Fast (0.35mm layer height) print profile sets a higher layer height than what is normally allowed
+    // by the nozzle. This is a hack and it works by increasing extrusion width. See GH #3919.
+    return std::max(max_layer_height, max_object_layer_height);
+}
+
+// For the use case when each object is printed separately
+// (print.config().complete_objects is true).
+ToolOrdering::ToolOrdering(const PrintObject &object, unsigned int first_extruder, bool prime_multi_material)
+{
+    if (object.layers().empty())
+        return;
+
+    // Initialize the print layers for just a single object.
+    {
+        std::vector<coordf_t> zs;
+        zs.reserve(zs.size() + object.layers().size() + object.support_layers().size());
+        for (auto layer : object.layers())
+            zs.emplace_back(layer->print_z);
+        for (auto layer : object.support_layers())
+            zs.emplace_back(layer->print_z);
+        this->initialize_layers(zs);
+    }
+    double max_layer_height = calc_max_layer_height(object.print()->config(), object.config().layer_height);
+
+    // Collect extruders required to print the layers.
+    this->collect_extruders(object, std::vector<std::pair<double, unsigned int>>());
+
+    // Reorder the extruders to minimize tool switches.
+    this->reorder_extruders(first_extruder);
+
+    this->fill_wipe_tower_partitions(object.print()->config(), object.layers().front()->print_z - object.layers().front()->height, max_layer_height);
+
+    this->collect_extruder_statistics(prime_multi_material);
+
+    this->mark_skirt_layers(object.print()->config(), max_layer_height);
+}
+
+// For the use case when all objects are printed at once.
+// (print.config().complete_objects is false).
+ToolOrdering::ToolOrdering(const Print &print, unsigned int first_extruder, bool prime_multi_material)
+{
+    m_print_config_ptr = &print.config();
+
+    // Initialize the print layers for all objects and all layers.
+    coordf_t object_bottom_z = 0.;
+    coordf_t max_layer_height = 0.;
+    {
+        std::vector<coordf_t> zs;
+        for (auto object : print.objects()) {
+            zs.reserve(zs.size() + object->layers().size() + object->support_layers().size());
+            for (auto layer : object->layers())
+                zs.emplace_back(layer->print_z);
+            for (auto layer : object->support_layers())
+                zs.emplace_back(layer->print_z);
+
+            // Find first object layer that is not empty and save its print_z
+            for (const Layer* layer : object->layers())
+                if (layer->has_extrusions()) {
+                    object_bottom_z = layer->print_z - layer->height;
+                    break;
+                }
+
+            max_layer_height = std::max(max_layer_height, object->config().layer_height.value);
+        }
+        this->initialize_layers(zs);
+    }
+    max_layer_height = calc_max_layer_height(print.config(), max_layer_height);
+
+	// Use the extruder switches from Model::custom_gcode_per_print_z to override the extruder to print the object.
+	// Do it only if all the objects were configured to be printed with a single extruder.
+	std::vector<std::pair<double, unsigned int>> per_layer_extruder_switches;
+	if (auto num_extruders = unsigned(print.config().nozzle_diameter.size());
+		num_extruders > 1 && print.object_extruders().size() == 1 && // the current Print's configuration is CustomGCode::MultiAsSingle
+		print.model().custom_gcode_per_print_z.mode == CustomGCode::MultiAsSingle) {
+		// Printing a single extruder platter on a printer with more than 1 extruder (or single-extruder multi-material).
+		// There may be custom per-layer tool changes available at the model.
+		per_layer_extruder_switches = custom_tool_changes(print.model().custom_gcode_per_print_z, num_extruders);
+	}
+
+    // Collect extruders reuqired to print the layers.
+    for (auto object : print.objects())
+        this->collect_extruders(*object, per_layer_extruder_switches);
+
+    // Reorder the extruders to minimize tool switches.
+    this->reorder_extruders(first_extruder);
+
+    this->fill_wipe_tower_partitions(print.config(), object_bottom_z, max_layer_height);
+
+    if (this->insert_wipe_tower_extruder()) {
+        this->reorder_extruders(first_extruder);
+        this->fill_wipe_tower_partitions(print.config(), object_bottom_z, max_layer_height);
+    }
+
+    this->collect_extruder_statistics(prime_multi_material);
+
+    this->mark_skirt_layers(print.config(), max_layer_height);
+}
+
+void ToolOrdering::initialize_layers(std::vector<coordf_t> &zs)
+{
+    sort_remove_duplicates(zs);
+    // Merge numerically very close Z values.
+    for (size_t i = 0; i < zs.size();) {
+        // Find the last layer with roughly the same print_z.
+        size_t j = i + 1;
+        coordf_t zmax = zs[i] + EPSILON;
+        for (; j < zs.size() && zs[j] <= zmax; ++ j) ;
+        // Assign an average print_z to the set of layers with nearly equal print_z.
+        m_layer_tools.emplace_back(LayerTools(0.5 * (zs[i] + zs[j-1])));
+        i = j;
+    }
+}
+
+// Decides whether this entity could be overridden
+[[nodiscard]] static bool is_overriddable(const ExtrusionEntityCollection& eec, const LayerTools& lt, const PrintConfig& print_config, const PrintObject& object, const PrintRegion& region)
+{
+    if (print_config.filament_soluble.get_at(lt.extruder(eec, region)))
+        return false;
+
+    if (object.config().wipe_into_objects)
+        return true;
+
+    if (!region.config().wipe_into_infill || eec.role() != ExtrusionRole::InternalInfill)
+        return false;
+
+    return true;
+}
+
+// Collect extruders reuqired to print layers.
+void ToolOrdering::collect_extruders(const PrintObject &object, const std::vector<std::pair<double, unsigned int>> &per_layer_extruder_switches)
+{
+    // Collect the support extruders.
+    for (auto support_layer : object.support_layers()) {
+        LayerTools   &layer_tools = this->tools_for_layer(support_layer->print_z);
+        ExtrusionRole role = support_layer->support_fills.role();
+        bool         has_support        = role == ExtrusionRole::Mixed || role == ExtrusionRole::SupportMaterial;
+        bool         has_interface      = role == ExtrusionRole::Mixed || role == ExtrusionRole::SupportMaterialInterface;
+        unsigned int extruder_support   = object.config().support_material_extruder.value;
+        unsigned int extruder_interface = object.config().support_material_interface_extruder.value;
+        if (has_support)
+            layer_tools.extruders.push_back(extruder_support);
+        if (has_interface)
+            layer_tools.extruders.push_back(extruder_interface);
+        if (has_support || has_interface)
+            layer_tools.has_support = true;
+    }
+
+    // Extruder overrides are ordered by print_z.
+    std::vector<std::pair<double, unsigned int>>::const_iterator it_per_layer_extruder_override;
+	it_per_layer_extruder_override = per_layer_extruder_switches.begin();
+    unsigned int extruder_override = 0;
+
+    // Collect the object extruders.
+    for (auto layer : object.layers()) {
+        LayerTools &layer_tools = this->tools_for_layer(layer->print_z);
+
+        // Override extruder with the next 
+    	for (; it_per_layer_extruder_override != per_layer_extruder_switches.end() && it_per_layer_extruder_override->first < layer->print_z + EPSILON; ++ it_per_layer_extruder_override)
+    		extruder_override = (int)it_per_layer_extruder_override->second;
+
+        // Store the current extruder override (set to zero if no overriden), so that layer_tools.wiping_extrusions().is_overridable_and_mark() will use it.
+        layer_tools.extruder_override = extruder_override;
+
+        // What extruders are required to print this object layer?
+        for (const LayerRegion *layerm : layer->regions()) {
+            const PrintRegion &region = layerm->region();
+
+            if (! layerm->perimeters().empty()) {
+                bool something_nonoverriddable = true;
+
+                if (m_print_config_ptr) { // in this case complete_objects is false (see ToolOrdering constructors)
+                    something_nonoverriddable = false;
+                    for (const ExtrusionEntity *eec : layerm->perimeters()) // let's check if there are nonoverriddable entities
+                        if (is_overriddable(dynamic_cast<const ExtrusionEntityCollection&>(*eec), layer_tools, *m_print_config_ptr, object, region))
+                            layer_tools.wiping_extrusions_nonconst().set_something_overridable();
+                        else
+                            something_nonoverriddable = true;
+                }
+
+                if (something_nonoverriddable)
+               		layer_tools.extruders.emplace_back(extruder_override == 0 ? region.config().perimeter_extruder.value : extruder_override);
+
+                layer_tools.has_object = true;
+            }
+
+            bool has_infill       = false;
+            bool has_solid_infill = false;
+            bool something_nonoverriddable = false;
+            for (const ExtrusionEntity *ee : layerm->fills()) {
+                // fill represents infill extrusions of a single island.
+                const auto *fill = dynamic_cast<const ExtrusionEntityCollection*>(ee);
+                ExtrusionRole role = fill->entities.empty() ? ExtrusionRole::None : fill->entities.front()->role();
+                if (role.is_solid_infill())
+                    has_solid_infill = true;
+                else if (role != ExtrusionRole::None)
+                    has_infill = true;
+
+                if (m_print_config_ptr) {
+                    if (is_overriddable(*fill, layer_tools, *m_print_config_ptr, object, region))
+                        layer_tools.wiping_extrusions_nonconst().set_something_overridable();
+                    else
+                        something_nonoverriddable = true;
+                }
+            }
+
+            if (something_nonoverriddable || !m_print_config_ptr) {
+            	if (extruder_override == 0) {
+	                if (has_solid_infill)
+	                    layer_tools.extruders.emplace_back(region.config().solid_infill_extruder);
+	                if (has_infill)
+	                    layer_tools.extruders.emplace_back(region.config().infill_extruder);
+            	} else if (has_solid_infill || has_infill)
+            		layer_tools.extruders.emplace_back(extruder_override);
+            }
+            if (has_solid_infill || has_infill)
+                layer_tools.has_object = true;
+        }
+    }
+
+    for (auto& layer : m_layer_tools) {
+        // Sort and remove duplicates
+        sort_remove_duplicates(layer.extruders);
+
+        // make sure that there are some tools for each object layer (e.g. tall wiping object will result in empty extruders vector)
+        if (layer.extruders.empty() && layer.has_object)
+            layer.extruders.emplace_back(0); // 0="dontcare" extruder - it will be taken care of in reorder_extruders
+    }
+}
+
+// Reorder extruders to minimize layer changes.
+void ToolOrdering::reorder_extruders(unsigned int last_extruder_id)
+{
+    if (m_layer_tools.empty())
+        return;
+
+    if (last_extruder_id == (unsigned int)-1) {
+        // The initial print extruder has not been decided yet.
+        // Initialize the last_extruder_id with the first non-zero extruder id used for the print.
+        last_extruder_id = 0;
+        for (size_t i = 0; i < m_layer_tools.size() && last_extruder_id == 0; ++ i) {
+            const LayerTools &lt = m_layer_tools[i];
+            for (unsigned int extruder_id : lt.extruders)
+                if (extruder_id > 0) {
+                    last_extruder_id = extruder_id;
+                    break;
+                }
+        }
+        if (last_extruder_id == 0)
+            // Nothing to extrude.
+            return;
+    } else
+        // 1 based index
+        ++ last_extruder_id;
+
+    for (LayerTools &lt : m_layer_tools) {
+        if (lt.extruders.empty())
+            continue;
+        if (lt.extruders.size() == 1 && lt.extruders.front() == 0)
+            lt.extruders.front() = last_extruder_id;
+        else {
+            if (lt.extruders.front() == 0)
+                // Pop the "don't care" extruder, the "don't care" region will be merged with the next one.
+                lt.extruders.erase(lt.extruders.begin());
+            // Reorder the extruders to start with the last one.
+            for (size_t i = 1; i < lt.extruders.size(); ++ i)
+                if (lt.extruders[i] == last_extruder_id) {
+                    // Move the last extruder to the front.
+                    memmove(lt.extruders.data() + 1, lt.extruders.data(), i * sizeof(unsigned int));
+                    lt.extruders.front() = last_extruder_id;
+                    break;
+                }
+
+            // On first layer with wipe tower, prefer a soluble extruder
+            // at the beginning, so it is not wiped on the first layer.
+            if (lt == m_layer_tools[0] && m_print_config_ptr && m_print_config_ptr->wipe_tower) {
+                for (size_t i = 0; i<lt.extruders.size(); ++i)
+                    if (m_print_config_ptr->filament_soluble.get_at(lt.extruders[i]-1)) { // 1-based...
+                        std::swap(lt.extruders[i], lt.extruders.front());
+                        break;
+                    }
+            }
+        }
+        last_extruder_id = lt.extruders.back();
+    }
+
+    // Reindex the extruders, so they are zero based, not 1 based.
+    for (LayerTools &lt : m_layer_tools)
+        for (unsigned int &extruder_id : lt.extruders) {
+            assert(extruder_id > 0);
+            -- extruder_id;
+        }    
+}
+
+void ToolOrdering::fill_wipe_tower_partitions(const PrintConfig &config, coordf_t object_bottom_z, coordf_t max_layer_height)
+{
+    if (m_layer_tools.empty())
+        return;
+
+    // Count the minimum number of tool changes per layer.
+    size_t last_extruder = size_t(-1);
+    for (LayerTools &lt : m_layer_tools) {
+        lt.wipe_tower_partitions = lt.extruders.size();
+        if (! lt.extruders.empty()) {
+            if (last_extruder == size_t(-1) || last_extruder == lt.extruders.front())
+                // The first extruder on this layer is equal to the current one, no need to do an initial tool change.
+                -- lt.wipe_tower_partitions;
+            last_extruder = lt.extruders.back();
+        }
+    }
+
+    // Propagate the wipe tower partitions down to support the upper partitions by the lower partitions.
+    for (int i = int(m_layer_tools.size()) - 2; i >= 0; -- i)
+        m_layer_tools[i].wipe_tower_partitions = std::max(m_layer_tools[i + 1].wipe_tower_partitions, m_layer_tools[i].wipe_tower_partitions);
+
+    //FIXME this is a hack to get the ball rolling.
+    for (LayerTools &lt : m_layer_tools)
+        lt.has_wipe_tower = (lt.has_object && lt.wipe_tower_partitions > 0) || lt.print_z < object_bottom_z + EPSILON;
+
+    // Test for a raft, insert additional wipe tower layer to fill in the raft separation gap.
+    for (size_t i = 0; i + 1 < m_layer_tools.size(); ++ i) {
+        const LayerTools &lt      = m_layer_tools[i];
+        const LayerTools &lt_next = m_layer_tools[i + 1];
+        if (lt.print_z < object_bottom_z + EPSILON && lt_next.print_z >= object_bottom_z + EPSILON) {
+            // lt is the last raft layer. Find the 1st object layer.
+            size_t j = i + 1;
+            for (; j < m_layer_tools.size() && ! m_layer_tools[j].has_wipe_tower; ++ j);
+            if (j < m_layer_tools.size()) {
+                const LayerTools &lt_object = m_layer_tools[j];
+                coordf_t gap = lt_object.print_z - lt.print_z;
+                assert(gap > 0.f);
+                if (gap > max_layer_height + EPSILON) {
+                    // Insert one additional wipe tower layer between lh.print_z and lt_object.print_z.
+                    LayerTools lt_new(0.5f * (lt.print_z + lt_object.print_z));
+                    // Find the 1st layer above lt_new.
+                    for (j = i + 1; j < m_layer_tools.size() && m_layer_tools[j].print_z < lt_new.print_z - EPSILON; ++ j);
+                    if (std::abs(m_layer_tools[j].print_z - lt_new.print_z) < EPSILON) {
+						m_layer_tools[j].has_wipe_tower = true;
+					} else {
+						LayerTools &lt_extra = *m_layer_tools.insert(m_layer_tools.begin() + j, lt_new);
+                        //LayerTools &lt_prev  = m_layer_tools[j];
+                        LayerTools &lt_next  = m_layer_tools[j + 1];
+                        assert(! m_layer_tools[j - 1].extruders.empty() && ! lt_next.extruders.empty());
+                        // FIXME: Following assert tripped when running combine_infill.t. I decided to comment it out for now.
+                        // If it is a bug, it's likely not critical, because this code is unchanged for a long time. It might
+                        // still be worth looking into it more and decide if it is a bug or an obsolete assert.
+                        //assert(lt_prev.extruders.back() == lt_next.extruders.front());
+                        lt_extra.has_wipe_tower = true;
+                        lt_extra.extruders.push_back(lt_next.extruders.front());
+                        lt_extra.wipe_tower_partitions = lt_next.wipe_tower_partitions;
+                    }
+                }
+            }
+            break;
+        }
+    }
+
+    // If the model contains empty layers (such as https://github.com/qidi3d/Slic3r/issues/1266), there might be layers
+    // that were not marked as has_wipe_tower, even when they should have been. This produces a crash with soluble supports
+    // and maybe other problems. We will therefore go through layer_tools and detect and fix this.
+    // So, if there is a non-object layer starting with different extruder than the last one ended with (or containing more than one extruder),
+    // we'll mark it with has_wipe tower.
+    for (unsigned int i=0; i+1<m_layer_tools.size(); ++i) {
+        LayerTools& lt = m_layer_tools[i];
+        LayerTools& lt_next = m_layer_tools[i+1];
+        if (lt.extruders.empty() || lt_next.extruders.empty())
+            break;
+        if (!lt_next.has_wipe_tower && (lt_next.extruders.front() != lt.extruders.back() || lt_next.extruders.size() > 1))
+            lt_next.has_wipe_tower = true;
+        // We should also check that the next wipe tower layer is no further than max_layer_height:
+        unsigned int j = i+1;
+        double last_wipe_tower_print_z = lt_next.print_z;
+        while (++j < m_layer_tools.size()-1 && !m_layer_tools[j].has_wipe_tower)
+            if (m_layer_tools[j+1].print_z - last_wipe_tower_print_z > max_layer_height + EPSILON) {
+                m_layer_tools[j].has_wipe_tower = true;
+                last_wipe_tower_print_z = m_layer_tools[j].print_z;
+            }
+    }
+
+    // Calculate the wipe_tower_layer_height values.
+    coordf_t wipe_tower_print_z_last = 0.;
+    for (LayerTools &lt : m_layer_tools)
+        if (lt.has_wipe_tower) {
+            lt.wipe_tower_layer_height = lt.print_z - wipe_tower_print_z_last;
+            wipe_tower_print_z_last = lt.print_z;
+        }
+}
+
+bool ToolOrdering::insert_wipe_tower_extruder()
+{
+    // In case that wipe_tower_extruder is set to non-zero, we must make sure that the extruder will be in the list.
+    bool changed = false;
+    if (m_print_config_ptr->wipe_tower_extruder != 0) {
+        for (LayerTools& lt : m_layer_tools) {
+            if (lt.wipe_tower_partitions > 0) {
+                lt.extruders.emplace_back(m_print_config_ptr->wipe_tower_extruder - 1);
+                sort_remove_duplicates(lt.extruders);
+                changed = true;
+            }
+        }
+        // Now convert the 0-based list to 1-based again.
+        for (LayerTools& lt : m_layer_tools) {
+            for (auto& extruder : lt.extruders)
+                    ++extruder;
+        }
+    }
+    return changed;
+}
+
+void ToolOrdering::collect_extruder_statistics(bool prime_multi_material)
+{
+    m_first_printing_extruder = (unsigned int)-1;
+    for (const auto &lt : m_layer_tools)
+        if (! lt.extruders.empty()) {
+            m_first_printing_extruder = lt.extruders.front();
+            break;
+        }
+
+    m_last_printing_extruder = (unsigned int)-1;
+    for (auto lt_it = m_layer_tools.rbegin(); lt_it != m_layer_tools.rend(); ++ lt_it)
+        if (! lt_it->extruders.empty()) {
+            m_last_printing_extruder = lt_it->extruders.back();
+            break;
+        }
+
+    m_all_printing_extruders.clear();
+    for (const auto &lt : m_layer_tools) {
+        append(m_all_printing_extruders, lt.extruders);
+        sort_remove_duplicates(m_all_printing_extruders);
+    }
+
+    if (prime_multi_material && ! m_all_printing_extruders.empty()) {
+        // Reorder m_all_printing_extruders in the sequence they will be primed, the last one will be m_first_printing_extruder.
+        // Then set m_first_printing_extruder to the 1st extruder primed.
+        m_all_printing_extruders.erase(
+            std::remove_if(m_all_printing_extruders.begin(), m_all_printing_extruders.end(),
+                [ this ](const unsigned int eid) { return eid == m_first_printing_extruder; }),
+            m_all_printing_extruders.end());
+        m_all_printing_extruders.emplace_back(m_first_printing_extruder);
+        m_first_printing_extruder = m_all_printing_extruders.front();
+    }
+}
+
+// Layers are marked for infinite skirt aka draft shield. Not all the layers have to be printed.
+void ToolOrdering::mark_skirt_layers(const PrintConfig &config, coordf_t max_layer_height)
+{
+    if (m_layer_tools.empty())
+        return;
+
+    if (m_layer_tools.front().extruders.empty()) {
+        // Empty first layer, no skirt will be printed.
+        //FIXME throw an exception?
+        return;
+    }
+
+    size_t i = 0;
+    for (;;) {
+        m_layer_tools[i].has_skirt = true;
+        size_t j = i + 1;
+        for (; j < m_layer_tools.size() && ! m_layer_tools[j].has_object; ++ j);
+        // i and j are two successive layers printing an object.
+        if (j == m_layer_tools.size())
+            // Don't print skirt above the last object layer.
+            break;
+        // Mark some printing intermediate layers as having skirt.
+        double last_z = m_layer_tools[i].print_z;
+        for (size_t k = i + 1; k < j; ++ k) {
+            if (m_layer_tools[k + 1].print_z - last_z > max_layer_height + EPSILON) {
+                // Layer k is the last one not violating the maximum layer height.
+                // Don't extrude skirt on empty layers.
+                while (m_layer_tools[k].extruders.empty())
+                    -- k;
+                if (m_layer_tools[k].has_skirt) {
+                    // Skirt cannot be generated due to empty layers, there would be a missing layer in the skirt.
+                    //FIXME throw an exception?
+                    break;
+                }
+                m_layer_tools[k].has_skirt = true;
+                last_z = m_layer_tools[k].print_z;
+            }
+        }
+        i = j;
+    }
+}
+
+// Assign a pointer to a custom G-code to the respective ToolOrdering::LayerTools.
+// Ignore color changes, which are performed on a layer and for such an extruder, that the extruder will not be printing above that layer.
+// If multiple events are planned over a span of a single layer, use the last one.
+void ToolOrdering::assign_custom_gcodes(const Print &print)
+{
+	// Only valid for non-sequential print.
+	assert(! print.config().complete_objects.value);
+
+	const CustomGCode::Info	&custom_gcode_per_print_z = print.model().custom_gcode_per_print_z;
+	if (custom_gcode_per_print_z.gcodes.empty())
+		return;
+
+	auto 						num_extruders = unsigned(print.config().nozzle_diameter.size());
+	CustomGCode::Mode 			mode          =
+		(num_extruders == 1) ? CustomGCode::SingleExtruder :
+		print.object_extruders().size() == 1 ? CustomGCode::MultiAsSingle : CustomGCode::MultiExtruder;
+	CustomGCode::Mode           model_mode    = print.model().custom_gcode_per_print_z.mode;
+	std::vector<unsigned char> 	extruder_printing_above(num_extruders, false);
+	auto 						custom_gcode_it = custom_gcode_per_print_z.gcodes.rbegin();
+	// Tool changes and color changes will be ignored, if the model's tool/color changes were entered in mm mode and the print is in non mm mode
+	// or vice versa.
+	bool 						ignore_tool_and_color_changes = (mode == CustomGCode::MultiExtruder) != (model_mode == CustomGCode::MultiExtruder);
+	// If printing on a single extruder machine, make the tool changes trigger color change (M600) events.
+	bool 						tool_changes_as_color_changes = mode == CustomGCode::SingleExtruder && model_mode == CustomGCode::MultiAsSingle;
+
+	// From the last layer to the first one:
+	for (auto it_lt = m_layer_tools.rbegin(); it_lt != m_layer_tools.rend(); ++ it_lt) {
+		LayerTools &lt = *it_lt;
+		// Add the extruders of the current layer to the set of extruders printing at and above this print_z.
+		for (unsigned int i : lt.extruders)
+			extruder_printing_above[i] = true;
+		// Skip all custom G-codes above this layer and skip all extruder switches.
+		for (; custom_gcode_it != custom_gcode_per_print_z.gcodes.rend() && (custom_gcode_it->print_z > lt.print_z + EPSILON || custom_gcode_it->type == CustomGCode::ToolChange); ++ custom_gcode_it);
+		if (custom_gcode_it == custom_gcode_per_print_z.gcodes.rend())
+			// Custom G-codes were processed.
+			break;
+		// Some custom G-code is configured for this layer or a layer below.
+		const CustomGCode::Item &custom_gcode = *custom_gcode_it;
+		// print_z of the layer below the current layer.
+		coordf_t print_z_below = 0.;
+		if (auto it_lt_below = it_lt; ++ it_lt_below != m_layer_tools.rend())
+			print_z_below = it_lt_below->print_z;
+		if (custom_gcode.print_z > print_z_below + 0.5 * EPSILON) {
+			// The custom G-code applies to the current layer.
+			bool color_change = custom_gcode.type == CustomGCode::ColorChange;
+			bool tool_change  = custom_gcode.type == CustomGCode::ToolChange;
+			bool pause_or_custom_gcode = ! color_change && ! tool_change;
+			bool apply_color_change = ! ignore_tool_and_color_changes &&
+				// If it is color change, it will actually be useful as the exturder above will print.
+				(color_change ? 
+					mode == CustomGCode::SingleExtruder || 
+						(custom_gcode.extruder <= int(num_extruders) && extruder_printing_above[unsigned(custom_gcode.extruder - 1)]) :
+				 	tool_change && tool_changes_as_color_changes);
+			if (pause_or_custom_gcode || apply_color_change)
+        		lt.custom_gcode = &custom_gcode;
+			// Consume that custom G-code event.
+			++ custom_gcode_it;
+		}
+	}
+}
+
+const LayerTools& ToolOrdering::tools_for_layer(coordf_t print_z) const
+{
+    auto it_layer_tools = std::lower_bound(m_layer_tools.begin(), m_layer_tools.end(), LayerTools(print_z - EPSILON));
+    assert(it_layer_tools != m_layer_tools.end());
+    coordf_t dist_min = std::abs(it_layer_tools->print_z - print_z);
+    for (++ it_layer_tools; it_layer_tools != m_layer_tools.end(); ++ it_layer_tools) {
+        coordf_t d = std::abs(it_layer_tools->print_z - print_z);
+        if (d >= dist_min)
+            break;
+        dist_min = d;
+    }
+    -- it_layer_tools;
+    assert(dist_min < EPSILON);
+    return *it_layer_tools;
+}
+
+// This function is called from Print::mark_wiping_extrusions and sets extruder this entity should be printed with (-1 .. as usual)
+void WipingExtrusions::set_extruder_override(const ExtrusionEntity* entity, size_t copy_id, int extruder, size_t num_of_copies)
+{
+    m_something_overridden = true;
+
+    auto entity_map_it = (m_entity_map.emplace(entity, ExtruderPerCopy())).first; // (add and) return iterator
+    ExtruderPerCopy& copies_vector = entity_map_it->second;
+    copies_vector.resize(num_of_copies, -1);
+
+    assert(copies_vector[copy_id] == -1);
+    if (copies_vector[copy_id] != -1)
+        BOOST_LOG_TRIVIAL(error) << "ERROR: Entity extruder overriden multiple times!!!";
+
+    copies_vector[copy_id] = extruder;
+}
+
+// Finds first non-soluble extruder on the layer
+[[nodiscard]] static int first_nonsoluble_extruder_on_layer(const PrintConfig& print_config, const LayerTools& layer_tools)
+{
+    for (auto extruders_it = layer_tools.extruders.begin(); extruders_it != layer_tools.extruders.end(); ++extruders_it)
+        if (!print_config.filament_soluble.get_at(*extruders_it))
+            return (*extruders_it);
+
+    return (-1);
+}
+
+// Finds last non-soluble extruder on the layer
+[[nodiscard]] static int last_nonsoluble_extruder_on_layer(const PrintConfig& print_config, const LayerTools& layer_tools)
+{
+    for (auto extruders_it = layer_tools.extruders.rbegin(); extruders_it != layer_tools.extruders.rend(); ++extruders_it)
+        if (!print_config.filament_soluble.get_at(*extruders_it))
+            return (*extruders_it);
+
+    return (-1);
+}
+
+// Following function iterates through all extrusions on the layer, remembers those that could be used for wiping after toolchange
+// and returns volume that is left to be wiped on the wipe tower.
+// Switching from old_extruder to new_extruder, trying to wipe volume_to_wipe into not yet extruded extrusions, that may change material (overridable).
+float WipingExtrusions::mark_wiping_extrusions(const Print& print, const LayerTools &lt, unsigned int old_extruder, unsigned int new_extruder, float volume_to_wipe)
+{
+    const float min_infill_volume = 0.f; // ignore infill with smaller volume than this
+
+    if (! m_something_overridable || volume_to_wipe <= 0. || 
+        // Don't wipe a soluble filament into another object.
+        print.config().filament_soluble.get_at(old_extruder) || 
+        // Don't prime a soluble filament into another object.
+        print.config().filament_soluble.get_at(new_extruder))
+        // Soluble filament cannot be wiped in a random infill, neither the filament after it
+        return std::max(0.f, volume_to_wipe);
+
+    // we will sort objects so that dedicated for wiping are at the beginning:
+    ConstPrintObjectPtrs object_list(print.objects().begin(), print.objects().end());
+    std::sort(object_list.begin(), object_list.end(), [](const PrintObject* a, const PrintObject* b) { return a->config().wipe_into_objects && ! b->config().wipe_into_objects; });
+
+    // We will now iterate through
+    //  - first the dedicated objects to mark perimeters or infills (depending on infill_first)
+    //  - second through the dedicated ones again to mark infills or perimeters (depending on infill_first)
+    //  - then all the others to mark infills (in case that !infill_first, we must also check that the perimeter is finished already
+    // this is controlled by the following variable:
+    bool perimeters_done = false;
+
+    for (int i=0 ; i<(int)object_list.size() + (perimeters_done ? 0 : 1); ++i) {
+        if (!perimeters_done && (i==(int)object_list.size() || !object_list[i]->config().wipe_into_objects)) { // we passed the last dedicated object in list
+            perimeters_done = true;
+            i=-1;   // let's go from the start again
+            continue;
+        }
+
+        const PrintObject* object = object_list[i];
+
+        // Finds this layer:
+        const Layer* this_layer = object->get_layer_at_printz(lt.print_z, EPSILON);
+        if (this_layer == nullptr)
+        	continue;
+        size_t num_of_copies = object->instances().size();
+
+        // iterate through copies (aka PrintObject instances) first, so that we mark neighbouring infills to minimize travel moves
+        for (unsigned int copy = 0; copy < num_of_copies; ++copy) {
+            for (const LayerRegion *layerm : this_layer->regions()) {
+                const auto &region = layerm->region();
+                if (!region.config().wipe_into_infill && !object->config().wipe_into_objects)
+                    continue;
+
+                bool wipe_into_infill_only = ! object->config().wipe_into_objects && region.config().wipe_into_infill;
+                if (print.config().infill_first != perimeters_done || wipe_into_infill_only) {
+                    for (const ExtrusionEntity* ee : layerm->fills()) { // iterate through all infill Collections
+                        auto* fill = dynamic_cast<const ExtrusionEntityCollection*>(ee);
+
+                        if (!is_overriddable(*fill, lt, print.config(), *object, region))
+                            continue;
+
+                        if (wipe_into_infill_only && ! print.config().infill_first)
+                            // In this case we must check that the original extruder is used on this layer before the one we are overridding
+                            // (and the perimeters will be finished before the infill is printed):
+                            if (!lt.is_extruder_order(lt.perimeter_extruder(region), new_extruder))
+                                continue;
+
+                        if ((!is_entity_overridden(fill, copy) && fill->total_volume() > min_infill_volume)) {     // this infill will be used to wipe this extruder
+                            set_extruder_override(fill, copy, new_extruder, num_of_copies);
+                            if ((volume_to_wipe -= float(fill->total_volume())) <= 0.f)
+                            	// More material was purged already than asked for.
+	                            return 0.f;
+                        }
+                    }
+                }
+
+                // Now the same for perimeters - see comments above for explanation:
+                if (object->config().wipe_into_objects && print.config().infill_first == perimeters_done)
+                {
+                    for (const ExtrusionEntity* ee : layerm->perimeters()) {
+                        auto* fill = dynamic_cast<const ExtrusionEntityCollection*>(ee);
+                        if (is_overriddable(*fill, lt, print.config(), *object, region) && !is_entity_overridden(fill, copy) && fill->total_volume() > min_infill_volume) {
+                            set_extruder_override(fill, copy, new_extruder, num_of_copies);
+                            if ((volume_to_wipe -= float(fill->total_volume())) <= 0.f)
+                            	// More material was purged already than asked for.
+	                            return 0.f;
+                        }
+                    }
+                }
+            }
+        }
+    }
+	// Some purge remains to be done on the Wipe Tower.
+    assert(volume_to_wipe > 0.);
+    return volume_to_wipe;
+}
+
+
+
+// Called after all toolchanges on a layer were mark_infill_overridden. There might still be overridable entities,
+// that were not actually overridden. If they are part of a dedicated object, printing them with the extruder
+// they were initially assigned to might mean violating the perimeter-infill order. We will therefore go through
+// them again and make sure we override it.
+void WipingExtrusions::ensure_perimeters_infills_order(const Print& print, const LayerTools &lt)
+{
+	if (! m_something_overridable)
+		return;
+
+    unsigned int first_nonsoluble_extruder = first_nonsoluble_extruder_on_layer(print.config(), lt);
+    unsigned int last_nonsoluble_extruder = last_nonsoluble_extruder_on_layer(print.config(), lt);
+
+    for (const PrintObject* object : print.objects()) {
+        // Finds this layer:
+        const Layer* this_layer = object->get_layer_at_printz(lt.print_z, EPSILON);
+        if (this_layer == nullptr)
+        	continue;
+        size_t num_of_copies = object->instances().size();
+
+        for (size_t copy = 0; copy < num_of_copies; ++copy) {    // iterate through copies first, so that we mark neighbouring infills to minimize travel moves
+            for (const LayerRegion *layerm : this_layer->regions()) {
+                const auto &region = layerm->region();
+                if (!region.config().wipe_into_infill && !object->config().wipe_into_objects)
+                    continue;
+
+                for (const ExtrusionEntity* ee : layerm->fills()) { // iterate through all infill Collections
+                    auto* fill = dynamic_cast<const ExtrusionEntityCollection*>(ee);
+                    assert(fill);
+
+                    if (!is_overriddable(*fill, lt, print.config(), *object, region)
+                     || is_entity_overridden(fill, copy) )
+                        continue;
+
+                    // This infill could have been overridden but was not - unless we do something, it could be
+                    // printed before its perimeter, or not be printed at all (in case its original extruder has
+                    // not been added to LayerTools
+                    // Either way, we will now force-override it with something suitable:
+                    if (print.config().infill_first
+                    || object->config().wipe_into_objects  // in this case the perimeter is overridden, so we can override by the last one safely
+                    || lt.is_extruder_order(lt.perimeter_extruder(region), last_nonsoluble_extruder)    // !infill_first, but perimeter is already printed when last extruder prints
+                    || ! lt.has_extruder(lt.infill_extruder(region))) // we have to force override - this could violate infill_first (FIXME)
+                        set_extruder_override(fill, copy, (print.config().infill_first ? first_nonsoluble_extruder : last_nonsoluble_extruder), num_of_copies);
+                    else {
+                        // In this case we can (and should) leave it to be printed normally.
+                        // Force overriding would mean it gets printed before its perimeter.
+                    }
+                }
+
+                // Now the same for perimeters - see comments above for explanation:
+                for (const ExtrusionEntity* ee : layerm->perimeters()) { // iterate through all perimeter Collections
+                    auto* fill = dynamic_cast<const ExtrusionEntityCollection*>(ee);
+                    assert(fill);
+                    if (is_overriddable(*fill, lt, print.config(), *object, region) && ! is_entity_overridden(fill, copy))
+                        set_extruder_override(fill, copy, (print.config().infill_first ? last_nonsoluble_extruder : first_nonsoluble_extruder), num_of_copies);
+                }
+            }
+        }
+    }
+}
+
+} // namespace Slic3r

src/libslic3r/GCode/ToolOrdering.hpp

@@ -0,0 +1,187 @@
+// Ordering of the tools to minimize tool switches.
+
+#ifndef slic3r_ToolOrdering_hpp_
+#define slic3r_ToolOrdering_hpp_
+
+#include "../libslic3r.h"
+
+#include <utility>
+#include <cstddef>
+
+#include <boost/container/small_vector.hpp>
+
+namespace Slic3r {
+
+class Print;
+class PrintObject;
+class LayerTools;
+class ToolOrdering;
+namespace CustomGCode { struct Item; }
+class PrintRegion;
+
+// Object of this class holds information about whether an extrusion is printed immediately
+// after a toolchange (as part of infill/perimeter wiping) or not. One extrusion can be a part
+// of several copies - this has to be taken into account.
+class WipingExtrusions
+{
+public:
+    bool is_anything_overridden() const {   // if there are no overrides, all the agenda can be skipped - this function can tell us if that's the case
+        return m_something_overridden;
+    }
+
+    // When allocating extruder overrides of an object's ExtrusionEntity, overrides for maximum 3 copies are allocated in place.
+    using ExtruderPerCopy =
+#ifdef NDEBUG
+        boost::container::small_vector<int32_t, 3>;
+#else // NDEBUG
+        std::vector<int32_t>;
+#endif // NDEBUG
+
+    // This is called from GCode::process_layer_single_object()
+    // Returns positive number if the extruder is overridden.
+    // Returns -1 if not.
+    int get_extruder_override(const ExtrusionEntity* entity, uint32_t instance_id) const {
+        auto entity_map_it = m_entity_map.find(entity);
+        return entity_map_it == m_entity_map.end() ? -1 : entity_map_it->second[instance_id];
+    }
+
+    // This function goes through all infill entities, decides which ones will be used for wiping and
+    // marks them by the extruder id. Returns volume that remains to be wiped on the wipe tower:
+    float mark_wiping_extrusions(const Print& print, const LayerTools& lt, unsigned int old_extruder, unsigned int new_extruder, float volume_to_wipe);
+
+    void ensure_perimeters_infills_order(const Print& print, const LayerTools& lt);
+
+    void set_something_overridable() { m_something_overridable = true; }
+
+private:
+    // This function is called from mark_wiping_extrusions and sets extruder that it should be printed with (-1 .. as usual)
+    void set_extruder_override(const ExtrusionEntity* entity, size_t copy_id, int extruder, size_t num_of_copies);
+
+    // Returns true in case that entity is not printed with its usual extruder for a given copy:
+    bool is_entity_overridden(const ExtrusionEntity* entity, size_t copy_id) const {
+        auto it = m_entity_map.find(entity);
+        return it == m_entity_map.end() ? false : it->second[copy_id] != -1;
+    }
+
+    std::map<const ExtrusionEntity*, ExtruderPerCopy> m_entity_map;  // to keep track of who prints what
+    bool m_something_overridable = false;
+    bool m_something_overridden = false;
+};
+
+class LayerTools
+{
+public:
+    // Changing these operators to epsilon version can make a problem in cases where support and object layers get close to each other.
+    // In case someone tries to do it, make sure you know what you're doing and test it properly (slice multiple objects at once with supports).
+    bool operator< (const LayerTools &rhs) const { return print_z < rhs.print_z; }
+    bool operator==(const LayerTools &rhs) const { return print_z == rhs.print_z; }
+
+    bool is_extruder_order(unsigned int a, unsigned int b) const;
+    bool has_extruder(unsigned int extruder) const { return std::find(this->extruders.begin(), this->extruders.end(), extruder) != this->extruders.end(); }
+
+    // Return a zero based extruder from the region, or extruder_override if overriden.
+    unsigned int perimeter_extruder(const PrintRegion &region) const;
+    unsigned int infill_extruder(const PrintRegion &region) const;
+    unsigned int solid_infill_extruder(const PrintRegion &region) const;
+	// Returns a zero based extruder this eec should be printed with, according to PrintRegion config or extruder_override if overriden.
+	unsigned int extruder(const ExtrusionEntityCollection &extrusions, const PrintRegion &region) const;
+
+    coordf_t 					print_z	= 0.;
+    bool 						has_object = false;
+    bool						has_support = false;
+    // Zero based extruder IDs, ordered to minimize tool switches.
+    std::vector<unsigned int> 	extruders;
+    // If per layer extruder switches are inserted by the G-code preview slider, this value contains the new (1 based) extruder, with which the whole object layer is being printed with.
+    // If not overriden, it is set to 0.
+    unsigned int 				extruder_override = 0;
+    // Should a skirt be printed at this layer?
+    // Layers are marked for infinite skirt aka draft shield. Not all the layers have to be printed.
+    bool                        has_skirt = false;
+    // Will there be anything extruded on this layer for the wipe tower?
+    // Due to the support layers possibly interleaving the object layers,
+    // wipe tower will be disabled for some support only layers.
+    bool 						has_wipe_tower = false;
+    // Number of wipe tower partitions to support the required number of tool switches
+    // and to support the wipe tower partitions above this one.
+    size_t                      wipe_tower_partitions = 0;
+    coordf_t 					wipe_tower_layer_height = 0.;
+    // Custom G-code (color change, extruder switch, pause) to be performed before this layer starts to print.
+    const CustomGCode::Item    *custom_gcode = nullptr;
+
+    WipingExtrusions&       wiping_extrusions_nonconst() { return m_wiping_extrusions; }
+    const WipingExtrusions& wiping_extrusions() const    { return m_wiping_extrusions; }
+
+private:
+    // to access LayerTools private constructor
+    friend class ToolOrdering;
+    LayerTools(const coordf_t z) : print_z(z) {}
+
+    // This object holds list of extrusion that will be used for extruder wiping
+    WipingExtrusions m_wiping_extrusions;
+};
+
+class ToolOrdering
+{
+public:
+    ToolOrdering() = default;
+
+    // For the use case when each object is printed separately
+    // (print.config.complete_objects is true).
+    ToolOrdering(const PrintObject &object, unsigned int first_extruder, bool prime_multi_material = false);
+
+    // For the use case when all objects are printed at once.
+    // (print.config.complete_objects is false).
+    ToolOrdering(const Print &print, unsigned int first_extruder, bool prime_multi_material = false);
+
+    void 				clear() { m_layer_tools.clear(); }
+
+    // Only valid for non-sequential print:
+	// Assign a pointer to a custom G-code to the respective ToolOrdering::LayerTools.
+	// Ignore color changes, which are performed on a layer and for such an extruder, that the extruder will not be printing above that layer.
+	// If multiple events are planned over a span of a single layer, use the last one.
+	void 				assign_custom_gcodes(const Print &print);
+
+    // Get the first extruder printing, including the extruder priming areas, returns -1 if there is no layer printed.
+    unsigned int   		first_extruder() const { return m_first_printing_extruder; }
+
+    // Get the first extruder printing the layer_tools, returns -1 if there is no layer printed.
+    unsigned int   		last_extruder() const { return m_last_printing_extruder; }
+
+    // For a multi-material print, the printing extruders are ordered in the order they shall be primed.
+    const std::vector<unsigned int>& all_extruders() const { return m_all_printing_extruders; }
+
+    // Find LayerTools with the closest print_z.
+    const LayerTools&	tools_for_layer(coordf_t print_z) const;
+    LayerTools&			tools_for_layer(coordf_t print_z) { return const_cast<LayerTools&>(std::as_const(*this).tools_for_layer(print_z)); }
+
+    const LayerTools&   front()       const { return m_layer_tools.front(); }
+    const LayerTools&   back()        const { return m_layer_tools.back(); }
+    std::vector<LayerTools>::const_iterator begin() const { return m_layer_tools.begin(); }
+    std::vector<LayerTools>::const_iterator end()   const { return m_layer_tools.end(); }
+    bool 				empty()       const { return m_layer_tools.empty(); }
+    std::vector<LayerTools>& layer_tools() { return m_layer_tools; }
+    bool 				has_wipe_tower() const { return ! m_layer_tools.empty() && m_first_printing_extruder != (unsigned int)-1 && m_layer_tools.front().wipe_tower_partitions > 0; }
+
+private:
+    void				initialize_layers(std::vector<coordf_t> &zs);
+    void 				collect_extruders(const PrintObject &object, const std::vector<std::pair<double, unsigned int>> &per_layer_extruder_switches);
+    void				reorder_extruders(unsigned int last_extruder_id);
+    void 				fill_wipe_tower_partitions(const PrintConfig &config, coordf_t object_bottom_z, coordf_t max_layer_height);
+    bool                insert_wipe_tower_extruder();
+    void                mark_skirt_layers(const PrintConfig &config, coordf_t max_layer_height);
+    void 				collect_extruder_statistics(bool prime_multi_material);
+
+    std::vector<LayerTools>    m_layer_tools;
+    // First printing extruder, including the multi-material priming sequence.
+    unsigned int               m_first_printing_extruder = (unsigned int)-1;
+    // Final printing extruder.
+    unsigned int               m_last_printing_extruder  = (unsigned int)-1;
+    // All extruders, which extrude some material over m_layer_tools.
+    std::vector<unsigned int>  m_all_printing_extruders;
+
+    const PrintConfig*         m_print_config_ptr = nullptr;
+};
+
+} // namespace SLic3r
+
+#endif /* slic3r_ToolOrdering_hpp_ */

src/libslic3r/GCode/WipeTower.hpp

@@ -0,0 +1,405 @@
+#ifndef WipeTower_
+#define WipeTower_
+
+#include <cmath>
+#include <string>
+#include <sstream>
+#include <utility>
+#include <algorithm>
+
+#include "libslic3r/Point.hpp"
+
+namespace Slic3r
+{
+
+class WipeTowerWriter;
+class PrintConfig;
+enum GCodeFlavor : unsigned char;
+
+
+
+class WipeTower
+{
+public:
+    static const std::string never_skip_tag() { return "_GCODE_WIPE_TOWER_NEVER_SKIP_TAG"; }
+	static std::pair<double, double> get_wipe_tower_cone_base(double width, double height, double depth, double angle_deg);
+	static std::vector<std::vector<float>> extract_wipe_volumes(const PrintConfig& config);
+
+    struct Extrusion
+    {
+		Extrusion(const Vec2f &pos, float width, unsigned int tool) : pos(pos), width(width), tool(tool) {}
+		// End position of this extrusion.
+		Vec2f				pos;
+		// Width of a squished extrusion, corrected for the roundings of the squished extrusions.
+		// This is left zero if it is a travel move.
+		float 			width;
+		// Current extruder index.
+		unsigned int    tool;
+	};
+
+	struct ToolChangeResult
+	{
+		// Print heigh of this tool change.
+		float					print_z;
+		float 					layer_height;
+		// G-code section to be directly included into the output G-code.
+		std::string				gcode;
+		// For path preview.
+		std::vector<Extrusion> 	extrusions;
+		// Initial position, at which the wipe tower starts its action.
+		// At this position the extruder is loaded and there is no Z-hop applied.
+		Vec2f						start_pos;
+		// Last point, at which the normal G-code generator of Slic3r shall continue.
+		// At this position the extruder is loaded and there is no Z-hop applied.
+		Vec2f						end_pos;
+		// Time elapsed over this tool change.
+		// This is useful not only for the print time estimation, but also for the control of layer cooling.
+		float  				    elapsed_time;
+
+        // Is this a priming extrusion? (If so, the wipe tower rotation & translation will not be applied later)
+        bool                    priming;
+
+        // Pass a polyline so that normal G-code generator can do a wipe for us.
+        // The wipe cannot be done by the wipe tower because it has to pass back
+        // a loaded extruder, so it would have to either do a wipe with no retraction
+        // (leading to https://github.com/qidi3d/QIDISlicer/issues/2834) or do
+        // an extra retraction-unretraction pair.
+        std::vector<Vec2f> wipe_path;
+
+        // Initial tool
+        int initial_tool;
+
+        // New tool
+        int new_tool;
+
+		// Sum the total length of the extrusion.
+		float total_extrusion_length_in_plane() {
+			float e_length = 0.f;
+			for (size_t i = 1; i < this->extrusions.size(); ++ i) {
+				const Extrusion &e = this->extrusions[i];
+				if (e.width > 0) {
+					Vec2f v = e.pos - (&e - 1)->pos;
+					e_length += v.norm();
+				}
+			}
+			return e_length;
+		}
+
+		bool force_travel = false;
+	};
+
+    struct box_coordinates
+    {
+        box_coordinates(float left, float bottom, float width, float height) :
+            ld(left        , bottom         ),
+            lu(left        , bottom + height),
+            rd(left + width, bottom         ),
+            ru(left + width, bottom + height) {}
+        box_coordinates(const Vec2f &pos, float width, float height) : box_coordinates(pos(0), pos(1), width, height) {}
+        void translate(const Vec2f &shift) {
+            ld += shift; lu += shift;
+            rd += shift; ru += shift;
+        }
+        void translate(const float dx, const float dy) { translate(Vec2f(dx, dy)); }
+        void expand(const float offset) {
+            ld += Vec2f(- offset, - offset);
+            lu += Vec2f(- offset,   offset);
+            rd += Vec2f(  offset, - offset);
+            ru += Vec2f(  offset,   offset);
+        }
+        void expand(const float offset_x, const float offset_y) {
+            ld += Vec2f(- offset_x, - offset_y);
+            lu += Vec2f(- offset_x,   offset_y);
+            rd += Vec2f(  offset_x, - offset_y);
+            ru += Vec2f(  offset_x,   offset_y);
+        }
+        Vec2f ld;  // left down
+        Vec2f lu;	// left upper
+        Vec2f rd;	// right lower
+        Vec2f ru;  // right upper
+    };
+
+    // Construct ToolChangeResult from current state of WipeTower and WipeTowerWriter.
+    // WipeTowerWriter is moved from !
+    ToolChangeResult construct_tcr(WipeTowerWriter& writer,
+                                   bool priming,
+                                   size_t old_tool) const;
+
+	// x			-- x coordinates of wipe tower in mm ( left bottom corner )
+	// y			-- y coordinates of wipe tower in mm ( left bottom corner )
+	// width		-- width of wipe tower in mm ( default 60 mm - leave as it is )
+	// wipe_area	-- space available for one toolchange in mm
+    WipeTower(const PrintConfig& config, const std::vector<std::vector<float>>& wiping_matrix, size_t initial_tool);
+
+
+	// Set the extruder properties.
+    void set_extruder(size_t idx, const PrintConfig& config);
+
+	// Appends into internal structure m_plan containing info about the future wipe tower
+	// to be used before building begins. The entries must be added ordered in z.
+    void plan_toolchange(float z_par, float layer_height_par, unsigned int old_tool, unsigned int new_tool, float wipe_volume = 0.f);
+
+	// Iterates through prepared m_plan, generates ToolChangeResults and appends them to "result"
+	void generate(std::vector<std::vector<ToolChangeResult>> &result);
+
+    float get_depth() const { return m_wipe_tower_depth; }
+    float get_brim_width() const { return m_wipe_tower_brim_width_real; }
+	float get_wipe_tower_height() const { return m_wipe_tower_height; }
+
+
+
+
+
+	// Switch to a next layer.
+	void set_layer(
+		// Print height of this layer.
+		float print_z,
+		// Layer height, used to calculate extrusion the rate.
+		float layer_height,
+		// Maximum number of tool changes on this layer or the layers below.
+		size_t max_tool_changes,
+		// Is this the first layer of the print? In that case print the brim first. (OBSOLETE)
+		bool /*is_first_layer*/,
+		// Is this the last layer of the waste tower?
+		bool is_last_layer)
+	{
+		m_z_pos 				= print_z;
+		m_layer_height			= layer_height;
+		m_depth_traversed  = 0.f;
+        m_current_layer_finished = false;
+
+		
+        // Advance m_layer_info iterator, making sure we got it right
+		while (!m_plan.empty() && m_layer_info->z < print_z - WT_EPSILON && m_layer_info+1 != m_plan.end())
+			++m_layer_info;
+
+		m_current_shape = (! this->is_first_layer() && m_current_shape == SHAPE_NORMAL) ? SHAPE_REVERSED : SHAPE_NORMAL;
+		if (this->is_first_layer()) {
+            m_num_layer_changes = 0;
+            m_num_tool_changes 	= 0;
+        } else
+            ++ m_num_layer_changes;
+		
+		// Calculate extrusion flow from desired line width, nozzle diameter, filament diameter and layer_height:
+		m_extrusion_flow = extrusion_flow(layer_height);
+	}
+
+	// Return the wipe tower position.
+	const Vec2f& 		 position() const { return m_wipe_tower_pos; }
+	// Return the wipe tower width.
+	float     		 width()    const { return m_wipe_tower_width; }
+	// The wipe tower is finished, there should be no more tool changes or wipe tower prints.
+	bool 	  		 finished() const { return m_max_color_changes == 0; }
+
+	// Returns gcode to prime the nozzles at the front edge of the print bed.
+	std::vector<ToolChangeResult> prime(
+		// print_z of the first layer.
+		float 						first_layer_height, 
+		// Extruder indices, in the order to be primed. The last extruder will later print the wipe tower brim, print brim and the object.
+		const std::vector<unsigned int> &tools,
+		// If true, the last priming are will be the same as the other priming areas, and the rest of the wipe will be performed inside the wipe tower.
+		// If false, the last priming are will be large enough to wipe the last extruder sufficiently.
+		bool 						last_wipe_inside_wipe_tower);
+
+	// Returns gcode for a toolchange and a final print head position.
+	// On the first layer, extrude a brim around the future wipe tower first.
+    ToolChangeResult tool_change(size_t new_tool);
+
+	// Fill the unfilled space with a sparse infill.
+	// Call this method only if layer_finished() is false.
+	ToolChangeResult finish_layer();
+
+	// Is the current layer finished?
+	bool 			 layer_finished() const {
+        return m_current_layer_finished;
+	}
+
+    std::vector<float> get_used_filament() const { return m_used_filament_length; }
+    int get_number_of_toolchanges() const { return m_num_tool_changes; }
+
+    struct FilamentParameters {
+        std::string 	    material = "PLA";
+        bool                is_soluble = false;
+        int  			    temperature = 0;
+        int  			    first_layer_temperature = 0;
+        float               loading_speed = 0.f;
+        float               loading_speed_start = 0.f;
+        float               unloading_speed = 0.f;
+        float               unloading_speed_start = 0.f;
+        float               delay = 0.f ;
+        int                 cooling_moves = 0;
+        float               cooling_initial_speed = 0.f;
+        float               cooling_final_speed = 0.f;
+        float               ramming_line_width_multiplicator = 1.f;
+        float               ramming_step_multiplicator = 1.f;
+        float               max_e_speed = std::numeric_limits<float>::max();
+        std::vector<float>  ramming_speed;
+        float               nozzle_diameter;
+        float               filament_area;
+    };
+
+private:
+	enum wipe_shape // A fill-in direction
+	{
+		SHAPE_NORMAL = 1,
+		SHAPE_REVERSED = -1
+	};
+
+    const float Width_To_Nozzle_Ratio = 1.25f; // desired line width (oval) in multiples of nozzle diameter - may not be actually neccessary to adjust
+    const float WT_EPSILON            = 1e-3f;
+    float filament_area() const {
+        return m_filpar[0].filament_area; // all extruders are assumed to have the same filament diameter at this point
+    }
+
+
+	bool   m_semm               = true; // Are we using a single extruder multimaterial printer?
+    Vec2f  m_wipe_tower_pos; 			// Left front corner of the wipe tower in mm.
+	float  m_wipe_tower_width; 			// Width of the wipe tower.
+	float  m_wipe_tower_depth 	= 0.f; 	// Depth of the wipe tower
+	float  m_wipe_tower_height  = 0.f;
+	float  m_wipe_tower_cone_angle = 0.f;
+    float  m_wipe_tower_brim_width      = 0.f; 	// Width of brim (mm) from config
+    float  m_wipe_tower_brim_width_real = 0.f; 	// Width of brim (mm) after generation
+	float  m_wipe_tower_rotation_angle = 0.f; // Wipe tower rotation angle in degrees (with respect to x axis)
+    float  m_internal_rotation  = 0.f;
+	float  m_y_shift			= 0.f;  // y shift passed to writer
+	float  m_z_pos 				= 0.f;  // Current Z position.
+	float  m_layer_height 		= 0.f; 	// Current layer height.
+	size_t m_max_color_changes 	= 0; 	// Maximum number of color changes per layer.
+    int    m_old_temperature    = -1;   // To keep track of what was the last temp that we set (so we don't issue the command when not neccessary)
+    float  m_travel_speed       = 0.f;
+    float  m_first_layer_speed  = 0.f;
+    size_t m_first_layer_idx    = size_t(-1);
+
+	// G-code generator parameters.
+    float           m_cooling_tube_retraction   = 0.f;
+    float           m_cooling_tube_length       = 0.f;
+    float           m_parking_pos_retraction    = 0.f;
+    float           m_extra_loading_move        = 0.f;
+    float           m_bridging                  = 0.f;
+    bool            m_no_sparse_layers          = false;
+    bool            m_set_extruder_trimpot      = false;
+    bool            m_adhesion                  = true;
+    GCodeFlavor     m_gcode_flavor;
+
+    // Bed properties
+    enum {
+        RectangularBed,
+        CircularBed,
+        CustomBed
+    } m_bed_shape;
+    float m_bed_width; // width of the bed bounding box
+    Vec2f m_bed_bottom_left; // bottom-left corner coordinates (for rectangular beds)
+
+	float m_perimeter_width = 0.4f * Width_To_Nozzle_Ratio; // Width of an extrusion line, also a perimeter spacing for 100% infill.
+	float m_extrusion_flow = 0.038f; //0.029f;// Extrusion flow is derived from m_perimeter_width, layer height and filament diameter.
+
+	// Extruder specific parameters.
+    std::vector<FilamentParameters> m_filpar;
+
+	// State of the wipe tower generator.
+	unsigned int m_num_layer_changes = 0; // Layer change counter for the output statistics.
+	unsigned int m_num_tool_changes  = 0; // Tool change change counter for the output statistics.
+	///unsigned int 	m_idx_tool_change_in_layer = 0; // Layer change counter in this layer. Counting up to m_max_color_changes.
+	bool m_print_brim = true;
+	// A fill-in direction (positive Y, negative Y) alternates with each layer.
+	wipe_shape   	m_current_shape = SHAPE_NORMAL;
+    size_t 	m_current_tool  = 0;
+    const std::vector<std::vector<float>> wipe_volumes;
+
+	float           m_depth_traversed = 0.f; // Current y position at the wipe tower.
+    bool            m_current_layer_finished = false;
+	bool 			m_left_to_right   = true;
+	float			m_extra_spacing   = 1.f;
+
+    bool is_first_layer() const { return size_t(m_layer_info - m_plan.begin()) == m_first_layer_idx; }
+
+	// Calculates extrusion flow needed to produce required line width for given layer height
+	float extrusion_flow(float layer_height = -1.f) const	// negative layer_height - return current m_extrusion_flow
+	{
+		if ( layer_height < 0 )
+			return m_extrusion_flow;
+		return layer_height * ( m_perimeter_width - layer_height * (1.f-float(M_PI)/4.f)) / filament_area();
+	}
+
+	// Calculates length of extrusion line to extrude given volume
+	float volume_to_length(float volume, float line_width, float layer_height) const {
+		return std::max(0.f, volume / (layer_height * (line_width - layer_height * (1.f - float(M_PI) / 4.f))));
+	}
+
+	// Calculates depth for all layers and propagates them downwards
+	void plan_tower();
+
+	// Goes through m_plan and recalculates depths and width of the WT to make it exactly square - experimental
+	void make_wipe_tower_square();
+
+    // Goes through m_plan, calculates border and finish_layer extrusions and subtracts them from last wipe
+    void save_on_last_wipe();
+
+
+    // to store information about tool changes for a given layer
+	struct WipeTowerInfo{
+		struct ToolChange {
+            size_t old_tool;
+            size_t new_tool;
+			float required_depth;
+            float ramming_depth;
+            float first_wipe_line;
+            float wipe_volume;
+            ToolChange(size_t old, size_t newtool, float depth=0.f, float ramming_depth=0.f, float fwl=0.f, float wv=0.f)
+            : old_tool{old}, new_tool{newtool}, required_depth{depth}, ramming_depth{ramming_depth}, first_wipe_line{fwl}, wipe_volume{wv} {}
+		};
+		float z;		// z position of the layer
+		float height;	// layer height
+		float depth;	// depth of the layer based on all layers above
+		float extra_spacing;
+		float toolchanges_depth() const { float sum = 0.f; for (const auto &a : tool_changes) sum += a.required_depth; return sum; }
+
+		std::vector<ToolChange> tool_changes;
+
+		WipeTowerInfo(float z_par, float layer_height_par)
+			: z{z_par}, height{layer_height_par}, depth{0}, extra_spacing{1.f} {}
+	};
+
+	std::vector<WipeTowerInfo> m_plan; 	// Stores information about all layers and toolchanges for the future wipe tower (filled by plan_toolchange(...))
+	std::vector<WipeTowerInfo>::iterator m_layer_info = m_plan.end();
+
+	// This sums height of all extruded layers, not counting the layers which
+	// will be later removed when the "no_sparse_layers" is used.
+	float m_current_height = 0.f;
+
+    // Stores information about used filament length per extruder:
+    std::vector<float> m_used_filament_length;
+
+    // Return index of first toolchange that switches to non-soluble extruder
+    // ot -1 if there is no such toolchange.
+    int first_toolchange_to_nonsoluble(
+            const std::vector<WipeTowerInfo::ToolChange>& tool_changes) const;
+
+	void toolchange_Unload(
+		WipeTowerWriter &writer,
+		const box_coordinates  &cleaning_box, 
+		const std::string&	 	current_material,
+		const int 				new_temperature);
+
+	void toolchange_Change(
+		WipeTowerWriter &writer,
+        const size_t		new_tool,
+		const std::string& 		new_material);
+	
+	void toolchange_Load(
+		WipeTowerWriter &writer,
+		const box_coordinates  &cleaning_box);
+	
+	void toolchange_Wipe(
+		WipeTowerWriter &writer,
+		const box_coordinates  &cleaning_box,
+		float wipe_volume);
+};
+
+
+
+
+} // namespace Slic3r
+
+#endif // WipeTowerQIDIMM_hpp_