Initial integration of the Prusa MultiMatrial Wipe Tower.

xs/src/libslic3r/GCode/ToolOrdering.cpp

@@ -0,0 +1,194 @@
+#include "ToolOrdering.hpp"
+
+namespace Slic3r {
+namespace ToolOrdering {
+
+// Collect extruders reuqired to print layers.
+static void collect_extruders(const PrintObject &object, std::vector<LayerTools> &layers)
+{
+    // Collect the support extruders.
+    for (auto support_layer : object.support_layers) {
+        auto it_layer = std::find(layers.begin(), layers.end(), LayerTools(support_layer->print_z));
+        assert(it_layer != layers.end());
+        ExtrusionRole role = support_layer->support_fills.role();
+        bool         has_support        = role == erMixed || role == erSupportMaterial;
+        bool         has_interface      = role == erMixed || role == erSupportMaterialInterface;
+        unsigned int extruder_support   = object.config.support_material_extruder.value;
+        unsigned int extruder_interface = object.config.support_material_interface_extruder.value;
+        if (has_support && has_interface) {
+            // If both base and interface supports are to be extruded and one of them will be extruded with a "don't care" extruder,
+            // print both with the same extruder to minimize extruder switches.
+            if (extruder_support == 0)
+                extruder_support = extruder_interface;
+            else if (extruder_interface == 0)
+                extruder_interface = extruder_support;
+        }
+        if (has_support)
+            it_layer->extruders.push_back(extruder_support);
+        if (has_interface)
+            it_layer->extruders.push_back(extruder_interface);
+    }
+    // Collect the object extruders.
+    for (auto layer : object.layers) {
+        auto it_layer = std::find(layers.begin(), layers.end(), LayerTools(layer->print_z));
+        assert(it_layer != layers.end());
+        // What extruders are required to print this object layer?
+        for (size_t region_id = 0; region_id < object.print()->regions.size(); ++ region_id) {
+            const LayerRegion *layerm = layer->regions[region_id];
+            if (layerm == nullptr)
+                continue;
+            const PrintRegion &region = *object.print()->regions[region_id];
+            if (! layerm->perimeters.entities.empty())
+                it_layer->extruders.push_back(region.config.perimeter_extruder.value);
+            bool has_infill       = false; 
+            bool has_solid_infill = false;
+            for (const ExtrusionEntity *ee : layerm->fills.entities) {
+                // fill represents infill extrusions of a single island.
+                const auto *fill = dynamic_cast<const ExtrusionEntityCollection*>(ee);
+                ExtrusionRole role = fill->entities.empty() ? erNone : fill->entities.front()->role();
+                if (is_solid_infill(role))
+                    has_solid_infill = true;
+                else if (role != erNone)
+                    has_infill = true;
+            }
+            if (has_solid_infill)
+                it_layer->extruders.push_back(region.config.solid_infill_extruder);
+            if (has_infill)
+                it_layer->extruders.push_back(region.config.infill_extruder);
+        }
+    }
+
+    // Sort and remove duplicates
+    for (LayerTools &lt : layers)
+        sort_remove_duplicates(lt.extruders);
+}
+
+// Reorder extruders to minimize layer changes.
+static void reorder_extruders(std::vector<LayerTools> &layers)
+{
+    if (layers.empty())
+        return;
+
+    // Initialize the last_extruder_id with the first non-zero extruder id used for the print.
+    unsigned int last_extruder_id = 0;
+    for (size_t i = 0; i < layers.size() && last_extruder_id == 0; ++ i) {
+        const LayerTools &lt = layers[i];
+        for (unsigned int extruder_id : lt.extruders)
+            if (extruder_id > 0) {
+                last_extruder_id = extruder_id;
+                break;
+            }
+    }
+    if (last_extruder_id == 0)
+        last_extruder_id = 1;
+
+    for (LayerTools &lt : layers) {
+        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;
+                }
+        }
+        last_extruder_id = lt.extruders.back();
+    }
+
+    // Reindex the extruders, so they are zero based, not 1 based.
+    for (LayerTools &lt : layers)
+        for (unsigned int &extruder_id : lt.extruders) {
+            assert(extruder_id > 0);
+            -- extruder_id;
+        }
+}
+
+static void fill_wipe_tower_partitions(std::vector<LayerTools> &layers)
+{
+    if (layers.empty())
+        return;
+
+    // Count the minimum number of tool changes per layer.
+    for (LayerTools &lt : layers)
+        lt.wipe_tower_partitions = std::max<int>(0, int(layers.front().extruders.size()) - 1);
+
+    // In case a distinct set of tools are used between two layers, there will be an additional tool change at the start of a layer.
+    //FIXME this does not minimize the number of tool changes in worst case.
+    for (size_t i = 1; i < layers.size(); ++ i)
+        if (layers[i-1].extruders.back() != layers[i].extruders.front())
+            ++ layers[i].wipe_tower_partitions;
+
+    // Propagate the wipe tower partitions down to support the upper partitions by the lower partitions.
+    for (int i = int(layers.size()) - 2; i >= 0; -- i)
+        layers[i].wipe_tower_partitions = std::max(layers[i + 1].wipe_tower_partitions, layers[i].wipe_tower_partitions);
+}
+
+// For the use case when each object is printed separately
+// (print.config.complete_objects is true).
+std::vector<LayerTools> tool_ordering(PrintObject &object)
+{
+    // Initialize the print layers for just a single object.
+    std::vector<LayerTools> layers;
+    {
+        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);
+        sort_remove_duplicates(zs);
+        for (coordf_t z : zs)
+            layers.emplace_back(LayerTools(z));
+    }
+
+    // Collect extruders reuqired to print the layers.
+    collect_extruders(object, layers);
+
+    // Reorder the extruders to minimize tool switches.
+    reorder_extruders(layers);
+
+    fill_wipe_tower_partitions(layers);
+    return layers;
+}
+
+// For the use case when all objects are printed at once.
+// (print.config.complete_objects is false).
+std::vector<LayerTools> tool_ordering(const Print &print)
+{
+    // Initialize the print layers for all objects and all layers. 
+    std::vector<LayerTools> layers;
+    {
+        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);
+        }
+        sort_remove_duplicates(zs);
+        for (coordf_t z : zs)
+            layers.emplace_back(LayerTools(z));
+    }
+
+    // Collect extruders reuqired to print the layers.
+    for (auto object : print.objects)
+        collect_extruders(*object, layers);
+
+    // Reorder the extruders to minimize tool switches.
+    reorder_extruders(layers);
+
+    fill_wipe_tower_partitions(layers);
+    return layers;
+}
+
+} // namespace ToolOrdering
+} // namespace Slic3r

xs/src/libslic3r/GCode/ToolOrdering.hpp

@@ -0,0 +1,38 @@
+// Ordering of the tools to minimize tool switches.
+
+#ifndef slic3r_ToolOrdering_hpp_
+#define slic3r_ToolOrdering_hpp_
+
+#include "libslic3r.h"
+#include "Print.hpp"
+
+namespace Slic3r {
+namespace ToolOrdering {
+
+struct LayerTools
+{
+    LayerTools(const coordf_t z) : print_z(z), wipe_tower_partitions(0) {}
+
+    bool operator< (const LayerTools &rhs) const { return print_z <  rhs.print_z; }
+    bool operator==(const LayerTools &rhs) const { return print_z == rhs.print_z; }
+
+	coordf_t 					print_z;
+	// Zero based extruder IDs, ordered to minimize tool switches.
+	std::vector<unsigned int> 	extruders;
+	// 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;
+};
+
+// For the use case when each object is printed separately
+// (print.config.complete_objects is true).
+extern std::vector<LayerTools> tool_ordering(PrintObject &object);
+
+// For the use case when all objects are printed at once.
+// (print.config.complete_objects is false).
+extern std::vector<LayerTools> tool_ordering(const Print &print);
+
+} // namespace ToolOrdering
+} // namespace SLic3r
+
+#endif /* slic3r_ToolOrdering_hpp_ */

xs/src/libslic3r/GCode/WipeTower.hpp

@@ -0,0 +1,59 @@
+#ifndef slic3r_WipeTower_hpp_
+#define slic3r_WipeTower_hpp_
+
+#include <utility>
+#include <string>
+
+namespace Slic3r
+{
+
+// A pure virtual WipeTower definition.
+class WipeTower
+{
+public:
+	// Internal point class, to make the wipe tower independent from other slic3r modules.
+	// This is important for Prusa Research as we want to build the wipe tower post-processor independently from slic3r.
+	struct xy
+	{
+		xy(float x = 0.f, float y = 0.f) : x(x), y(y) {}
+		xy  operator+(const xy &rhs) const { xy out(*this); out.x += rhs.x; out.y += rhs.y; return out; }
+		xy  operator-(const xy &rhs) const { xy out(*this); out.x -= rhs.x; out.y -= rhs.y; return out; }
+		xy& operator+=(const xy &rhs) { x += rhs.x; y += rhs.y; return *this; }
+		xy& operator-=(const xy &rhs) { x -= rhs.x; y -= rhs.y; return *this; }
+		float x;
+		float y;
+	};
+
+	WipeTower() {}
+	virtual ~WipeTower() {}
+
+	// Return the wipe tower position.
+	virtual const xy& position() const = 0;
+
+	// The wipe tower is finished, there should be no more tool changes or wipe tower prints.
+	virtual bool 	  finished() const = 0;
+
+	// Switch to a next layer.
+	virtual 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.
+		bool   is_first_layer,
+		// Is this the last layer of the wipe tower?
+		bool   is_last_layer) = 0;
+
+	// Returns gcode for toolchange and the end position.
+	// if new_tool == -1, just unload the current filament over the wipe tower.
+	virtual std::pair<std::string, xy> tool_change(int new_tool) = 0;
+
+	// Close the current wipe tower layer with a perimeter and possibly fill the unfilled space with a zig-zag.
+	virtual std::pair<std::string, xy> close_layer() = 0;
+};
+
+}; // namespace Slic3r
+
+#endif /* slic3r_WipeTower_hpp_ */

xs/src/libslic3r/GCode/WipeTowerPrusaMM.cpp

@@ -0,0 +1,661 @@
+#include "WipeTowerPrusaMM.hpp"
+
+#include <assert.h>
+#include <math.h>
+#include <fstream>
+#include <iostream>
+
+#ifdef __linux
+#include <strings.h>
+#endif /* __linux */
+
+#ifdef _MSC_VER 
+#define strcasecmp _stricmp
+#endif
+
+namespace Slic3r
+{
+
+namespace PrusaMultiMaterial {
+
+class Writer
+{
+public:
+	Writer() : 
+		m_current_pos(std::numeric_limits<float>::max(), std::numeric_limits<float>::max()),
+		m_current_z(0.f),
+		m_current_feedrate(0.f),
+		m_extrusion_flow(0.f) {}
+
+	Writer&				 set_z(float z) 
+		{ m_current_z = z; return *this; }
+
+	Writer& 			 set_extrusion_flow(float flow)
+		{ m_extrusion_flow = flow; return *this; }
+
+	Writer& 			 feedrate(float f)
+	{
+		if (f != m_current_feedrate)
+			m_gcode += "G1" + set_format_F(f) + "\n";
+		return *this;
+	}
+
+	const std::string&   gcode() const { return m_gcode; }
+	float                x()     const { return m_current_pos.x; }
+	float                y()     const { return m_current_pos.y; }
+	const WipeTower::xy& pos()   const { return m_current_pos; }
+
+	Writer& extrude_explicit(float x, float y, float e, float f = 0.f) 
+	{
+		if (x == m_current_pos.x && y == m_current_pos.y && e == 0.f && (f == 0.f || f == m_current_feedrate))
+			return *this;
+		m_gcode += "G1 ";
+		if (x != m_current_pos.x)
+			m_gcode += set_format_X(x);
+		if (y != m_current_pos.y)
+			m_gcode += set_format_Y(y);
+		if (e != 0)
+			m_gcode += set_format_E(e);
+		if (f != 0 && f != m_current_feedrate)
+			m_gcode += set_format_F(f);
+		m_gcode += "\n";
+		return *this;
+	}
+
+	Writer& extrude_explicit(const WipeTower::xy &dest, float e, float f = 0.f) 
+		{ return extrude_explicit(dest.x, dest.y, e, f); }
+
+	// Travel to a new XY position. f=0 means use the current value.
+	Writer& travel(float x, float y, float f = 0.f) 
+		{ return extrude_explicit(x, y, 0, f); }
+
+	Writer& travel(const WipeTower::xy &dest, float f = 0.f) 
+		{ return extrude_explicit(dest.x, dest.y, 0.f, f); }
+
+	Writer& extrude(float x, float y, float f = 0.f) {
+		float dx = x - m_current_pos.x;
+		float dy = y - m_current_pos.y;
+		return extrude_explicit(x, y, sqrt(dx*dx+dy*dy) * m_extrusion_flow, f);
+	}
+
+	Writer& extrude(const WipeTower::xy &dest, const float f = 0.f) 
+		{ return extrude(dest.x, dest.y, f); }
+
+	Writer& deretract(float e, float f = 0.f)
+	{
+		if (e == 0 && (f == 0 || f == m_current_feedrate))
+			return *this;
+		m_gcode += "G1 ";
+		if (e != 0)
+			m_gcode += set_format_E(e);
+		if (f != 0 && f != m_current_feedrate)
+			m_gcode += set_format_F(f);
+		m_gcode += "\n";
+		return *this;
+	}
+
+	Writer& deretract_move_x(float x, float e, float f = 0.f)
+		{ return extrude_explicit(x, m_current_pos.y, e, f); }
+
+	Writer& retract(float e, float f = 0.f)
+		{ return retract(-e, f); }
+
+	Writer& z_hop(float hop, float f = 0.f) { 
+		m_gcode += std::string("G1") + set_format_Z(m_current_z + hop);
+		if (f != 0 && f != m_current_feedrate)
+			m_gcode += set_format_F(f);
+		m_gcode += "\n";
+		return *this;
+	}
+
+	// Move to x1, +y_increment,
+	// extrude quickly amount e to x2 with feed f.
+	Writer& ram(float x1, float x2, float dy, float e, float f) {
+		return  travel(x1, m_current_pos.y + dy, f)
+			   .extrude_explicit(x2, m_current_pos.y, e);
+	}
+
+	Writer& cool(float x1, float x2, float e1, float e2, float f) {
+		return  extrude_explicit(x1, m_current_pos.y, e1, f)
+			   .extrude_explicit(x2, m_current_pos.y, e2);
+	}
+
+	Writer& set_tool(int tool) 
+	{
+		char buf[64];
+		sprintf(buf, "T%d\n", tool);
+		m_gcode += buf;
+		return *this;
+	}
+
+	// Set extruder temperature, don't wait.
+	Writer& set_extruder_temp(int temperature, bool wait = false)
+	{
+		char buf[128];
+		sprintf(buf, "M%d S%d\n", wait ? 109 : 104, temperature);
+		m_gcode += buf;
+		return *this;
+	};
+
+	// Set speed factor override percentage
+	Writer& speed_override(int speed) {
+		char buf[128];
+		sprintf(buf, "M220 S%d\n", speed);
+		m_gcode += buf;
+		return *this;
+	};
+
+	// Set digital trimpot motor
+	Writer& set_extruder_trimpot(int current)
+	{
+		char buf[128];
+		sprintf(buf, "M907 E%d\n", current);
+		m_gcode += buf;
+		return *this;
+	};
+
+	Writer& flush_planner_queue() { 
+		m_gcode += "G4 S0\n"; 
+		return *this;
+	}
+
+	// Reset internal extruder counter.
+	Writer& reset_extruder() { 
+		m_gcode += "G92 E0.0\n";
+		return *this;
+	}
+
+	Writer& comment_with_value(const char *comment, int value)
+	{
+		char strvalue[15];
+		sprintf(strvalue, "%d", value);
+		m_gcode += std::string(";") + comment + strvalue + "\n";
+		return *this;
+	};
+
+	Writer& comment_material(WipeTowerPrusaMM::material_type material)
+	{
+		m_gcode += "; material : ";
+		switch (material)
+		{
+		case WipeTowerPrusaMM::PVA:
+			m_gcode += "#8 (PVA)";
+			break;
+		case WipeTowerPrusaMM::SCAFF:
+			m_gcode += "#5 (Scaffold)";
+			break;
+		case WipeTowerPrusaMM::FLEX:
+			m_gcode += "#4 (Flex)";
+			break;
+		default:
+			m_gcode += "DEFAULT (PLA)";
+			break;
+		}
+		m_gcode += "\n";
+		return *this;
+	};
+
+	Writer& append(const char *text) { m_gcode += text; return *this; }
+
+private:
+	WipeTower::xy m_current_pos;
+	float    	  m_current_z;
+	float 	  	  m_current_feedrate;
+	float 	  	  m_extrusion_flow;
+	std::string   m_gcode;
+
+	std::string   set_format_X(float x) {
+		char buf[64];
+		sprintf(buf, " X%.3f", x);
+		m_current_pos.x = x;
+		return buf;
+	}
+
+	std::string   set_format_Y(float y) {
+		char buf[64];
+		sprintf(buf, " Y%.3f", y);
+		m_current_pos.y = y;
+		return buf;
+	}
+
+	std::string   set_format_Z(float y) {
+		char buf[64];
+		sprintf(buf, " Z%.3f", y);
+		return buf;
+	}
+
+	std::string   set_format_E(float e) {
+		char buf[64];
+		sprintf(buf, " E%.4f", e);
+		return buf;
+	}
+
+	std::string   set_format_F(float f) {
+		char buf[64];
+		sprintf(buf, " F%.0f", f);
+		m_current_feedrate = f;
+		return buf;
+	}
+};
+
+} // namespace PrusaMultiMaterial
+
+static inline int randi(int lo, int hi)
+{
+	int n = hi - lo + 1;
+	int i = rand() % n;
+	if (i < 0) i = -i;
+	return lo + i;
+}
+
+WipeTowerPrusaMM::material_type WipeTowerPrusaMM::parse_material(const char *name)
+{
+	if (strcasecmp(name, "PLA") == 0)
+		return PLA;
+	if (strcasecmp(name, "ABS") == 0)
+		return ABS;
+	if (strcasecmp(name, "PET") == 0)
+		return PET;
+	if (strcasecmp(name, "HIPS") == 0)
+		return HIPS;
+	if (strcasecmp(name, "FLEX") == 0)
+		return FLEX;
+	if (strcasecmp(name, "SCAFF") == 0)
+		return SCAFF;
+	if (strcasecmp(name, "EDGE") == 0)
+		return EDGE;
+	if (strcasecmp(name, "NGEN") == 0)
+		return NGEN;
+	if (strcasecmp(name, "PVA") == 0)
+		return PVA;
+	return INVALID;
+}
+
+std::pair<std::string, WipeTower::xy> WipeTowerPrusaMM::tool_change(int tool)
+{
+	// Either it is the last tool unload,
+	// or there must be a nonzero wipe tower partitions available.
+	assert(tool < 0 || it_layer_tools->wipe_tower_partitions > 0);
+
+	if (m_layer_change_in_layer == size_t(-1))
+		// First layer, prime the extruder.
+		return toolchange_Brim(tool);
+
+	box_coordinates cleaning_box(
+		m_wipe_tower_pos.x,
+		m_wipe_tower_pos.y + m_current_wipe_start_y,
+		m_wipe_tower_width, 
+		m_wipe_area - m_perimeter_width / 2);
+
+	PrusaMultiMaterial::Writer writer;
+	writer.set_extrusion_flow(m_extrusion_flow)
+		  .set_z(m_z_pos)
+		  .append(";--------------------\n"
+			 	  "; CP TOOLCHANGE START\n")
+		  .comment_with_value(" toolchange #", m_layer_change_total)
+		  .comment_material(m_current_material)
+		  .append(";--------------------\n")
+		  .speed_override(100)
+		  // Lift for a Z hop.
+		  .z_hop(m_zhop, 7200)
+		  // additional retract on move to tower
+		  .retract(m_retract/2, 3600)
+		  .travel(((m_current_shape == SHAPE_NORMAL) ? cleaning_box.ld : cleaning_box.rd) + xy(m_perimeter_width, m_current_shape * m_perimeter_width), 7200)
+		  // Unlift for a Z hop.
+		  .z_hop(0, 7200)
+		  // Additional retract on move to tower.
+		  .deretract(m_retract/2, 3600)
+		  .deretract(m_retract, 1500)
+		  // Increase extruder current for ramming.
+		  .set_extruder_trimpot(750)
+		  .flush_planner_queue();
+
+	// Ram the hot material out of the melt zone, retract the filament into the cooling tubes and let it cool.
+	toolchange_Unload(writer, cleaning_box, m_current_material, m_current_shape, 
+		m_is_first_layer ? m_first_layer_temperature[tool]  : m_temperature[tool]);
+
+	if (tool >= 0) {
+		// This is not the last change.
+		// Change the tool, set a speed override for solube and flex materials.
+		toolchange_Change(writer, tool, m_current_material, m_material[tool]);
+		toolchange_Load(writer, cleaning_box);
+		// Wipe the newly loaded filament until the end of the assigned wipe area.
+		toolchange_Wipe(writer, cleaning_box, m_current_material);
+		// Draw a perimeter around cleaning_box and wipe.
+		toolchange_Done(writer, cleaning_box);
+	}
+
+	// Reset the extruder current to a normal value.
+	writer.set_extruder_trimpot(550)
+		  .flush_planner_queue()
+		  .reset_extruder()
+		  .append("; CP TOOLCHANGE END\n"
+	 		      ";------------------\n"
+				  "\n\n");
+
+    ++ m_layer_change_in_layer;
+    m_current_wipe_start_y += m_wipe_area;
+  	m_current_material = m_material[tool];
+	return std::pair<std::string, xy>(writer.gcode(), writer.pos());
+}
+
+std::pair<std::string, WipeTower::xy> WipeTowerPrusaMM::toolchange_Brim(size_t tool, bool sideOnly, float y_offset)
+{
+	const box_coordinates wipeTower_box(
+		m_wipe_tower_pos,
+		m_wipe_tower_width,
+		m_wipe_area * float(m_max_color_changes) - m_perimeter_width / 2);
+
+	PrusaMultiMaterial::Writer writer;
+	writer.set_extrusion_flow(m_extrusion_flow * 1.1f)
+		  // Let the writer know the current Z position as a base for Z-hop.
+		  .set_z(m_z_pos)
+		  .append(
+			";-------------------------------------\n"
+			"; CP WIPE TOWER FIRST LAYER BRIM START\n");
+
+	// Move with Z hop and prime the extruder 10*m_perimeter_width left along the vertical edge of the wipe tower.
+	writer.z_hop(m_zhop, 7200)
+		  .travel(wipeTower_box.lu - xy(m_perimeter_width * 10.f, 0), 6000)
+		  .z_hop(0, 7200)
+		  .extrude_explicit(wipeTower_box.ld - xy(m_perimeter_width * 10.f, 0), m_retract, 2400)
+		  .feedrate(2100);
+
+	toolchange_Change(writer, tool, m_current_material, m_material[tool]);
+
+	if (sideOnly) {
+		float x_offset = 0.f;
+		for (size_t i = 0; i < 4; ++ i, x_offset += m_perimeter_width)
+			writer.travel (wipeTower_box.ld + xy(- x_offset,   y_offset))
+				  .extrude(wipeTower_box.lu + xy(- x_offset, - y_offset));
+		writer.travel(wipeTower_box.rd + xy(x_offset, y_offset), 7000)
+			  .feedrate(2100);
+		x_offset = 0.f;
+		for (size_t i = 0; i < 4; ++ i, x_offset += m_perimeter_width)
+			writer.travel (wipeTower_box.rd + xy(x_offset,   y_offset))
+				  .extrude(wipeTower_box.ru + xy(x_offset, - y_offset));
+	} else {
+		// Extrude 4 rounds of a brim around the future wipe tower.
+		box_coordinates box(wipeTower_box);
+		box.ld += xy(- m_perimeter_width / 2, 0);
+		box.lu += xy(- m_perimeter_width / 2, m_perimeter_width);
+		box.rd += xy(  m_perimeter_width / 2, 0);
+		box.ru += xy(  m_perimeter_width / 2, m_perimeter_width);
+		for (size_t i = 0; i < 4; ++ i) {
+			writer.travel(box.ld)
+				  .extrude(box.lu) .extrude(box.ru)
+				  .extrude(box.rd) .extrude(box.ld);
+			box.expand(m_perimeter_width);
+		}
+	}
+
+	// Move to the front left corner and wipe along the front edge.
+	writer.travel(wipeTower_box.ld, 7000)
+		  .travel(wipeTower_box.rd)
+		  .travel(wipeTower_box.ld)
+		  .append("; CP WIPE TOWER FIRST LAYER BRIM END\n"
+			      ";-----------------------------------\n");
+
+	return std::pair<std::string, xy>(writer.gcode(), writer.pos());
+}
+
+// Ram the hot material out of the melt zone, retract the filament into the cooling tubes and let it cool.
+void WipeTowerPrusaMM::toolchange_Unload(
+	PrusaMultiMaterial::Writer &writer,
+	const box_coordinates 	&cleaning_box,
+	const material_type		 material,
+	const wipe_shape 	     shape,
+	const int 				 temperature)
+{
+	float xl = cleaning_box.ld.x + (m_perimeter_width / 2);
+	float xr = cleaning_box.rd.x - (m_perimeter_width / 2);
+	float y_step = shape * m_perimeter_width;
+
+	writer.append("; CP TOOLCHANGE UNLOAD");
+
+	// Ram the hot material out of the extruder melt zone.
+	switch (material)
+	{
+	case PVA:
+   		// ramming          start                    end                  y increment     amount feedrate
+		writer.ram(xl + m_perimeter_width * 2, xr - m_perimeter_width,     y_step * 1.2f, 3,     4000)
+			  .ram(xr - m_perimeter_width,     xl + m_perimeter_width,     y_step * 1.5f, 3,     4500)
+			  .ram(xl + m_perimeter_width * 2, xr - m_perimeter_width * 2, y_step * 1.5f, 3,     4800)
+			  .ram(xr - m_perimeter_width,     xl + m_perimeter_width,     y_step * 1.5f, 3,     5000);
+		break;
+	case SCAFF:
+		writer.ram(xl + m_perimeter_width * 2, xr - m_perimeter_width,     y_step * 3.f,  3,     4000)
+			  .ram(xr - m_perimeter_width,     xl + m_perimeter_width,     y_step * 3.f,  4,     4600)
+			  .ram(xl + m_perimeter_width * 2, xr - m_perimeter_width * 2, y_step * 3.f,  4.5,   5200);
+		break;
+	default:
+		writer.ram(xl + m_perimeter_width * 2, xr - m_perimeter_width,     y_step * 1.2f, 1.6f,  4000)
+			  .ram(xr - m_perimeter_width,     xl + m_perimeter_width,     y_step * 1.2f, 1.65f, 4600)
+			  .ram(xl + m_perimeter_width * 2, xr - m_perimeter_width * 2, y_step * 1.2f, 1.74f, 5200);
+	}
+
+	// Pull the filament end into a cooling tube.
+	writer.retract(15, 5000).retract(50, 5400).retract(15, 3000).deretract(12, 2000);
+
+	if (temperature != 0)
+		// Set the extruder temperature, but don't wait.
+		writer.set_extruder_temp(temperature, false);
+
+	// Horizontal cooling moves at the following y coordinate:
+	writer.travel(writer.x(), writer.y() + y_step * 0.8f, 1600);
+	switch (material)
+	{
+	case PVA:
+		writer.cool(xl, xr, 3, -5, 1600)
+			  .cool(xl, xr, 5, -5, 2000)
+			  .cool(xl, xr, 5, -5, 2200)
+			  .cool(xl, xr, 5, -5, 2400)
+			  .cool(xl, xr, 5, -5, 2400)
+			  .cool(xl, xr, 5, -5, 2400);
+		break;
+	case SCAFF:
+		writer.cool(xl, xr, 3, -5, 1600)
+			  .cool(xl, xr, 5, -5, 2000)
+			  .cool(xl, xr, 5, -5, 2200)
+			  .cool(xl, xr, 5, -5, 2200)
+			  .cool(xl, xr, 5, -5, 2400);
+		break;
+	default:
+		writer.cool(xl, xr, 3, -5, 1600)
+			  .cool(xl, xr, 5, -5, 2000)
+			  .cool(xl, xr, 5, -5, 2400)
+			  .cool(xl, xr, 5, -3, 2400);
+	}
+
+	writer.flush_planner_queue();
+}
+
+// Change the tool, set a speed override for solube and flex materials.
+void WipeTowerPrusaMM::toolchange_Change(
+	PrusaMultiMaterial::Writer &writer,
+	const int 		tool, 
+	material_type  /* current_material */, 
+	material_type 	new_material)
+{
+	// Speed override for the material. Go slow for flex and soluble materials.
+	int speed_override;
+	switch (new_material) {
+	case PVA:   speed_override = 80; break;
+	case SCAFF: speed_override = 35; break;
+	case FLEX:  speed_override = 35; break;
+	default:    speed_override = 100;
+	}
+	writer.set_tool(tool)
+	      .speed_override(speed_override)
+	      .flush_planner_queue();
+}
+
+void WipeTowerPrusaMM::toolchange_Load(
+	PrusaMultiMaterial::Writer &writer,
+	const box_coordinates  &cleaning_box)
+{
+	float xl = cleaning_box.ld.x + m_perimeter_width;
+	float xr = cleaning_box.rd.x - m_perimeter_width;
+
+	writer.append("; CP TOOLCHANGE LOAD\n")
+	// Load the filament while moving left / right,
+	// so the excess material will not create a blob at a single position.
+		  .deretract_move_x(xr, 20, 1400)
+		  .deretract_move_x(xl, 40, 3000)
+		  .deretract_move_x(xr, 20, 1600)
+		  .deretract_move_x(xl, 10, 1000);
+
+	// Extrude first five lines (just three lines if colorInit is set).
+	writer.extrude(xr, writer.y(), 1600);
+	bool colorInit = false;
+	size_t pass = colorInit ? 1 : 2;
+	for (int i = 0; i < pass; ++ i)
+		writer.travel (xr, writer.y() + m_current_shape * m_perimeter_width * 0.85f, 2200)
+			  .extrude(xl, writer.y())
+			  .travel (xl, writer.y() + m_current_shape * m_perimeter_width * 0.85f)
+			  .extrude(xr, writer.y());
+
+	// Reset the extruder current to the normal value.
+	writer.set_extruder_trimpot(550);
+}
+
+// Wipe the newly loaded filament until the end of the assigned wipe area.
+void WipeTowerPrusaMM::toolchange_Wipe(
+	PrusaMultiMaterial::Writer &writer,
+	const box_coordinates  &cleaning_box,
+	const material_type 	material)
+{
+	// Increase flow on first layer, slow down print.
+	writer.set_extrusion_flow(m_extrusion_flow * (m_is_first_layer ? 1.18f : 1.f))
+		  .append("; CP TOOLCHANGE WIPE\n");
+	float wipe_coeff = m_is_first_layer ? 0.5f : 1.f;
+	float xl = cleaning_box.ld.x + 2.f * m_perimeter_width;
+	float xr = cleaning_box.rd.x - 2.f * m_perimeter_width;
+	// Wipe speed will increase up to 4800.
+	float wipe_speed = 4200;
+	// Y increment per wipe line.
+	float dy = m_current_shape * m_perimeter_width * 0.7f;
+	for (bool p = true; ; p = ! p) {
+		writer.feedrate((wipe_speed = std::min(4800.f, wipe_speed + 50.f)) * wipe_coeff);
+		if (p)
+			writer.extrude(xl - m_perimeter_width/2, writer.y() + dy)
+			      .extrude(xr + m_perimeter_width,   writer.y());
+		else
+			writer.extrude(xl - m_perimeter_width,   writer.y() + dy)
+				  .extrude(xr + m_perimeter_width*2, writer.y());
+		writer.feedrate((wipe_speed = std::min(4800.f, wipe_speed + 50.f)) * wipe_coeff)
+			  .extrude(xr + m_perimeter_width, writer.y() + dy)
+			  .extrude(xl - m_perimeter_width, writer.y());
+		if ((m_current_shape == SHAPE_NORMAL) ?
+			(writer.y() > cleaning_box.lu.y - m_perimeter_width) :
+			(writer.y() < cleaning_box.ld.y + m_perimeter_width))
+			// Next wipe line does not fit the cleaning box.
+			break;
+	}
+	// Reset the extrusion flow.
+	writer.set_extrusion_flow(m_extrusion_flow);
+}
+
+// Draw a perimeter around cleaning_box and wipe.
+void WipeTowerPrusaMM::toolchange_Done(
+	PrusaMultiMaterial::Writer &writer,
+	const box_coordinates 	&cleaning_box)
+{
+	box_coordinates box = cleaning_box;
+	if (m_current_shape == SHAPE_REVERSED) {
+		std::swap(box.lu, box.ld);
+		std::swap(box.ru, box.rd);
+	}
+	// Draw a perimeter around cleaning_box.
+	writer.travel(box.lu, 7000)
+		  .extrude(box.ld, 3200).extrude(box.rd)
+		  .extrude(box.ru).extrude(box.lu)
+		  // Wipe the nozzle.
+		  .travel(box.ru, 7200)
+		  .travel(box.lu)
+		  .feedrate(6000);
+}
+
+std::pair<std::string, WipeTower::xy> WipeTowerPrusaMM::close_layer()
+{
+	PrusaMultiMaterial::Writer writer;
+	writer.set_extrusion_flow(m_extrusion_flow)
+		  .set_z(m_z_pos)
+		  .append(";--------------------\n"
+				  "; CP EMPTY GRID START\n")
+		  .comment_with_value(" layer #", m_layer_change_total ++);
+
+	// Slow down on the 1st layer.
+	float speed_factor = m_is_first_layer ? 0.5f : 1.f;
+
+	box_coordinates _p  = _boxForColor(m_layer_change_in_layer);
+	{
+		box_coordinates _to = _boxForColor(m_max_color_changes);
+		float firstLayerOffset = 0.f;
+		_p.ld.y += firstLayerOffset;
+		_p.rd.y += firstLayerOffset;
+		_p.lu = _to.lu; _p.ru = _to.ru;
+	}
+
+	if (m_layer_change_in_layer == 0)
+		// There were no tool changes at all in this layer.
+		// Jump with retract to _p.ld + a random shift in +x.
+		writer.retract(m_retract * 1.5f, 3600)
+			  .z_hop(m_zhop, 7200)
+			  .travel(_p.ld.x + randi(5, 20), _p.ld.y, 7000)
+			  .z_hop(0, 7200)
+			  .extrude_explicit(_p.ld, m_retract * 1.5f, 3600);
+
+	box_coordinates box = _p;
+	writer.extrude(box.lu, 2400 * speed_factor)
+		  .extrude(box.ru)
+		  .extrude(box.rd)
+		  .extrude(box.ld + xy(m_perimeter_width / 2, 0));
+
+	box.expand(- m_perimeter_width / 2);
+	writer.extrude(box.lu, 3200 * speed_factor)
+		  .extrude(box.ru)
+		  .extrude(box.rd)
+		  .extrude(box.ld + xy(m_perimeter_width / 2, 0))
+		  .extrude(box.ld + xy(m_perimeter_width / 2, m_perimeter_width / 2));
+
+	writer.extrude(_p.ld + xy(m_perimeter_width * 3,   m_perimeter_width), 2900 * speed_factor)
+	      .extrude(_p.lu + xy(m_perimeter_width * 3, - m_perimeter_width))
+		  .extrude(_p.lu + xy(m_perimeter_width * 6, - m_perimeter_width))
+		  .extrude(_p.ld + xy(m_perimeter_width * 6,   m_perimeter_width));
+
+	if (_p.lu.y - _p.ld.y > 4) {
+		// Extrude three zig-zags.
+		writer.feedrate(3200 * speed_factor);
+		float step = (m_wipe_tower_width - m_perimeter_width * 12.f) / 12.f;
+		for (size_t i = 0; i < 3; ++ i) {
+			writer.extrude(writer.x() + step, _p.ld.y + m_perimeter_width * 8);
+			writer.extrude(writer.x()       , _p.lu.y - m_perimeter_width * 8);
+			writer.extrude(writer.x() + step, _p.lu.y - m_perimeter_width    );
+			writer.extrude(writer.x() + step, _p.lu.y - m_perimeter_width * 8);
+			writer.extrude(writer.x()       , _p.ld.y + m_perimeter_width * 8);
+			writer.extrude(writer.x() + step, _p.ld.y + m_perimeter_width    );
+		}
+	}
+
+	// Extrude the perimeter.
+	writer.extrude(_p.ru + xy(- m_perimeter_width * 6, - m_perimeter_width), 2900 * speed_factor)
+		  .extrude(_p.ru + xy(- m_perimeter_width * 3, - m_perimeter_width))
+		  .extrude(_p.rd + xy(- m_perimeter_width * 3,   m_perimeter_width))
+		  .extrude(_p.rd + xy(- m_perimeter_width,       m_perimeter_width))
+       	  // Wipe along the front side of the current wiping box.
+		  .travel(_p.ld + xy(  m_perimeter_width, m_perimeter_width / 2), 7200)
+		  .travel(_p.rd + xy(- m_perimeter_width, m_perimeter_width / 2))
+		  .append("; CP EMPTY GRID END\n"
+			      ";------------------\n\n\n\n\n\n\n");
+
+	m_current_shape = wipe_shape(- m_current_shape);
+	return std::pair<std::string, xy>(writer.gcode(), writer.pos());
+}
+
+WipeTowerPrusaMM::box_coordinates WipeTowerPrusaMM::_boxForColor(int order) const
+{
+	return box_coordinates(m_wipe_tower_pos.x, m_wipe_tower_pos.y + m_wipe_area * order - m_perimeter_width / 2, m_wipe_tower_width, m_perimeter_width);
+}
+
+}; // namespace Slic3r

xs/src/libslic3r/GCode/WipeTowerPrusaMM.hpp

@@ -0,0 +1,217 @@
+#ifndef WipeTowerPrusaMM_hpp_
+#define WipeTowerPrusaMM_hpp_
+
+#include <algorithm>
+#include <string>
+#include <utility>
+
+#include "WipeTower.hpp"
+
+namespace Slic3r
+{
+
+namespace PrusaMultiMaterial {
+	class Writer;
+};
+
+class WipeTowerPrusaMM : public WipeTower
+{
+public:
+	enum material_type
+	{
+		INVALID = -1,
+		PLA   = 0,		// E:210C	B:55C
+		ABS   = 1,		// E:255C	B:100C
+		PET   = 2,		// E:240C	B:90C
+		HIPS  = 3,		// E:220C	B:100C
+		FLEX  = 4,		// E:245C	B:80C
+		SCAFF = 5,		// E:215C	B:55C
+		EDGE  = 6,		// E:240C	B:80C
+		NGEN  = 7,		// E:230C	B:80C
+		PVA   = 8	    // E:210C	B:80C
+	};
+
+	// Parse material name into material_type.
+	static material_type parse_material(const char *name);
+
+	// 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
+	WipeTowerPrusaMM(float x, float y, float width, float wipe_area) :
+		m_wipe_tower_pos(x, y),
+		m_wipe_tower_width(width),
+		m_wipe_area(wipe_area),
+		m_z_pos(0.f) {
+		for (size_t i = 0; i < 4; ++ i) {
+			// Extruder specific parameters.
+			m_material[i] = PLA;
+			m_temperature[i] = 0;
+			m_first_layer_temperature[i] = 0;
+		}
+	}
+	virtual ~WipeTowerPrusaMM() {}
+
+	// _retract - retract value in mm
+	void set_retract(float retract) { m_retract = retract; }
+	
+	// _zHop - z hop value in mm
+	void set_zhop(float zhop) { m_zhop = zhop; }
+
+	// Set the extruder properties.
+	void set_extruder(size_t idx, material_type material, int temp, int first_layer_temp)
+	{
+		m_material[idx] = material;
+		m_temperature[idx] = temp;
+		m_first_layer_temperature[idx] = first_layer_temp;
+	}
+
+	// Switch to a next layer.
+	virtual 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.
+		bool   is_first_layer,
+		// Is this the last layer of the waste tower?
+		bool   is_last_layer)
+	{
+		m_z_pos 				= print_z;
+		m_max_color_changes 	= max_tool_changes;
+		m_is_first_layer 		= is_first_layer;
+		m_is_last_layer			= is_last_layer;
+		// Start counting the color changes from zero.
+		m_layer_change_in_layer = is_first_layer ? size_t(-1) : 0;
+		m_current_wipe_start_y  = 0.f;
+
+		int layer_idx = int(floor(layer_height * 100) + 0.5f);
+		switch (layer_idx)
+		{
+		case 15:
+			m_extrusion_flow = (float)0.024;
+			break;
+		case 20:
+		default:
+			m_extrusion_flow = (float)0.029;
+			break;
+		}
+	}
+
+	// Return the wipe tower position.
+	virtual const xy& position() const { return m_wipe_tower_pos; }
+	// The wipe tower is finished, there should be no more tool changes or wipe tower prints.
+	virtual bool 	  finished() const { return m_max_color_changes == 0; }
+
+	// Returns gcode for toolchange 
+	virtual std::pair<std::string, xy> tool_change(int new_tool);
+
+	// Close the current wipe tower layer with a perimeter and possibly fill the unfilled space with a zig-zag.
+	virtual std::pair<std::string, xy> close_layer();
+
+private:
+	WipeTowerPrusaMM();
+
+	enum wipe_shape
+	{
+		SHAPE_NORMAL   = 1,
+		SHAPE_REVERSED = -1
+	};
+
+	// Left front corner of the wipe tower in mm.
+	xy     m_wipe_tower_pos;
+	// Width of the wipe tower.
+	float  m_wipe_tower_width;
+	// Per color Y span.
+	float  m_wipe_area;
+	// Current Z position.
+	float  m_z_pos 			= 0.f;
+	// Maximum number of color changes per layer.
+	size_t m_max_color_changes = 0;
+	// Is this the 1st layer of the print? If so, print the brim around the waste tower.
+	bool   m_is_first_layer = false;
+	// Is this the last layer of this waste tower?
+	bool   m_is_last_layer  = false;
+
+	// G-code generator parameters.
+	float  m_zhop 			 = 0.5f;
+	float  m_retract		 = 4.f;
+	float  m_perimeter_width = 0.5f;
+	float  m_extrusion_flow  = 0.029f;
+
+	// Extruder specific parameters.
+	material_type 	m_material[4];
+	int  			m_temperature[4];
+	int  			m_first_layer_temperature[4];
+
+	// State of the wiper tower generator.
+	// Layer change counter for the output statistics.
+	unsigned int 	m_layer_change_total = 0;
+	// Layer change counter in this layer. Counting up to m_max_color_changes.
+	unsigned int 	m_layer_change_in_layer = 0;
+	wipe_shape   	m_current_shape = SHAPE_NORMAL;
+	material_type 	m_current_material = PLA;
+	// Current y position at the wipe tower.
+	float 		 	m_current_wipe_start_y = 0.f;
+
+	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 xy &pos, float width, float height) : box_coordinates(pos.x, pos.y, width, height) {}
+		void expand(const float offset) {
+			ld += xy(- offset, - offset);
+			lu += xy(- offset,   offset);
+			rd += xy(  offset, - offset);
+			ru += xy(  offset,   offset);
+		}
+		xy ld;  // left down
+		xy lu;	// left upper 
+		xy ru;	// right upper
+		xy rd;	// right lower
+	};
+
+	// Returns gcode for wipe tower brim
+	// sideOnly			-- set to false -- experimental, draw brim on sides of wipe tower 
+	// offset			-- set to 0		-- experimental, offset to replace brim in front / rear of wipe tower
+	std::pair<std::string, WipeTower::xy> toolchange_Brim(size_t tool, bool sideOnly = false, float y_offset = 0.f);
+
+	void toolchange_Unload(
+		PrusaMultiMaterial::Writer &writer,
+		const box_coordinates  &cleaning_box, 
+		const material_type	 	material,
+		const wipe_shape 	    shape,
+		const int 				temperature);
+
+	void toolchange_Change(
+		PrusaMultiMaterial::Writer &writer,
+		int 					tool,
+		material_type 			current_material,
+		material_type 			new_material);
+	
+	void toolchange_Load(
+		PrusaMultiMaterial::Writer &writer,
+		const box_coordinates  &cleaning_box);
+	
+	void toolchange_Wipe(
+		PrusaMultiMaterial::Writer &writer,
+		const box_coordinates  &cleaning_box, 
+		const material_type 	material);
+	
+	void toolchange_Done(
+		PrusaMultiMaterial::Writer &writer,
+		const box_coordinates  &cleaning_box);
+
+	void toolchange_Perimeter();
+
+	box_coordinates _boxForColor(int order) const;
+};
+
+}; // namespace Slic3r
+
+#endif /* WipeTowerPrusaMM_hpp_ */