WIP: Ironing over top surfaces.

src/libslic3r/Fill/Fill.cpp

@@ -10,6 +10,7 @@
 #include "../Surface.hpp"
 
 #include "FillBase.hpp"
+#include "FillRectilinear2.hpp"
 
 namespace Slic3r {
 
@@ -388,8 +389,8 @@ void Layer::make_fills()
 		        	flow_width      = new_flow.width;
 		        }
 		        // Save into layer.
-		        auto *eec = new ExtrusionEntityCollection();
-		        m_regions[surface_fill.region_id]->fills.entities.push_back(eec);
+				ExtrusionEntityCollection* eec = nullptr;
+		        m_regions[surface_fill.region_id]->fills.entities.push_back(eec = new ExtrusionEntityCollection());
 		        // Only concentric fills are not sorted.
 		        eec->no_sort = f->no_sort();
 		        extrusion_entities_append_paths(
@@ -418,4 +419,163 @@ void Layer::make_fills()
 #endif
 }
 
+// Create ironing extrusions over top surfaces.
+void Layer::make_ironing()
+{
+	// LayerRegion::slices contains surfaces marked with SurfaceType.
+	// Here we want to collect top surfaces extruded with the same extruder.
+	// A surface will be ironed with the same extruder to not contaminate the print with another material leaking from the nozzle.
+
+	// First classify regions based on the extruder used.
+	struct IroningParams {
+		int 		extruder 	= -1;
+		bool 		just_infill = false;
+		// Spacing of the ironing lines, also to calculate the extrusion flow from.
+		double 		line_spacing;
+		// Height of the extrusion, to calculate the extrusion flow from.
+		double 		height;
+		double 		speed;
+		double 		angle;
+
+		bool operator<(const IroningParams &rhs) const {
+			if (this->extruder < rhs.extruder)
+				return true;
+			if (this->extruder > rhs.extruder)
+				return false;
+			if (int(this->just_infill) < int(rhs.just_infill))
+				return true;
+			if (int(this->just_infill) > int(rhs.just_infill))
+				return false;
+			if (this->line_spacing < rhs.line_spacing)
+				return true;
+			if (this->line_spacing > rhs.line_spacing)
+				return false;
+			if (this->height < rhs.height)
+				return true;
+			if (this->height > rhs.height)
+				return false;
+			if (this->speed < rhs.speed)
+				return true;
+			if (this->speed > rhs.speed)
+				return false;
+			if (this->angle < rhs.angle)
+				return true;
+			if (this->angle > rhs.angle)
+				return false;
+			return false;
+		}
+
+		bool operator==(const IroningParams &rhs) const {
+			return this->extruder == rhs.extruder && this->just_infill == rhs.just_infill &&
+				   this->line_spacing == rhs.line_spacing && this->height == rhs.height && this->speed == rhs.speed &&
+				   this->angle == rhs.angle;
+		}
+
+		LayerRegion *layerm		= nullptr;
+
+		// IdeaMaker: ironing
+		// ironing flowrate (5% percent)
+		// ironing speed (10 mm/sec)
+
+		// Kisslicer: 
+		// iron off, Sweep, Group
+		// ironing speed: 15 mm/sec
+
+		// Cura:
+		// Pattern (zig-zag / concentric)
+		// line spacing (0.1mm)
+		// flow: from normal layer height. 10%
+		// speed: 20 mm/sec
+	};
+
+	std::vector<IroningParams> by_extruder;
+	bool   extruder_dont_care   = this->object()->config().wipe_into_objects;
+    double default_layer_height = this->object()->config().layer_height;
+
+	for (LayerRegion *layerm : m_regions)
+		if (! layerm->slices.empty()) {
+			IroningParams ironing_params;
+			const PrintRegionConfig &config = layerm->region()->config();
+			if (config.ironing_type == IroningType::AllSolid ||
+				(config.top_solid_layers > 0 && 
+					(config.ironing_type == IroningType::TopSurfaces ||
+					 (config.ironing_type == IroningType::TopmostOnly && layerm->layer()->upper_layer == nullptr)))) {
+				if (config.perimeter_extruder == config.solid_infill_extruder || config.perimeters == 0) {
+					// Iron the whole face.
+					ironing_params.extruder = config.solid_infill_extruder;
+				} else {
+					// Iron just the infill.
+					ironing_params.extruder = config.solid_infill_extruder;
+				}
+			}
+			if (ironing_params.extruder != -1) {
+				ironing_params.just_infill 	= false;
+				ironing_params.line_spacing = config.ironing_spacing;
+				ironing_params.height 		= default_layer_height * 0.01 * config.ironing_flowrate;
+				ironing_params.speed 		= config.ironing_speed;
+				ironing_params.angle 		= config.fill_angle * M_PI / 180.;
+				ironing_params.layerm 		= layerm;
+				by_extruder.emplace_back(ironing_params);
+			}
+		}
+	std::sort(by_extruder.begin(), by_extruder.end());
+
+    FillRectilinear2 	fill;
+    FillParams 			fill_params;
+	fill.set_bounding_box(this->object()->bounding_box());
+	fill.layer_id 			 = this->id();
+    fill.z 					 = this->print_z;
+    fill.overlap 			 = 0;
+    fill_params.density 	 = 1.;
+    fill_params.dont_connect = true;
+
+	for (size_t i = 0; i < by_extruder.size(); ++ i) {
+		// Find span of regions equivalent to the ironing operation.
+		IroningParams &ironing_params = by_extruder[i];
+		size_t j = i;
+		for (++ j; j < by_extruder.size() && ironing_params == by_extruder[j]; ++ j) ;
+
+		// Create the ironing extrusions for regions <i, j)
+		ExPolygons ironing_areas;
+		double nozzle_dmr = this->object()->print()->config().nozzle_diameter.values[ironing_params.extruder - 1];
+		if (ironing_params.just_infill) {
+			// Just infill.
+		} else {
+			// Infill and perimeter.
+			// Merge top surfaces with the same ironing parameters.
+			Polygons polys;
+			for (size_t k = i; k < j; ++ k)
+				for (const Surface &surface : by_extruder[k].layerm->slices.surfaces)
+					if (surface.surface_type == stTop)
+						polygons_append(polys, surface.expolygon);
+			// Trim the top surfaces with half the nozzle diameter.
+			ironing_areas = intersection_ex(polys, offset(this->lslices, - float(scale_(0.5 * nozzle_dmr))));
+		}
+
+        // Create the filler object.
+        fill.spacing = ironing_params.line_spacing;
+        fill.angle = float(ironing_params.angle + 0.25 * M_PI);
+        fill.link_max_length = (coord_t)scale_(3. * fill.spacing);
+		double height = ironing_params.height * fill.spacing / nozzle_dmr;
+        Flow flow = Flow::new_from_spacing(float(nozzle_dmr), 0., float(height), false);
+        double flow_mm3_per_mm = flow.mm3_per_mm();
+        Surface surface_fill(stTop, ExPolygon());
+        for (ExPolygon &expoly : ironing_areas) {
+			surface_fill.expolygon = std::move(expoly);
+			Polylines polylines = fill.fill_surface(&surface_fill, fill_params);
+	        if (! polylines.empty()) {
+		        // Save into layer.
+				ExtrusionEntityCollection *eec = nullptr;
+		        ironing_params.layerm->fills.entities.push_back(eec = new ExtrusionEntityCollection());
+		        //FIXME we may not want to sort a monotonous infill.
+		        eec->no_sort = false;
+		        extrusion_entities_append_paths(
+		            eec->entities, std::move(polylines),
+		            erIroning,
+		            flow_mm3_per_mm, float(flow.width), float(height));
+		    }
+		}
+	}
+}
+
 } // namespace Slic3r