#include <src/libslic3r/GCode.hpp>

Collaboration diagram for Slic3r::GCode:

Classes
class	GCodeOutputStream

struct	InstanceToPrint

struct	ObjectLayerToPrint

struct	PlaceholderParserIntegration

Public Types
using	ObjectsLayerToPrint = std::vector< ObjectLayerToPrint >

Public Member Functions
	GCode ()

	~GCode ()=default

void	do_export (Print print, const char path, GCodeProcessorResult *result=nullptr, ThumbnailsGeneratorCallback thumbnail_cb=nullptr)

const Vec2d &	origin () const

void	set_origin (const Vec2d &pointf)

void	set_origin (const coordf_t x, const coordf_t y)

const Point &	last_pos () const

Vec2d	point_to_gcode (const Point &point) const

Vec2d	point_to_gcode_quantized (const Point &point) const

Point	gcode_to_point (const Vec2d &point) const

const FullPrintConfig &	config () const

const Layer *	layer () const

GCodeWriter &	writer ()

const GCodeWriter &	writer () const

PlaceholderParser &	placeholder_parser ()

const PlaceholderParser &	placeholder_parser () const

std::string	placeholder_parser_process (const std::string &name, const std::string &templ, unsigned int current_extruder_id, const DynamicConfig *config_override=nullptr)

bool	enable_cooling_markers () const

unsigned int	layer_count () const

void	set_layer_count (unsigned int value)

void	apply_print_config (const PrintConfig &print_config)

Static Public Member Functions
static void	append_full_config (const Print &print, std::string &str)

Private Member Functions
void	_do_export (Print &print, GCodeOutputStream &file, ThumbnailsGeneratorCallback thumbnail_cb)

LayerResult	process_layer (const Print &print, const ObjectsLayerToPrint &layers, const LayerTools &layer_tools, const bool last_layer, const std::vector< const PrintInstance * > *ordering, const size_t single_object_idx=size_t(-1))

void	process_layers (const Print &print, const ToolOrdering &tool_ordering, const std::vector< const PrintInstance * > &print_object_instances_ordering, const std::vector< std::pair< coordf_t, ObjectsLayerToPrint > > &layers_to_print, GCodeOutputStream &output_stream)

void	process_layers (const Print &print, const ToolOrdering &tool_ordering, ObjectsLayerToPrint layers_to_print, const size_t single_object_idx, GCodeOutputStream &output_stream)

void	set_last_pos (const Point &pos)

bool	last_pos_defined () const

void	set_extruders (const std::vector< unsigned int > &extruder_ids)

std::string	preamble ()

std::string	change_layer (coordf_t print_z)

std::string	extrude_entity (const ExtrusionEntity &entity, const std::string_view description, double speed=-1.)

std::string	extrude_loop (ExtrusionLoop loop, const std::string_view description, double speed=-1.)

std::string	extrude_multi_path (ExtrusionMultiPath multipath, const std::string_view description, double speed=-1.)

std::string	extrude_path (ExtrusionPath path, const std::string_view description, double speed=-1.)

std::vector< InstanceToPrint >	sort_print_object_instances (const std::vector< ObjectLayerToPrint > &layers, const std::vector< const PrintInstance * > *ordering, const size_t single_object_instance_idx)

void	process_layer_single_object (std::string &gcode, const unsigned int extruder_id, const InstanceToPrint &print_instance, const ObjectLayerToPrint &layer_to_print, const LayerTools &layer_tools, const bool is_anything_overridden, const bool print_wipe_extrusions)

std::string	extrude_support (const ExtrusionEntityCollection &support_fills)

std::string	travel_to (const Point &point, ExtrusionRole role, std::string comment)

bool	needs_retraction (const Polyline &travel, ExtrusionRole role=ExtrusionRole::None)

std::string	retract (bool toolchange=false)

std::string	unretract ()

std::string	set_extruder (unsigned int extruder_id, double print_z)

std::string	_extrude (const ExtrusionPath &path, const std::string_view description, double speed=-1)

void	print_machine_envelope (GCodeOutputStream &file, Print &print)

void	_print_first_layer_bed_temperature (GCodeOutputStream &file, Print &print, const std::string &gcode, unsigned int first_printing_extruder_id, bool wait)

void	_print_first_layer_extruder_temperatures (GCodeOutputStream &file, Print &print, const std::string &gcode, unsigned int first_printing_extruder_id, bool wait)

bool	on_first_layer () const

bool	object_layer_over_raft () const

Static Private Member Functions
static ObjectsLayerToPrint	collect_layers_to_print (const PrintObject &object)

static std::vector< std::pair< coordf_t, ObjectsLayerToPrint > >	collect_layers_to_print (const Print &print)

Private Attributes
SeamPlacer	m_seam_placer

ExtrusionQualityEstimator	m_extrusion_quality_estimator

Vec2d	m_origin

FullPrintConfig	m_config

double	m_scaled_resolution

GCodeWriter	m_writer

struct Slic3r::GCode::PlaceholderParserIntegration	m_placeholder_parser_integration

OozePrevention	m_ooze_prevention

Wipe	m_wipe

AvoidCrossingPerimeters	m_avoid_crossing_perimeters

JPSPathFinder	m_avoid_crossing_curled_overhangs

RetractWhenCrossingPerimeters	m_retract_when_crossing_perimeters

bool	m_enable_loop_clipping

bool	m_enable_cooling_markers

bool	m_enable_extrusion_role_markers

GCodeExtrusionRole	m_last_processor_extrusion_role

unsigned int	m_layer_count

int	m_layer_index

const Layer *	m_layer

bool	m_object_layer_over_raft

double	m_volumetric_speed

GCodeExtrusionRole	m_last_extrusion_role

float	m_last_height { 0.0f }

float	m_last_layer_z { 0.0f }

float	m_max_layer_z { 0.0f }

float	m_last_width { 0.0f }

Point	m_last_pos

bool	m_last_pos_defined

std::unique_ptr< CoolingBuffer >	m_cooling_buffer

std::unique_ptr< SpiralVase >	m_spiral_vase

std::unique_ptr< GCodeFindReplace >	m_find_replace

std::unique_ptr< PressureEqualizer >	m_pressure_equalizer

std::unique_ptr< WipeTowerIntegration >	m_wipe_tower

std::vector< coordf_t >	m_skirt_done

bool	m_brim_done

bool	m_second_layer_things_done

std::pair< const PrintObject *, Point >	m_last_obj_copy

bool	m_silent_time_estimator_enabled

GCodeProcessor	m_processor

Friends
class	Wipe

class	WipeTowerIntegration

class	PressureEqualizer

Detailed Description

Member Typedef Documentation

◆ ObjectsLayerToPrint

using Slic3r::GCode::ObjectsLayerToPrint = std::vector<ObjectLayerToPrint>

Constructor & Destructor Documentation

◆ GCode()

Slic3r::GCode::GCode ( )

inline

            : 
      m_origin(Vec2d::Zero()),
        m_enable_loop_clipping(true), 
        m_enable_cooling_markers(false), 
        m_enable_extrusion_role_markers(false),
        m_last_processor_extrusion_role(GCodeExtrusionRole::None),
        m_layer_count(0),
        m_layer_index(-1), 
        m_layer(nullptr),
        m_object_layer_over_raft(false),
        m_volumetric_speed(0),
        m_last_pos_defined(false),
        m_last_extrusion_role(GCodeExtrusionRole::None),
        m_last_width(0.0f),
#if ENABLE_GCODE_VIEWER_DATA_CHECKING
        m_last_mm3_per_mm(0.0),
#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
        m_brim_done(false),
        m_second_layer_things_done(false),
        m_silent_time_estimator_enabled(false),
        m_last_obj_copy(nullptr, Point(std::numeric_limits<coord_t>::max(), std::numeric_limits<coord_t>::max()))
        {}

◆ ~GCode()

Slic3r::GCode::~GCode ( )

default

Member Function Documentation

◆ _do_export()

void Slic3r::GCode::_do_export	(	Print &	print,
		GCodeOutputStream &	file,
		ThumbnailsGeneratorCallback	thumbnail_cb
	)

private

{
    // modifies m_silent_time_estimator_enabled
    DoExport::init_gcode_processor(print.config(), m_processor, m_silent_time_estimator_enabled);
 
    if (! print.config().gcode_substitutions.values.empty()) {
        m_find_replace = make_unique<GCodeFindReplace>(print.config());
        file.set_find_replace(m_find_replace.get(), false);
    }
 
    // resets analyzer's tracking data
    m_last_height  = 0.f;
    m_last_layer_z = 0.f;
    m_max_layer_z  = 0.f;
    m_last_width = 0.f;
#if ENABLE_GCODE_VIEWER_DATA_CHECKING
    m_last_mm3_per_mm = 0.;
#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
 
    // How many times will be change_layer() called?
    // change_layer() in turn increments the progress bar status.
    m_layer_count = 0;
    if (print.config().complete_objects.value) {
        // Add each of the object's layers separately.
        for (auto object : print.objects()) {
            std::vector<coordf_t> zs;
            zs.reserve(object->layers().size() + object->support_layers().size());
            for (auto layer : object->layers())
                zs.push_back(layer->print_z);
            for (auto layer : object->support_layers())
                zs.push_back(layer->print_z);
            std::sort(zs.begin(), zs.end());
            m_layer_count += (unsigned int)(object->instances().size() * (std::unique(zs.begin(), zs.end()) - zs.begin()));
        }
    }
    print.throw_if_canceled();
 
    m_enable_cooling_markers = true;
    this->apply_print_config(print.config());
 
    m_volumetric_speed = DoExport::autospeed_volumetric_limit(print);
    print.throw_if_canceled();
 
    if (print.config().spiral_vase.value)
        m_spiral_vase = make_unique<SpiralVase>(print.config());
 
    if (print.config().max_volumetric_extrusion_rate_slope_positive.value > 0 ||
        print.config().max_volumetric_extrusion_rate_slope_negative.value > 0)
        m_pressure_equalizer = make_unique<PressureEqualizer>(print.config());
    m_enable_extrusion_role_markers = (bool)m_pressure_equalizer;
 
    if (print.config().avoid_crossing_curled_overhangs){
        this->m_avoid_crossing_curled_overhangs.init_bed_shape(get_bed_shape(print.config()));
    }
 
    // Write information on the generator.
    file.write_format("; %s\n\n", Slic3r::header_slic3r_generated().c_str());
 
    // Unit tests or command line slicing may not define "thumbnails" or "thumbnails_format".
    // If "thumbnails_format" is not defined, export to PNG.
    if (const auto [thumbnails, thumbnails_format] = std::make_pair(
            print.full_print_config().option<ConfigOptionPoints>("thumbnails"),
            print.full_print_config().option<ConfigOptionEnum<GCodeThumbnailsFormat>>("thumbnails_format"));
        thumbnails)
        GCodeThumbnails::export_thumbnails_to_file(
            thumbnail_cb, thumbnails->values, thumbnails_format ? thumbnails_format->value : GCodeThumbnailsFormat::PNG,
            [&file](const char* sz) { file.write(sz); },
            [&print]() { print.throw_if_canceled(); });
 
    // Write notes (content of the Print Settings tab -> Notes)
    {
        std::list<std::string> lines;
        boost::split(lines, print.config().notes.value, boost::is_any_of("\n"), boost::token_compress_off);
        for (auto line : lines) {
            // Remove the trailing '\r' from the '\r\n' sequence.
            if (! line.empty() && line.back() == '\r')
                line.pop_back();
            file.write_format("; %s\n", line.c_str());
        }
        if (! lines.empty())
            file.write("\n");
    }
    print.throw_if_canceled();
 
    // Write some terse information on the slicing parameters.
    const PrintObject *first_object         = print.objects().front();
    const double       layer_height         = first_object->config().layer_height.value;
    assert(! print.config().first_layer_height.percent);
    const double       first_layer_height   = print.config().first_layer_height.value;
    for (size_t region_id = 0; region_id < print.num_print_regions(); ++ region_id) {
        const PrintRegion &region = print.get_print_region(region_id);
        file.write_format("; external perimeters extrusion width = %.2fmm\n", region.flow(*first_object, frExternalPerimeter, layer_height).width());
        file.write_format("; perimeters extrusion width = %.2fmm\n",          region.flow(*first_object, frPerimeter,         layer_height).width());
        file.write_format("; infill extrusion width = %.2fmm\n",              region.flow(*first_object, frInfill,            layer_height).width());
        file.write_format("; solid infill extrusion width = %.2fmm\n",        region.flow(*first_object, frSolidInfill,       layer_height).width());
        file.write_format("; top infill extrusion width = %.2fmm\n",          region.flow(*first_object, frTopSolidInfill,    layer_height).width());
        if (print.has_support_material())
            file.write_format("; support material extrusion width = %.2fmm\n", support_material_flow(first_object).width());
        if (print.config().first_layer_extrusion_width.value > 0)
            file.write_format("; first layer extrusion width = %.2fmm\n",   region.flow(*first_object, frPerimeter, first_layer_height, true).width());
        file.write_format("\n");
    }
    print.throw_if_canceled();
 
    // adds tags for time estimators
    if (print.config().remaining_times.value)
        file.write_format(";%s\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::First_Line_M73_Placeholder).c_str());
 
    // Starting now, the G-code find / replace post-processor will be enabled.
    file.find_replace_enable();
 
    // Prepare the helper object for replacing placeholders in custom G-code and output filename.
    m_placeholder_parser_integration.parser = print.placeholder_parser();
    m_placeholder_parser_integration.parser.update_timestamp();
    m_placeholder_parser_integration.context.rng = std::mt19937(std::chrono::high_resolution_clock::now().time_since_epoch().count());
    // Enable passing global variables between PlaceholderParser invocations.
    m_placeholder_parser_integration.context.global_config = std::make_unique<DynamicConfig>();
    print.update_object_placeholders(m_placeholder_parser_integration.parser.config_writable(), ".gcode");
 
    // Get optimal tool ordering to minimize tool switches of a multi-exruder print.
    // For a print by objects, find the 1st printing object.
    ToolOrdering tool_ordering;
    unsigned int initial_extruder_id = (unsigned int)-1;
    unsigned int final_extruder_id   = (unsigned int)-1;
    bool         has_wipe_tower      = false;
    std::vector<const PrintInstance*>           print_object_instances_ordering;
    std::vector<const PrintInstance*>::const_iterator   print_object_instance_sequential_active;
    if (print.config().complete_objects.value) {
        // Order object instances for sequential print.
        print_object_instances_ordering = sort_object_instances_by_model_order(print);
//        print_object_instances_ordering = sort_object_instances_by_max_z(print);
        // Find the 1st printing object, find its tool ordering and the initial extruder ID.
        print_object_instance_sequential_active = print_object_instances_ordering.begin();
        for (; print_object_instance_sequential_active != print_object_instances_ordering.end(); ++ print_object_instance_sequential_active) {
            tool_ordering = ToolOrdering(*(*print_object_instance_sequential_active)->print_object, initial_extruder_id);
            if ((initial_extruder_id = tool_ordering.first_extruder()) != static_cast<unsigned int>(-1))
                break;
        }
        if (initial_extruder_id == static_cast<unsigned int>(-1))
            // No object to print was found, cancel the G-code export.
            throw Slic3r::SlicingError(_u8L("No extrusions were generated for objects."));
        // We don't allow switching of extruders per layer by Model::custom_gcode_per_print_z in sequential mode.
        // Use the extruder IDs collected from Regions.
        this->set_extruders(print.extruders());
    } else {
        // Find tool ordering for all the objects at once, and the initial extruder ID.
        // If the tool ordering has been pre-calculated by Print class for wipe tower already, reuse it.
        tool_ordering = print.tool_ordering();
        tool_ordering.assign_custom_gcodes(print);
        if (tool_ordering.all_extruders().empty())
            // No object to print was found, cancel the G-code export.
            throw Slic3r::SlicingError(_u8L("No extrusions were generated for objects."));
        has_wipe_tower = print.has_wipe_tower() && tool_ordering.has_wipe_tower();
        initial_extruder_id = (has_wipe_tower && ! print.config().single_extruder_multi_material_priming) ?
            // The priming towers will be skipped.
            tool_ordering.all_extruders().back() :
            // Don't skip the priming towers.
            tool_ordering.first_extruder();
        // In non-sequential print, the printing extruders may have been modified by the extruder switches stored in Model::custom_gcode_per_print_z.
        // Therefore initialize the printing extruders from there.
        this->set_extruders(tool_ordering.all_extruders());
        // Order object instances using a nearest neighbor search.
        print_object_instances_ordering = chain_print_object_instances(print);
        m_layer_count = tool_ordering.layer_tools().size();
    }
    if (initial_extruder_id == (unsigned int)-1) {
        // Nothing to print!
        initial_extruder_id = 0;
        final_extruder_id   = 0;
    } else {
        final_extruder_id = tool_ordering.last_extruder();
        assert(final_extruder_id != (unsigned int)-1);
    }
    print.throw_if_canceled();
 
    m_cooling_buffer = make_unique<CoolingBuffer>(*this);
    m_cooling_buffer->set_current_extruder(initial_extruder_id);
 
    // Emit machine envelope limits for the Marlin firmware.
    this->print_machine_envelope(file, print);
 
    // Update output variables after the extruders were initialized.
    m_placeholder_parser_integration.init(m_writer);
    // Let the start-up script prime the 1st printing tool.
    this->placeholder_parser().set("initial_tool", initial_extruder_id);
    this->placeholder_parser().set("initial_extruder", initial_extruder_id);
    this->placeholder_parser().set("current_extruder", initial_extruder_id);
    //Set variable for total layer count so it can be used in custom gcode.
    this->placeholder_parser().set("total_layer_count", m_layer_count);
    // Useful for sequential prints.
    this->placeholder_parser().set("current_object_idx", 0);
    // For the start / end G-code to do the priming and final filament pull in case there is no wipe tower provided.
    this->placeholder_parser().set("has_wipe_tower", has_wipe_tower);
    this->placeholder_parser().set("has_single_extruder_multi_material_priming", has_wipe_tower && print.config().single_extruder_multi_material_priming);
    this->placeholder_parser().set("total_toolchanges", std::max(0, print.wipe_tower_data().number_of_toolchanges)); // Check for negative toolchanges (single extruder mode) and set to 0 (no tool change).
    {
        BoundingBoxf bbox(print.config().bed_shape.values);
        this->placeholder_parser().set("print_bed_min",  new ConfigOptionFloats({ bbox.min.x(), bbox.min.y() }));
        this->placeholder_parser().set("print_bed_max",  new ConfigOptionFloats({ bbox.max.x(), bbox.max.y() }));
        this->placeholder_parser().set("print_bed_size", new ConfigOptionFloats({ bbox.size().x(), bbox.size().y() }));
    }
    {
        // Convex hull of the 1st layer extrusions, for bed leveling and placing the initial purge line.
        // It encompasses the object extrusions, support extrusions, skirt, brim, wipe tower.
        // It does NOT encompass user extrusions generated by custom G-code,
        // therefore it does NOT encompass the initial purge line.
        // It does NOT encompass MMU/MMU2 starting (wipe) areas.
        auto pts = std::make_unique<ConfigOptionPoints>();
        pts->values.reserve(print.first_layer_convex_hull().size());
        for (const Point &pt : print.first_layer_convex_hull().points)
            pts->values.emplace_back(unscale(pt));
        BoundingBoxf bbox(pts->values);
        this->placeholder_parser().set("first_layer_print_convex_hull", pts.release());
        this->placeholder_parser().set("first_layer_print_min",  new ConfigOptionFloats({ bbox.min.x(), bbox.min.y() }));
        this->placeholder_parser().set("first_layer_print_max",  new ConfigOptionFloats({ bbox.max.x(), bbox.max.y() }));
        this->placeholder_parser().set("first_layer_print_size", new ConfigOptionFloats({ bbox.size().x(), bbox.size().y() }));
        this->placeholder_parser().set("num_extruders", int(print.config().nozzle_diameter.values.size()));
        // PlaceholderParser currently substitues non-existent vector values with the zero'th value, which is harmful in the case of "is_extruder_used[]"
        // as Slicer may lie about availability of such non-existent extruder.
        // We rather sacrifice 256B of memory before we change the behavior of the PlaceholderParser, which should really only fill in the non-existent
        // vector elements for filament parameters.
        std::vector<unsigned char> is_extruder_used(std::max(size_t(255), print.config().nozzle_diameter.size()), 0);
        for (unsigned int extruder_id : tool_ordering.all_extruders())
            is_extruder_used[extruder_id] = true;
        this->placeholder_parser().set("is_extruder_used", new ConfigOptionBools(is_extruder_used));
    }
 
    // Enable ooze prevention if configured so.
    DoExport::init_ooze_prevention(print, m_ooze_prevention);
 
    std::string start_gcode = this->placeholder_parser_process("start_gcode", print.config().start_gcode.value, initial_extruder_id);
    // Set bed temperature if the start G-code does not contain any bed temp control G-codes.
    this->_print_first_layer_bed_temperature(file, print, start_gcode, initial_extruder_id, true);
    // Set extruder(s) temperature before and after start G-code.
    this->_print_first_layer_extruder_temperatures(file, print, start_gcode, initial_extruder_id, false);
 
    // adds tag for processor
    file.write_format(";%s%s\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role).c_str(), gcode_extrusion_role_to_string(GCodeExtrusionRole::Custom).c_str());
 
    // Write the custom start G-code
    file.writeln(start_gcode);
 
    this->_print_first_layer_extruder_temperatures(file, print, start_gcode, initial_extruder_id, true);
    print.throw_if_canceled();
 
    // Set other general things.
    file.write(this->preamble());
 
    print.throw_if_canceled();
 
    // Collect custom seam data from all objects.
    std::function<void(void)> throw_if_canceled_func = [&print]() { print.throw_if_canceled();};
    m_seam_placer.init(print, throw_if_canceled_func);
 
    if (! (has_wipe_tower && print.config().single_extruder_multi_material_priming)) {
        // Set initial extruder only after custom start G-code.
        // Ugly hack: Do not set the initial extruder if the extruder is primed using the MMU priming towers at the edge of the print bed.
        file.write(this->set_extruder(initial_extruder_id, 0.));
    }
 
    // Do all objects for each layer.
    if (print.config().complete_objects.value) {
        size_t finished_objects = 0;
        const PrintObject *prev_object = (*print_object_instance_sequential_active)->print_object;
        for (; print_object_instance_sequential_active != print_object_instances_ordering.end(); ++ print_object_instance_sequential_active) {
            const PrintObject &object = *(*print_object_instance_sequential_active)->print_object;
            if (&object != prev_object || tool_ordering.first_extruder() != final_extruder_id) {
                tool_ordering = ToolOrdering(object, final_extruder_id);
                unsigned int new_extruder_id = tool_ordering.first_extruder();
                if (new_extruder_id == (unsigned int)-1)
                    // Skip this object.
                    continue;
                initial_extruder_id = new_extruder_id;
                final_extruder_id   = tool_ordering.last_extruder();
                assert(final_extruder_id != (unsigned int)-1);
            }
            print.throw_if_canceled();
            this->set_origin(unscale((*print_object_instance_sequential_active)->shift));
            if (finished_objects > 0) {
                // Move to the origin position for the copy we're going to print.
                // This happens before Z goes down to layer 0 again, so that no collision happens hopefully.
                m_enable_cooling_markers = false; // we're not filtering these moves through CoolingBuffer
                m_avoid_crossing_perimeters.use_external_mp_once();
                file.write(this->retract());
                file.write(this->travel_to(Point(0, 0), ExtrusionRole::None, "move to origin position for next object"));
                m_enable_cooling_markers = true;
                // Disable motion planner when traveling to first object point.
                m_avoid_crossing_perimeters.disable_once();
                // Ff we are printing the bottom layer of an object, and we have already finished
                // another one, set first layer temperatures. This happens before the Z move
                // is triggered, so machine has more time to reach such temperatures.
                this->placeholder_parser().set("current_object_idx", int(finished_objects));
                std::string between_objects_gcode = this->placeholder_parser_process("between_objects_gcode", print.config().between_objects_gcode.value, initial_extruder_id);
                // Set first layer bed and extruder temperatures, don't wait for it to reach the temperature.
                this->_print_first_layer_bed_temperature(file, print, between_objects_gcode, initial_extruder_id, false);
                this->_print_first_layer_extruder_temperatures(file, print, between_objects_gcode, initial_extruder_id, false);
                file.writeln(between_objects_gcode);
            }
            // Reset the cooling buffer internal state (the current position, feed rate, accelerations).
            m_cooling_buffer->reset(this->writer().get_position());
            m_cooling_buffer->set_current_extruder(initial_extruder_id);
            // Process all layers of a single object instance (sequential mode) with a parallel pipeline:
            // Generate G-code, run the filters (vase mode, cooling buffer), run the G-code analyser
            // and export G-code into file.
            this->process_layers(print, tool_ordering, collect_layers_to_print(object), *print_object_instance_sequential_active - object.instances().data(), file);
            ++ finished_objects;
            // Flag indicating whether the nozzle temperature changes from 1st to 2nd layer were performed.
            // Reset it when starting another object from 1st layer.
            m_second_layer_things_done = false;
            prev_object = &object;
        }
    } else {
        // Sort layers by Z.
        // All extrusion moves with the same top layer height are extruded uninterrupted.
        std::vector<std::pair<coordf_t, ObjectsLayerToPrint>> layers_to_print = collect_layers_to_print(print);
        // Prusa Multi-Material wipe tower.
        if (has_wipe_tower && ! layers_to_print.empty()) {
            m_wipe_tower.reset(new WipeTowerIntegration(print.config(), *print.wipe_tower_data().priming.get(), print.wipe_tower_data().tool_changes, *print.wipe_tower_data().final_purge.get()));
            file.write(m_writer.travel_to_z(first_layer_height + m_config.z_offset.value, "Move to the first layer height"));
            if (print.config().single_extruder_multi_material_priming) {
                file.write(m_wipe_tower->prime(*this));
                // Verify, whether the print overaps the priming extrusions.
                BoundingBoxf bbox_print(get_print_extrusions_extents(print));
                coordf_t twolayers_printz = ((layers_to_print.size() == 1) ? layers_to_print.front() : layers_to_print[1]).first + EPSILON;
                for (const PrintObject *print_object : print.objects())
                    bbox_print.merge(get_print_object_extrusions_extents(*print_object, twolayers_printz));
                bbox_print.merge(get_wipe_tower_extrusions_extents(print, twolayers_printz));
                BoundingBoxf bbox_prime(get_wipe_tower_priming_extrusions_extents(print));
                bbox_prime.offset(0.5f);
                bool overlap = bbox_prime.overlap(bbox_print);
 
                if (print.config().gcode_flavor == gcfMarlinLegacy || print.config().gcode_flavor == gcfMarlinFirmware) {
                    file.write(this->retract());
                    file.write("M300 S800 P500\n"); // Beep for 500ms, tone 800Hz.
                    if (overlap) {
                        // Wait for the user to remove the priming extrusions.
                        file.write("M1 Remove priming towers and click button.\n");
                    } else {
                        // Just wait for a bit to let the user check, that the priming succeeded.
                        //TODO Add a message explaining what the printer is waiting for. This needs a firmware fix.
                        file.write("M1 S10\n");
                    }
                } else {
                    // This is not Marlin, M1 command is probably not supported.
                    // (See https://github.com/prusa3d/PrusaSlicer/issues/5441.)
                    if (overlap) {
                        print.active_step_add_warning(PrintStateBase::WarningLevel::CRITICAL,
                            _u8L("Your print is very close to the priming regions. "
                              "Make sure there is no collision."));
                    } else {
                        // Just continue printing, no action necessary.
                    }
 
                }
            }
            print.throw_if_canceled();
        }
        // Process all layers of all objects (non-sequential mode) with a parallel pipeline:
        // Generate G-code, run the filters (vase mode, cooling buffer), run the G-code analyser
        // and export G-code into file.
        this->process_layers(print, tool_ordering, print_object_instances_ordering, layers_to_print, file);
        if (m_wipe_tower)
            // Purge the extruder, pull out the active filament.
            file.write(m_wipe_tower->finalize(*this));
    }
 
    // Write end commands to file.
    file.write(this->retract());
    file.write(m_writer.set_fan(0));
 
    // adds tag for processor
    file.write_format(";%s%s\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role).c_str(), gcode_extrusion_role_to_string(GCodeExtrusionRole::Custom).c_str());
 
    // Process filament-specific gcode in extruder order.
    {
        DynamicConfig config;
        config.set_key_value("layer_num", new ConfigOptionInt(m_layer_index));
        config.set_key_value("layer_z",   new ConfigOptionFloat(m_writer.get_position().z() - m_config.z_offset.value));
        config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
        if (print.config().single_extruder_multi_material) {
            // Process the end_filament_gcode for the active filament only.
            int extruder_id = m_writer.extruder()->id();
            config.set_key_value("filament_extruder_id", new ConfigOptionInt(extruder_id));
            file.writeln(this->placeholder_parser_process("end_filament_gcode", print.config().end_filament_gcode.get_at(extruder_id), extruder_id, &config));
        } else {
            for (const std::string &end_gcode : print.config().end_filament_gcode.values) {
                int extruder_id = (unsigned int)(&end_gcode - &print.config().end_filament_gcode.values.front());
                config.set_key_value("filament_extruder_id", new ConfigOptionInt(extruder_id));
                file.writeln(this->placeholder_parser_process("end_filament_gcode", end_gcode, extruder_id, &config));
            }
        }
        file.writeln(this->placeholder_parser_process("end_gcode", print.config().end_gcode, m_writer.extruder()->id(), &config));
    }
    file.write(m_writer.update_progress(m_layer_count, m_layer_count, true)); // 100%
    file.write(m_writer.postamble());
 
    // From now to the end of G-code, the G-code find / replace post-processor will be disabled.
    // Thus the PrusaSlicer generated config will NOT be processed by the G-code post-processor, see GH issue #7952.
    file.find_replace_supress();
 
    // adds tags for time estimators
    if (print.config().remaining_times.value)
        file.write_format(";%s\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Last_Line_M73_Placeholder).c_str());
 
    print.throw_if_canceled();
 
    // Get filament stats.
    file.write(DoExport::update_print_stats_and_format_filament_stats(
      // Const inputs
        has_wipe_tower, print.wipe_tower_data(),
        this->config(),
        m_writer.extruders(),
        initial_extruder_id,
        // Modifies
        print.m_print_statistics));
    file.write("\n");
    file.write_format("; total filament used [g] = %.2lf\n", print.m_print_statistics.total_weight);
    file.write_format("; total filament cost = %.2lf\n", print.m_print_statistics.total_cost);
    if (print.m_print_statistics.total_toolchanges > 0)
      file.write_format("; total toolchanges = %i\n", print.m_print_statistics.total_toolchanges);
    file.write_format(";%s\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Estimated_Printing_Time_Placeholder).c_str());
 
    // Append full config, delimited by two 'phony' configuration keys prusaslicer_config = begin and prusaslicer_config = end.
    // The delimiters are structured as configuration key / value pairs to be parsable by older versions of PrusaSlicer G-code viewer.
    {
        file.write("\n; prusaslicer_config = begin\n");
        std::string full_config;
        append_full_config(print, full_config);
        if (!full_config.empty())
            file.write(full_config);
        file.write("; prusaslicer_config = end\n");
    }
    print.throw_if_canceled();
}

References _print_first_layer_bed_temperature(), _print_first_layer_extruder_temperatures(), _u8L, Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::active_step_add_warning(), Slic3r::ToolOrdering::all_extruders(), append_full_config(), apply_print_config(), Slic3r::ToolOrdering::assign_custom_gcodes(), Slic3r::DoExport::autospeed_volumetric_limit(), Slic3r::between_objects_gcode(), Slic3r::chain_print_object_instances(), collect_layers_to_print(), config(), Slic3r::PrintObject::config(), Slic3r::Print::config(), Slic3r::PlaceholderParser::config_writable(), Slic3r::GCode::PlaceholderParserIntegration::context, Slic3r::PrintStateBase::CRITICAL, Slic3r::Custom, Slic3r::AvoidCrossingPerimeters::disable_once(), Slic3r::end_gcode(), EPSILON, Slic3r::GCodeProcessor::Estimated_Printing_Time_Placeholder, Slic3r::GCodeThumbnails::export_thumbnails_to_file(), Slic3r::GCodeWriter::extruder(), Slic3r::GCodeWriter::extruders(), Slic3r::Print::extruders(), Slic3r::WipeTowerData::final_purge, Slic3r::GCode::GCodeOutputStream::find_replace_enable(), Slic3r::GCode::GCodeOutputStream::find_replace_supress(), Slic3r::ToolOrdering::first_extruder(), Slic3r::Print::first_layer_convex_hull(), Slic3r::GCodeProcessor::First_Line_M73_Placeholder, Slic3r::PrintRegion::flow(), Slic3r::frExternalPerimeter, Slic3r::frInfill, Slic3r::frPerimeter, Slic3r::frSolidInfill, Slic3r::frTopSolidInfill, Slic3r::PrintBase::full_print_config(), Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcode_extrusion_role_to_string(), Slic3r::get_bed_shape(), Slic3r::GCodeWriter::get_position(), Slic3r::get_print_extrusions_extents(), Slic3r::get_print_object_extrusions_extents(), Slic3r::Print::get_print_region(), Slic3r::get_wipe_tower_extrusions_extents(), Slic3r::get_wipe_tower_priming_extrusions_extents(), Slic3r::PlaceholderParser::ContextData::global_config, Slic3r::Print::has_support_material(), Slic3r::ToolOrdering::has_wipe_tower(), Slic3r::Print::has_wipe_tower(), Slic3r::header_slic3r_generated(), Slic3r::Extruder::id(), Slic3r::GCode::PlaceholderParserIntegration::init(), Slic3r::SeamPlacer::init(), Slic3r::JPSPathFinder::init_bed_shape(), Slic3r::DoExport::init_gcode_processor(), Slic3r::DoExport::init_ooze_prevention(), Slic3r::ToolOrdering::last_extruder(), Slic3r::GCodeProcessor::Last_Line_M73_Placeholder, layer(), Slic3r::layer_height(), Slic3r::ToolOrdering::layer_tools(), m_avoid_crossing_curled_overhangs, m_avoid_crossing_perimeters, m_config, m_cooling_buffer, m_enable_cooling_markers, m_enable_extrusion_role_markers, m_find_replace, m_last_height, m_last_layer_z, m_last_width, m_layer_count, m_layer_index, m_max_layer_z, m_ooze_prevention, m_placeholder_parser_integration, m_pressure_equalizer, Slic3r::Print::m_print_statistics, m_processor, m_seam_placer, m_second_layer_things_done, m_silent_time_estimator_enabled, m_spiral_vase, m_volumetric_speed, m_wipe_tower, m_writer, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::ExtrusionRole::None, Slic3r::Print::num_print_regions(), Slic3r::WipeTowerData::number_of_toolchanges, Slic3r::Print::objects(), Slic3r::BoundingBoxBase< PointType, APointsType >::offset(), Slic3r::ConfigBase::option(), Slic3r::BoundingBoxBase< PointType, APointsType >::overlap(), Slic3r::GCode::PlaceholderParserIntegration::parser, placeholder_parser(), Slic3r::PrintBase::placeholder_parser(), placeholder_parser_process(), Slic3r::PNG, Slic3r::MultiPoint::points, Slic3r::GCodeWriter::postamble(), preamble(), Slic3r::WipeTowerData::priming, print_machine_envelope(), Slic3r::Layer::print_z, process_layers(), Slic3r::GCodeProcessor::reserved_tag(), retract(), Slic3r::PlaceholderParser::ContextData::rng, Slic3r::GCodeProcessor::Role, Slic3r::PlaceholderParser::set(), set_extruder(), set_extruders(), Slic3r::GCodeWriter::set_fan(), Slic3r::GCode::GCodeOutputStream::set_find_replace(), set_origin(), Slic3r::BoundingBoxBase< PointType, APointsType >::size(), Slic3r::MultiPoint::size(), Slic3r::sort_object_instances_by_model_order(), Slic3r::support_material_flow(), Slic3r::PrintBase::throw_if_canceled(), Slic3r::WipeTowerData::tool_changes, Slic3r::Print::tool_ordering(), Slic3r::PrintStatistics::total_cost, Slic3r::PrintStatistics::total_toolchanges, Slic3r::PrintStatistics::total_weight, travel_to(), Slic3r::GCodeWriter::travel_to_z(), Slic3r::unscale(), Slic3r::PrintBase::update_object_placeholders(), Slic3r::DoExport::update_print_stats_and_format_filament_stats(), Slic3r::GCodeWriter::update_progress(), Slic3r::PlaceholderParser::update_timestamp(), Slic3r::AvoidCrossingPerimeters::use_external_mp_once(), void(), Slic3r::Flow::width(), Slic3r::Print::wipe_tower_data(), WipeTowerIntegration, Slic3r::GCode::GCodeOutputStream::write(), Slic3r::GCode::GCodeOutputStream::write_format(), Slic3r::GCode::GCodeOutputStream::writeln(), and writer().

Referenced by do_export().

Here is the caller graph for this function:

◆ _extrude()

std::string Slic3r::GCode::_extrude	(	const ExtrusionPath &	path,
		const std::string_view	description,
		double	speed = `-1`
	)

private

{
    std::string gcode;
    const std::string_view description_bridge = path.role().is_bridge() ? " (bridge)"sv : ""sv;
 
    // go to first point of extrusion path
    if (!m_last_pos_defined || m_last_pos != path.first_point()) {
        std::string comment = "move to first ";
        comment += description;
        comment += description_bridge;
        comment += " point";
        gcode += this->travel_to(path.first_point(), path.role(), comment);
    }
 
    // compensate retraction
    gcode += this->unretract();
 
    // adjust acceleration
    if (m_config.default_acceleration.value > 0) {
        double acceleration;
        if (this->on_first_layer() && m_config.first_layer_acceleration.value > 0) {
            acceleration = m_config.first_layer_acceleration.value;
        } else if (this->object_layer_over_raft() && m_config.first_layer_acceleration_over_raft.value > 0) {
            acceleration = m_config.first_layer_acceleration_over_raft.value;
        } else if (m_config.bridge_acceleration.value > 0 && path.role().is_bridge()) {
            acceleration = m_config.bridge_acceleration.value;
        } else if (m_config.top_solid_infill_acceleration > 0 && path.role() == ExtrusionRole::TopSolidInfill) {
            acceleration = m_config.top_solid_infill_acceleration.value;
        } else if (m_config.solid_infill_acceleration > 0 && path.role().is_solid_infill()) {
            acceleration = m_config.solid_infill_acceleration.value;
        } else if (m_config.infill_acceleration.value > 0 && path.role().is_infill()) {
            acceleration = m_config.infill_acceleration.value;
        } else if (m_config.external_perimeter_acceleration > 0 && path.role().is_external_perimeter()) {
            acceleration = m_config.external_perimeter_acceleration.value;
        } else if (m_config.perimeter_acceleration.value > 0 && path.role().is_perimeter()) {
            acceleration = m_config.perimeter_acceleration.value;
        } else {
            acceleration = m_config.default_acceleration.value;
        }
        gcode += m_writer.set_print_acceleration((unsigned int)floor(acceleration + 0.5));
    }
 
    // calculate extrusion length per distance unit
    double e_per_mm = m_writer.extruder()->e_per_mm3() * path.mm3_per_mm;
    if (m_writer.extrusion_axis().empty())
        // gcfNoExtrusion
        e_per_mm = 0;
 
    // set speed
    if (speed == -1) {
        if (path.role() == ExtrusionRole::Perimeter) {
            speed = m_config.get_abs_value("perimeter_speed");
        } else if (path.role() == ExtrusionRole::ExternalPerimeter) {
            speed = m_config.get_abs_value("external_perimeter_speed");
        } else if (path.role().is_bridge()) {
            assert(path.role().is_perimeter() || path.role() == ExtrusionRole::BridgeInfill);
            speed = m_config.get_abs_value("bridge_speed");
        } else if (path.role() == ExtrusionRole::InternalInfill) {
            speed = m_config.get_abs_value("infill_speed");
        } else if (path.role() == ExtrusionRole::SolidInfill) {
            speed = m_config.get_abs_value("solid_infill_speed");
        } else if (path.role() == ExtrusionRole::TopSolidInfill) {
            speed = m_config.get_abs_value("top_solid_infill_speed");
        } else if (path.role() == ExtrusionRole::Ironing) {
            speed = m_config.get_abs_value("ironing_speed");
        } else if (path.role() == ExtrusionRole::GapFill) {
            speed = m_config.get_abs_value("gap_fill_speed");
        } else {
            throw Slic3r::InvalidArgument("Invalid speed");
        }
    }
    if (m_volumetric_speed != 0. && speed == 0)
        speed = m_volumetric_speed / path.mm3_per_mm;
    if (this->on_first_layer())
        speed = m_config.get_abs_value("first_layer_speed", speed);
    else if (this->object_layer_over_raft())
        speed = m_config.get_abs_value("first_layer_speed_over_raft", speed);
    if (m_config.max_volumetric_speed.value > 0) {
        // cap speed with max_volumetric_speed anyway (even if user is not using autospeed)
        speed = std::min(
            speed,
            m_config.max_volumetric_speed.value / path.mm3_per_mm
        );
    }
    if (EXTRUDER_CONFIG(filament_max_volumetric_speed) > 0) {
        // cap speed with max_volumetric_speed anyway (even if user is not using autospeed)
        speed = std::min(
            speed,
            EXTRUDER_CONFIG(filament_max_volumetric_speed) / path.mm3_per_mm
        );
    }
 
    bool                        variable_speed_or_fan_speed = false;
    std::vector<ProcessedPoint> new_points{};
    if ((this->m_config.enable_dynamic_overhang_speeds || this->config().enable_dynamic_fan_speeds.get_at(m_writer.extruder()->id())) &&
        !this->on_first_layer() && path.role().is_perimeter()) {
        std::vector<std::pair<int, ConfigOptionFloatOrPercent>> overhangs_with_speeds = {{100, ConfigOptionFloatOrPercent{speed, false}}};
        if (this->m_config.enable_dynamic_overhang_speeds) {
            overhangs_with_speeds = {{0, m_config.overhang_speed_0},
                                     {25, m_config.overhang_speed_1},
                                     {50, m_config.overhang_speed_2},
                                     {75, m_config.overhang_speed_3},
                                     {100, ConfigOptionFloatOrPercent{speed, false}}};
        }
 
        std::vector<std::pair<int, ConfigOptionInts>> overhang_w_fan_speeds = {{100, ConfigOptionInts{0}}};
        if (this->m_config.enable_dynamic_fan_speeds.get_at(m_writer.extruder()->id())) {
            overhang_w_fan_speeds = {{0, m_config.overhang_fan_speed_0},
                                     {25, m_config.overhang_fan_speed_1},
                                     {50, m_config.overhang_fan_speed_2},
                                     {75, m_config.overhang_fan_speed_3},
                                     {100, ConfigOptionInts{0}}};
        }
 
        double external_perim_reference_speed = m_config.get_abs_value("external_perimeter_speed");
        if (external_perim_reference_speed == 0)
            external_perim_reference_speed = m_volumetric_speed / path.mm3_per_mm;
        if (m_config.max_volumetric_speed.value > 0)
            external_perim_reference_speed = std::min(external_perim_reference_speed, m_config.max_volumetric_speed.value / path.mm3_per_mm);
        if (EXTRUDER_CONFIG(filament_max_volumetric_speed) > 0) {
            external_perim_reference_speed = std::min(external_perim_reference_speed,
                                                      EXTRUDER_CONFIG(filament_max_volumetric_speed) / path.mm3_per_mm);
        }
 
        new_points = m_extrusion_quality_estimator.estimate_speed_from_extrusion_quality(path, overhangs_with_speeds, overhang_w_fan_speeds,
                                                                              m_writer.extruder()->id(), external_perim_reference_speed,
                                                                              speed);
        variable_speed_or_fan_speed = std::any_of(new_points.begin(), new_points.end(),
                                                  [speed](const ProcessedPoint &p) { return p.speed != speed || p.fan_speed != 0; });
    }
 
    double F = speed * 60;  // convert mm/sec to mm/min
 
    // extrude arc or line
    if (m_enable_extrusion_role_markers)
    {
        if (GCodeExtrusionRole role = extrusion_role_to_gcode_extrusion_role(path.role()); role != m_last_extrusion_role)
        {
            m_last_extrusion_role = role;
            if (m_enable_extrusion_role_markers)
            {
                char buf[32];
                sprintf(buf, ";_EXTRUSION_ROLE:%d\n", int(m_last_extrusion_role));
                gcode += buf;
            }
        }
    }
 
    // adds processor tags and updates processor tracking data
    // PrusaMultiMaterial::Writer may generate GCodeProcessor::Height_Tag lines without updating m_last_height
    // so, if the last role was GCodeExtrusionRole::WipeTower we force export of GCodeProcessor::Height_Tag lines
    bool last_was_wipe_tower = (m_last_processor_extrusion_role == GCodeExtrusionRole::WipeTower);
    assert(is_decimal_separator_point());
 
    if (GCodeExtrusionRole role = extrusion_role_to_gcode_extrusion_role(path.role()); role != m_last_processor_extrusion_role) {
        m_last_processor_extrusion_role = role;
        char buf[64];
        sprintf(buf, ";%s%s\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role).c_str(), gcode_extrusion_role_to_string(m_last_processor_extrusion_role).c_str());
        gcode += buf;
    }
 
    if (last_was_wipe_tower || m_last_width != path.width) {
        m_last_width = path.width;
        gcode += std::string(";") + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Width)
               + float_to_string_decimal_point(m_last_width) + "\n";
    }
 
#if ENABLE_GCODE_VIEWER_DATA_CHECKING
    if (last_was_wipe_tower || (m_last_mm3_per_mm != path.mm3_per_mm)) {
        m_last_mm3_per_mm = path.mm3_per_mm;
        gcode += std::string(";") + GCodeProcessor::Mm3_Per_Mm_Tag
            + float_to_string_decimal_point(m_last_mm3_per_mm) + "\n";
    }
#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
 
    if (last_was_wipe_tower || std::abs(m_last_height - path.height) > EPSILON) {
        m_last_height = path.height;
 
        gcode += std::string(";") + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height)
            + float_to_string_decimal_point(m_last_height) + "\n";
    }
 
    std::string cooling_marker_setspeed_comments;
    if (m_enable_cooling_markers) {
        if (path.role().is_bridge())
            gcode += ";_BRIDGE_FAN_START\n";
        else
            cooling_marker_setspeed_comments = ";_EXTRUDE_SET_SPEED";
        if (path.role() == ExtrusionRole::ExternalPerimeter)
            cooling_marker_setspeed_comments += ";_EXTERNAL_PERIMETER";
    }
 
    if (!variable_speed_or_fan_speed) {
        // F is mm per minute.
        gcode += m_writer.set_speed(F, "", cooling_marker_setspeed_comments);
        double path_length = 0.;
        std::string comment;
        if (m_config.gcode_comments) {
            comment = description;
            comment += description_bridge;
        }
        Vec2d prev = this->point_to_gcode_quantized(path.polyline.points.front());
        auto  it   = path.polyline.points.begin();
        auto  end  = path.polyline.points.end();
        for (++ it; it != end; ++ it) {
            Vec2d p = this->point_to_gcode_quantized(*it);
            const double line_length = (p - prev).norm();
            path_length += line_length;
            gcode += m_writer.extrude_to_xy(p, e_per_mm * line_length, comment);
            prev = p;
        }
    } else {
        std::string marked_comment;
        if (m_config.gcode_comments) {
            marked_comment = description;
            marked_comment += description_bridge;
        }
        double last_set_speed     = new_points[0].speed * 60.0;
        double last_set_fan_speed = new_points[0].fan_speed;
        gcode += m_writer.set_speed(last_set_speed, "", cooling_marker_setspeed_comments);
        gcode += "\n;_SET_FAN_SPEED" + std::to_string(int(last_set_fan_speed)) + "\n";
        Vec2d prev = this->point_to_gcode_quantized(new_points[0].p);
        for (size_t i = 1; i < new_points.size(); i++) {
            const ProcessedPoint &processed_point = new_points[i];
            Vec2d                 p               = this->point_to_gcode_quantized(processed_point.p);
            const double          line_length     = (p - prev).norm();
            gcode += m_writer.extrude_to_xy(p, e_per_mm * line_length, marked_comment);
            prev             = p;
            double new_speed = processed_point.speed * 60.0;
            if (last_set_speed != new_speed) {
                gcode += m_writer.set_speed(new_speed, "", cooling_marker_setspeed_comments);
                last_set_speed = new_speed;
            }
            if (last_set_fan_speed != processed_point.fan_speed) {
                last_set_fan_speed = processed_point.fan_speed;
                gcode += "\n;_SET_FAN_SPEED" + std::to_string(int(last_set_fan_speed)) + "\n";
            }
        }
        gcode += "\n;_RESET_FAN_SPEED\n";
    }
 
    if (m_enable_cooling_markers)
        gcode += path.role().is_bridge() ? ";_BRIDGE_FAN_END\n" : ";_EXTRUDE_END\n";
 
    this->set_last_pos(path.last_point());
    return gcode;
}

Referenced by extrude_loop(), extrude_multi_path(), and extrude_path().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _print_first_layer_bed_temperature()

void Slic3r::GCode::_print_first_layer_bed_temperature	(	GCodeOutputStream &	file,
		Print &	print,
		const std::string &	gcode,
		unsigned int	first_printing_extruder_id,
		bool	wait
	)

private

{
    bool autoemit = print.config().autoemit_temperature_commands;
    // Initial bed temperature based on the first extruder.
    int  temp = print.config().first_layer_bed_temperature.get_at(first_printing_extruder_id);
    // Is the bed temperature set by the provided custom G-code?
    int  temp_by_gcode     = -1;
    bool temp_set_by_gcode = custom_gcode_sets_temperature(gcode, 140, 190, false, temp_by_gcode);
    if (autoemit && temp_set_by_gcode && temp_by_gcode >= 0 && temp_by_gcode < 1000)
        temp = temp_by_gcode;
    // Always call m_writer.set_bed_temperature() so it will set the internal "current" state of the bed temp as if
    // the custom start G-code emited these.
    std::string set_temp_gcode = m_writer.set_bed_temperature(temp, wait);
    if (autoemit && ! temp_set_by_gcode)
        file.write(set_temp_gcode);
}

References Slic3r::Print::config(), Slic3r::custom_gcode_sets_temperature(), m_writer, Slic3r::GCodeWriter::set_bed_temperature(), and Slic3r::GCode::GCodeOutputStream::write().

Referenced by _do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _print_first_layer_extruder_temperatures()

void Slic3r::GCode::_print_first_layer_extruder_temperatures	(	GCodeOutputStream &	file,
		Print &	print,
		const std::string &	gcode,
		unsigned int	first_printing_extruder_id,
		bool	wait
	)

private

{
    bool autoemit = print.config().autoemit_temperature_commands;
    // Is the bed temperature set by the provided custom G-code?
    int  temp_by_gcode = -1;
    bool include_g10   = print.config().gcode_flavor == gcfRepRapFirmware;
    if (! autoemit  || custom_gcode_sets_temperature(gcode, 104, 109, include_g10, temp_by_gcode)) {
        // Set the extruder temperature at m_writer, but throw away the generated G-code as it will be written with the custom G-code.
        int temp = print.config().first_layer_temperature.get_at(first_printing_extruder_id);
        if (autoemit && temp_by_gcode >= 0 && temp_by_gcode < 1000)
            temp = temp_by_gcode;
        m_writer.set_temperature(temp, wait, first_printing_extruder_id);
    } else {
        // Custom G-code does not set the extruder temperature. Do it now.
        if (print.config().single_extruder_multi_material.value) {
            // Set temperature of the first printing extruder only.
            int temp = print.config().first_layer_temperature.get_at(first_printing_extruder_id);
            if (temp > 0)
                file.write(m_writer.set_temperature(temp, wait, first_printing_extruder_id));
        } else {
            // Set temperatures of all the printing extruders.
            for (unsigned int tool_id : print.extruders()) {
                int temp = print.config().first_layer_temperature.get_at(tool_id);
 
                if (print.config().ooze_prevention.value && tool_id != first_printing_extruder_id) {
                    if (print.config().idle_temperature.is_nil(tool_id))
                        temp += print.config().standby_temperature_delta.value;
                    else
                        temp = print.config().idle_temperature.get_at(tool_id);
                }
 
                if (temp > 0)
                    file.write(m_writer.set_temperature(temp, wait, tool_id));
            }
        }
    }
}

References Slic3r::Print::config(), Slic3r::custom_gcode_sets_temperature(), Slic3r::Print::extruders(), Slic3r::gcfRepRapFirmware, m_writer, Slic3r::GCodeWriter::set_temperature(), and Slic3r::GCode::GCodeOutputStream::write().

Referenced by _do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ append_full_config()

void Slic3r::GCode::append_full_config	(	const Print &	print,
		std::string &	str
	)

static

{
    const DynamicPrintConfig &cfg = print.full_print_config();
    // Sorted list of config keys, which shall not be stored into the G-code. Initializer list.
    static constexpr auto banned_keys = {
        "compatible_printers"sv,
        "compatible_prints"sv,
        //FIXME The print host keys should not be exported to full_print_config anymore. The following keys may likely be removed.
        "print_host"sv,
        "printhost_apikey"sv,
        "printhost_cafile"sv
    };
    assert(std::is_sorted(banned_keys.begin(), banned_keys.end()));
    auto is_banned = [](const std::string &key) {
        return std::binary_search(banned_keys.begin(), banned_keys.end(), key);
    };
    for (const std::string &key : cfg.keys())
        if (! is_banned(key) && ! cfg.option(key)->is_nil())
            str += "; " + key + " = " + cfg.opt_serialize(key) + "\n";
}

References Slic3r::PrintBase::full_print_config(), Slic3r::ConfigOption::is_nil(), Slic3r::DynamicConfig::keys(), Slic3r::ConfigBase::opt_serialize(), and Slic3r::ConfigBase::option().

Referenced by _do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_print_config()

void Slic3r::GCode::apply_print_config ( const PrintConfig & print_config )

{
    m_writer.apply_print_config(print_config);
    m_config.apply(print_config);
    m_scaled_resolution = scaled<double>(print_config.gcode_resolution.value);
}

References Slic3r::GCodeWriter::apply_print_config(), m_config, m_scaled_resolution, and m_writer.

Referenced by _do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ change_layer()

std::string Slic3r::GCode::change_layer ( coordf_t print_z )

private

{
    std::string gcode;
    if (m_layer_count > 0)
        // Increment a progress bar indicator.
        gcode += m_writer.update_progress(++ m_layer_index, m_layer_count);
    coordf_t z = print_z + m_config.z_offset.value;  // in unscaled coordinates
    if (EXTRUDER_CONFIG(retract_layer_change) && m_writer.will_move_z(z))
        gcode += this->retract();
 
    {
        std::ostringstream comment;
        comment << "move to next layer (" << m_layer_index << ")";
        gcode += m_writer.travel_to_z(z, comment.str());
    }
 
    // forget last wiping path as wiping after raising Z is pointless
    m_wipe.reset_path();
 
    return gcode;
}

References comment, EXTRUDER_CONFIG, m_config, m_layer_count, m_layer_index, m_wipe, m_writer, Slic3r::Wipe::reset_path(), retract(), Slic3r::GCodeWriter::travel_to_z(), Slic3r::GCodeWriter::update_progress(), and Slic3r::GCodeWriter::will_move_z().

Referenced by Slic3r::WipeTowerIntegration::finalize(), and process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collect_layers_to_print() [1/2]

std::vector< std::pair< coordf_t, GCode::ObjectsLayerToPrint > > Slic3r::GCode::collect_layers_to_print ( const Print & print )

staticprivate

{
    struct OrderingItem {
        coordf_t    print_z;
        size_t      object_idx;
        size_t      layer_idx;
    };
 
    std::vector<ObjectsLayerToPrint>  per_object(print.objects().size(), ObjectsLayerToPrint());
    std::vector<OrderingItem>         ordering;
    for (size_t i = 0; i < print.objects().size(); ++i) {
        per_object[i] = collect_layers_to_print(*print.objects()[i]);
        OrderingItem ordering_item;
        ordering_item.object_idx = i;
        ordering.reserve(ordering.size() + per_object[i].size());
        const ObjectLayerToPrint &front = per_object[i].front();
        for (const ObjectLayerToPrint &ltp : per_object[i]) {
            ordering_item.print_z = ltp.print_z();
            ordering_item.layer_idx = &ltp - &front;
            ordering.emplace_back(ordering_item);
        }
    }
 
    std::sort(ordering.begin(), ordering.end(), [](const OrderingItem& oi1, const OrderingItem& oi2) { return oi1.print_z < oi2.print_z; });
 
    std::vector<std::pair<coordf_t, ObjectsLayerToPrint>> layers_to_print;
 
    // Merge numerically very close Z values.
    for (size_t i = 0; i < ordering.size();) {
        // Find the last layer with roughly the same print_z.
        size_t j = i + 1;
        coordf_t zmax = ordering[i].print_z + EPSILON;
        for (; j < ordering.size() && ordering[j].print_z <= zmax; ++j);
        // Merge into layers_to_print.
        std::pair<coordf_t, ObjectsLayerToPrint> merged;
        // Assign an average print_z to the set of layers with nearly equal print_z.
        merged.first = 0.5 * (ordering[i].print_z + ordering[j - 1].print_z);
        merged.second.assign(print.objects().size(), ObjectLayerToPrint());
        for (; i < j; ++i) {
            const OrderingItem& oi = ordering[i];
            assert(merged.second[oi.object_idx].layer() == nullptr);
            merged.second[oi.object_idx] = std::move(per_object[oi.object_idx][oi.layer_idx]);
        }
        layers_to_print.emplace_back(std::move(merged));
    }
 
    return layers_to_print;
}

References collect_layers_to_print(), EPSILON, Slic3r::Print::objects(), and ordering.

Here is the call graph for this function:

◆ collect_layers_to_print() [2/2]

GCode::ObjectsLayerToPrint Slic3r::GCode::collect_layers_to_print ( const PrintObject & object )

staticprivate

{
    GCode::ObjectsLayerToPrint layers_to_print;
    layers_to_print.reserve(object.layers().size() + object.support_layers().size());
 
    /*
    // Calculate a minimum support layer height as a minimum over all extruders, but not smaller than 10um.
    // This is the same logic as in support generator.
    //FIXME should we use the printing extruders instead?
    double gap_over_supports = object.config().support_material_contact_distance;
    // FIXME should we test object.config().support_material_synchronize_layers ? Currently the support layers are synchronized with object layers iff soluble supports.
    assert(!object.has_support() || gap_over_supports != 0. || object.config().support_material_synchronize_layers);
    if (gap_over_supports != 0.) {
        gap_over_supports = std::max(0., gap_over_supports);
        // Not a soluble support,
        double support_layer_height_min = 1000000.;
        for (auto lh : object.print()->config().min_layer_height.values)
            support_layer_height_min = std::min(support_layer_height_min, std::max(0.01, lh));
        gap_over_supports += support_layer_height_min;
    }*/
 
    std::vector<std::pair<double, double>> warning_ranges;
 
    // Pair the object layers with the support layers by z.
    size_t idx_object_layer = 0;
    size_t idx_support_layer = 0;
    const ObjectLayerToPrint* last_extrusion_layer = nullptr;
    while (idx_object_layer < object.layers().size() || idx_support_layer < object.support_layers().size()) {
        ObjectLayerToPrint layer_to_print;
        layer_to_print.object_layer = (idx_object_layer < object.layers().size()) ? object.layers()[idx_object_layer++] : nullptr;
        layer_to_print.support_layer = (idx_support_layer < object.support_layers().size()) ? object.support_layers()[idx_support_layer++] : nullptr;
        if (layer_to_print.object_layer && layer_to_print.support_layer) {
            if (layer_to_print.object_layer->print_z < layer_to_print.support_layer->print_z - EPSILON) {
                layer_to_print.support_layer = nullptr;
                --idx_support_layer;
            }
            else if (layer_to_print.support_layer->print_z < layer_to_print.object_layer->print_z - EPSILON) {
                layer_to_print.object_layer = nullptr;
                --idx_object_layer;
            }
        }
 
        layers_to_print.emplace_back(layer_to_print);
 
        bool has_extrusions = (layer_to_print.object_layer && layer_to_print.object_layer->has_extrusions())
            || (layer_to_print.support_layer && layer_to_print.support_layer->has_extrusions());
 
        // Check that there are extrusions on the very first layer. The case with empty
        // first layer may result in skirt/brim in the air and maybe other issues.
        if (layers_to_print.size() == 1u) {
            if (!has_extrusions)
                throw Slic3r::SlicingError(_u8L("There is an object with no extrusions in the first layer.") + "\n" +
                                           _u8L("Object name") + ": " + object.model_object()->name);
        }
 
        // In case there are extrusions on this layer, check there is a layer to lay it on.
        if ((layer_to_print.object_layer && layer_to_print.object_layer->has_extrusions())
            // Allow empty support layers, as the support generator may produce no extrusions for non-empty support regions.
            || (layer_to_print.support_layer /* && layer_to_print.support_layer->has_extrusions() */)) {
            double top_cd = object.config().support_material_contact_distance;
            double bottom_cd = object.config().support_material_bottom_contact_distance == 0. ? top_cd : object.config().support_material_bottom_contact_distance;
 
            double extra_gap = (layer_to_print.support_layer ? bottom_cd : top_cd);
 
            double maximal_print_z = (last_extrusion_layer ? last_extrusion_layer->print_z() : 0.)
                + layer_to_print.layer()->height
                + std::max(0., extra_gap);
            // Negative support_contact_z is not taken into account, it can result in false positives in cases
            // where previous layer has object extrusions too (https://github.com/prusa3d/PrusaSlicer/issues/2752)
 
            if (has_extrusions && layer_to_print.print_z() > maximal_print_z + 2. * EPSILON)
                warning_ranges.emplace_back(std::make_pair((last_extrusion_layer ? last_extrusion_layer->print_z() : 0.), layers_to_print.back().print_z()));
        }
        // Remember last layer with extrusions.
        if (has_extrusions)
            last_extrusion_layer = &layers_to_print.back();
    }
 
    if (! warning_ranges.empty()) {
        std::string warning;
        size_t i = 0;
        for (i = 0; i < std::min(warning_ranges.size(), size_t(3)); ++i)
            warning += Slic3r::format(_u8L("Empty layer between %1% and %2%."),
                                      warning_ranges[i].first, warning_ranges[i].second) + "\n";
        if (i < warning_ranges.size())
            warning += _u8L("(Some lines not shown)") + "\n";
        warning += "\n";
        warning += Slic3r::format(_u8L("Object name: %1%"), object.model_object()->name) + "\n\n"
            + _u8L("Make sure the object is printable. This is usually caused by negligibly small extrusions or by a faulty model. "
                "Try to repair the model or change its orientation on the bed.");
 
        const_cast<Print*>(object.print())->active_step_add_warning(
            PrintStateBase::WarningLevel::CRITICAL, warning);
    }
 
    return layers_to_print;
}

References _u8L, Slic3r::PrintStateBase::CRITICAL, EPSILON, Slic3r::format(), Slic3r::Layer::has_extrusions(), Slic3r::SupportLayer::has_extrusions(), Slic3r::Layer::height, Slic3r::GCode::ObjectLayerToPrint::layer(), Slic3r::GCode::ObjectLayerToPrint::object_layer, Slic3r::GCode::ObjectLayerToPrint::print_z(), Slic3r::Layer::print_z, and Slic3r::GCode::ObjectLayerToPrint::support_layer.

Referenced by _do_export(), and collect_layers_to_print().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ config()

const FullPrintConfig & Slic3r::GCode::config ( ) const

inline

172{ return m_config; }

References m_config.

Referenced by _do_export(), Slic3r::OozePrevention::_get_temp(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::need_wipe(), Slic3r::OozePrevention::post_toolchange(), Slic3r::OozePrevention::pre_toolchange(), process_layer(), process_layer_single_object(), set_extruder(), Slic3r::WipeTowerIntegration::tool_change(), Slic3r::AvoidCrossingPerimeters::travel_to(), and travel_to().

Here is the caller graph for this function:

◆ do_export()

void Slic3r::GCode::do_export	(	Print *	print,
		const char *	path,
		GCodeProcessorResult *	result = `nullptr`,
		ThumbnailsGeneratorCallback	thumbnail_cb = `nullptr`
	)

{
    CNumericLocalesSetter locales_setter;
 
    // Does the file exist? If so, we hope that it is still valid.
    {
        PrintStateBase::StateWithTimeStamp state = print->step_state_with_timestamp(psGCodeExport);
        if (! state.enabled || (state.is_done() && boost::filesystem::exists(boost::filesystem::path(path))))
            return;
    }
 
    // Enabled and either not done, or marked as done while the output file is missing.
    print->set_started(psGCodeExport);
 
    // check if any custom gcode contains keywords used by the gcode processor to
    // produce time estimation and gcode toolpaths
    std::vector<std::pair<std::string, std::string>> validation_res = DoExport::validate_custom_gcode(*print);
    if (!validation_res.empty()) {
        std::string reports;
        for (const auto& [source, keyword] : validation_res) {
            reports += source + ": \"" + keyword + "\"\n";
        }
        print->active_step_add_warning(PrintStateBase::WarningLevel::NON_CRITICAL,
            _u8L("In the custom G-code were found reserved keywords:") + "\n" +
            reports +
            _u8L("This may cause problems in g-code visualization and printing time estimation."));
    }
 
    BOOST_LOG_TRIVIAL(info) << "Exporting G-code..." << log_memory_info();
 
    // Remove the old g-code if it exists.
    boost::nowide::remove(path);
 
    std::string path_tmp(path);
    path_tmp += ".tmp";
 
    m_processor.initialize(path_tmp);
    m_processor.set_print(print);
    GCodeOutputStream file(boost::nowide::fopen(path_tmp.c_str(), "wb"), m_processor);
    if (! file.is_open())
        throw Slic3r::RuntimeError(std::string("G-code export to ") + path + " failed.\nCannot open the file for writing.\n");
 
    try {
        this->_do_export(*print, file, thumbnail_cb);
        file.flush();
        if (file.is_error()) {
            file.close();
            boost::nowide::remove(path_tmp.c_str());
            throw Slic3r::RuntimeError(std::string("G-code export to ") + path + " failed\nIs the disk full?\n");
        }
    } catch (std::exception & /* ex */) {
        // Rethrow on any exception. std::runtime_exception and CanceledException are expected to be thrown.
        // Close and remove the file.
        file.close();
        boost::nowide::remove(path_tmp.c_str());
        throw;
    }
    file.close();
 
    if (! m_placeholder_parser_integration.failed_templates.empty()) {
        // G-code export proceeded, but some of the PlaceholderParser substitutions failed.
        //FIXME localize!
        std::string msg = std::string("G-code export to ") + path + " failed due to invalid custom G-code sections:\n\n";
        for (const auto &name_and_error : m_placeholder_parser_integration.failed_templates)
            msg += name_and_error.first + "\n" + name_and_error.second + "\n";
        msg += "\nPlease inspect the file ";
        msg += path_tmp + " for error messages enclosed between\n";
        msg += "        !!!!! Failed to process the custom G-code template ...\n";
        msg += "and\n";
        msg += "        !!!!! End of an error report for the custom G-code template ...\n";
        msg += "for all macro processing errors.";
        throw Slic3r::PlaceholderParserError(msg);
    }
 
    BOOST_LOG_TRIVIAL(debug) << "Start processing gcode, " << log_memory_info();
    // Post-process the G-code to update time stamps.
    m_processor.finalize(true);
//    DoExport::update_print_estimated_times_stats(m_processor, print->m_print_statistics);
    DoExport::update_print_estimated_stats(m_processor, m_writer.extruders(), print->m_print_statistics);
    if (result != nullptr) {
        *result = std::move(m_processor.extract_result());
        // set the filename to the correct value
        result->filename = path;
    }
    BOOST_LOG_TRIVIAL(debug) << "Finished processing gcode, " << log_memory_info();
 
    if (rename_file(path_tmp, path))
        throw Slic3r::RuntimeError(
            std::string("Failed to rename the output G-code file from ") + path_tmp + " to " + path + '\n' +
            "Is " + path_tmp + " locked?" + '\n');
 
    BOOST_LOG_TRIVIAL(info) << "Exporting G-code finished" << log_memory_info();
    print->set_done(psGCodeExport);
}

References _do_export(), _u8L, Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::active_step_add_warning(), Slic3r::GCode::GCodeOutputStream::close(), Slic3r::PrintStateBase::StateWithTimeStamp::enabled, Slic3r::GCodeProcessor::extract_result(), Slic3r::GCodeWriter::extruders(), Slic3r::GCode::PlaceholderParserIntegration::failed_templates, Slic3r::GCodeProcessorResult::filename, Slic3r::GCodeProcessor::finalize(), Slic3r::GCode::GCodeOutputStream::flush(), Slic3r::GCodeProcessor::initialize(), Slic3r::PrintStateBase::StateWithTimeStamp::is_done(), Slic3r::GCode::GCodeOutputStream::is_error(), Slic3r::GCode::GCodeOutputStream::is_open(), keyword(), Slic3r::log_memory_info(), m_placeholder_parser_integration, Slic3r::Print::m_print_statistics, m_processor, m_writer, Slic3r::PrintStateBase::NON_CRITICAL, Slic3r::psGCodeExport, Slic3r::rename_file(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_done(), Slic3r::GCodeProcessor::set_print(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::set_started(), Slic3r::PrintBaseWithState< PrintStepEnumType, COUNT >::step_state_with_timestamp(), Slic3r::DoExport::update_print_estimated_stats(), and Slic3r::DoExport::validate_custom_gcode().

Here is the call graph for this function:

◆ enable_cooling_markers()

bool Slic3r::GCode::enable_cooling_markers ( ) const

inline

181{ return m_enable_cooling_markers; }

References m_enable_cooling_markers.

Referenced by Slic3r::Wipe::wipe().

Here is the caller graph for this function:

◆ extrude_entity()

std::string Slic3r::GCode::extrude_entity	(	const ExtrusionEntity &	entity,
		const std::string_view	description,
		double	speed = `-1.`
	)

private

{
    if (const ExtrusionPath* path = dynamic_cast<const ExtrusionPath*>(&entity))
        return this->extrude_path(*path, description, speed);
    else if (const ExtrusionMultiPath* multipath = dynamic_cast<const ExtrusionMultiPath*>(&entity))
        return this->extrude_multi_path(*multipath, description, speed);
    else if (const ExtrusionLoop* loop = dynamic_cast<const ExtrusionLoop*>(&entity))
        return this->extrude_loop(*loop, description, speed);
    else
        throw Slic3r::InvalidArgument("Invalid argument supplied to extrude()");
    return "";
}

References extrude_loop(), extrude_multi_path(), and extrude_path().

Referenced by process_layer(), and process_layer_single_object().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extrude_loop()

std::string Slic3r::GCode::extrude_loop	(	ExtrusionLoop	loop,
		const std::string_view	description,
		double	speed = `-1.`
	)

private

{
    // get a copy; don't modify the orientation of the original loop object otherwise
    // next copies (if any) would not detect the correct orientation
 
    // extrude all loops ccw
    bool was_clockwise = loop.make_counter_clockwise();
 
    // find the point of the loop that is closest to the current extruder position
    // or randomize if requested
    Point last_pos = this->last_pos();
 
    if (! m_config.spiral_vase && comment_is_perimeter(description)) {
        assert(m_layer != nullptr);
        m_seam_placer.place_seam(m_layer, loop, m_config.external_perimeters_first, this->last_pos());
    } else
        // Because the G-code export has 1um resolution, don't generate segments shorter than 1.5 microns,
        // thus empty path segments will not be produced by G-code export.
        loop.split_at(last_pos, false, scaled<double>(0.0015));
 
    for (auto it = std::next(loop.paths.begin()); it != loop.paths.end(); ++it) {
        assert(it->polyline.points.size() >= 2);
        assert(std::prev(it)->polyline.last_point() == it->polyline.first_point());
    }
    assert(loop.paths.front().first_point() == loop.paths.back().last_point());
 
    // clip the path to avoid the extruder to get exactly on the first point of the loop;
    // if polyline was shorter than the clipping distance we'd get a null polyline, so
    // we discard it in that case
    double clip_length = m_enable_loop_clipping ?
        scale_(EXTRUDER_CONFIG(nozzle_diameter)) * LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER :
        0;
 
    // get paths
    ExtrusionPaths paths;
    loop.clip_end(clip_length, &paths);
    if (paths.empty()) return "";
 
    // apply the small perimeter speed
    if (paths.front().role().is_perimeter() && loop.length() <= SMALL_PERIMETER_LENGTH && speed == -1)
        speed = m_config.small_perimeter_speed.get_abs_value(m_config.perimeter_speed);
 
    // extrude along the path
    std::string gcode;
    for (ExtrusionPath &path : paths) {
        path.simplify(m_scaled_resolution);
        gcode += this->_extrude(path, description, speed);
    }
 
    // reset acceleration
    gcode += m_writer.set_print_acceleration((unsigned int)(m_config.default_acceleration.value + 0.5));
 
    if (m_wipe.enable) {
        m_wipe.path = paths.front().polyline;
 
        for (auto it = std::next(paths.begin()); it != paths.end(); ++it) {
            if (it->role().is_bridge())
                break; // Don't perform a wipe on bridges.
 
            assert(it->polyline.points.size() >= 2);
            assert(m_wipe.path.points.back() == it->polyline.first_point());
            if (m_wipe.path.points.back() != it->polyline.first_point())
                break; // ExtrusionLoop is interrupted in some place.
 
            m_wipe.path.points.insert(m_wipe.path.points.end(), it->polyline.points.begin() + 1, it->polyline.points.end());
        }
    }
 
    // make a little move inwards before leaving loop
    if (paths.back().role().is_external_perimeter() && m_layer != NULL && m_config.perimeters.value > 1 && paths.front().size() >= 2 && paths.back().polyline.points.size() >= 3) {
        // detect angle between last and first segment
        // the side depends on the original winding order of the polygon (left for contours, right for holes)
        //FIXME improve the algorithm in case the loop is tiny.
        //FIXME improve the algorithm in case the loop is split into segments with a low number of points (see the Point b query).
        // Angle from the 2nd point to the last point.
        double angle_inside = angle(paths.front().polyline.points[1]        - paths.front().first_point(),
                                    *(paths.back().polyline.points.end()-3) - paths.front().first_point());
        assert(angle_inside >= -M_PI && angle_inside <= M_PI);
        // 3rd of this angle will be taken, thus make the angle monotonic before interpolation.
        if (was_clockwise) {
            if (angle_inside > 0)
                angle_inside -= 2.0 * M_PI;
        } else {
            if (angle_inside < 0)
                angle_inside += 2.0 * M_PI;
        }
 
        // create the destination point along the first segment and rotate it
        // we make sure we don't exceed the segment length because we don't know
        // the rotation of the second segment so we might cross the object boundary
        Vec2d  p1 = paths.front().polyline.points.front().cast<double>();
        Vec2d  p2 = paths.front().polyline.points[1].cast<double>();
        Vec2d  v  = p2 - p1;
        double nd = scale_(EXTRUDER_CONFIG(nozzle_diameter));
        double l2 = v.squaredNorm();
        // Shift by no more than a nozzle diameter.
        //FIXME Hiding the seams will not work nicely for very densely discretized contours!
        Point  pt = ((nd * nd >= l2) ? p2 : (p1 + v * (nd / sqrt(l2)))).cast<coord_t>();
        // Rotate pt inside around the seam point.
        pt.rotate(angle_inside / 3., paths.front().polyline.points.front());
        // generate the travel move
        gcode += m_writer.travel_to_xy(this->point_to_gcode(pt), "move inwards before travel");
    }
 
    return gcode;
}

References _extrude(), Slic3r::angle(), Slic3r::comment_is_perimeter(), Slic3r::Wipe::enable, EXTRUDER_CONFIG, Slic3r::MultiPoint::front(), Slic3r::l2(), last_pos(), LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER, m_config, m_enable_loop_clipping, m_layer, M_PI, m_scaled_resolution, m_seam_placer, m_wipe, m_writer, Slic3r::Wipe::path, Slic3r::SeamPlacer::place_seam(), point_to_gcode(), Slic3r::MultiPoint::points, Slic3r::Point::rotate(), scale_, Slic3r::GCodeWriter::set_print_acceleration(), SMALL_PERIMETER_LENGTH, sqrt(), and Slic3r::GCodeWriter::travel_to_xy().

Referenced by extrude_entity(), and process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extrude_multi_path()

std::string Slic3r::GCode::extrude_multi_path	(	ExtrusionMultiPath	multipath,
		const std::string_view	description,
		double	speed = `-1.`
	)

private

{
    for (auto it = std::next(multipath.paths.begin()); it != multipath.paths.end(); ++it) {
        assert(it->polyline.points.size() >= 2);
        assert(std::prev(it)->polyline.last_point() == it->polyline.first_point());
    }
    // extrude along the path
    std::string gcode;
    for (ExtrusionPath path : multipath.paths) {
        path.simplify(m_scaled_resolution);
        gcode += this->_extrude(path, description, speed);
    }
    if (m_wipe.enable) {
        m_wipe.path = std::move(multipath.paths.back().polyline);
        m_wipe.path.reverse();
 
        for (auto it = std::next(multipath.paths.rbegin()); it != multipath.paths.rend(); ++it) {
            if (it->role().is_bridge())
                break; // Do not perform a wipe on bridges.
 
            assert(it->polyline.points.size() >= 2);
            assert(m_wipe.path.points.back() == it->polyline.last_point());
            if (m_wipe.path.points.back() != it->polyline.last_point())
                break; // ExtrusionMultiPath is interrupted in some place.
 
            m_wipe.path.points.insert(m_wipe.path.points.end(), it->polyline.points.rbegin() + 1, it->polyline.points.rend());
        }
    }
    // reset acceleration
    gcode += m_writer.set_print_acceleration((unsigned int)floor(m_config.default_acceleration.value + 0.5));
    return gcode;
}

References _extrude(), Slic3r::Wipe::enable, floor(), m_config, m_scaled_resolution, m_wipe, m_writer, Slic3r::Wipe::path, Slic3r::ExtrusionMultiPath::paths, Slic3r::MultiPoint::points, Slic3r::MultiPoint::reverse(), and Slic3r::GCodeWriter::set_print_acceleration().

Referenced by extrude_entity(), and extrude_support().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extrude_path()

std::string Slic3r::GCode::extrude_path	(	ExtrusionPath	path,
		const std::string_view	description,
		double	speed = `-1.`
	)

private

{
    path.simplify(m_scaled_resolution);
    std::string gcode = this->_extrude(path, description, speed);
    if (m_wipe.enable) {
        m_wipe.path = std::move(path.polyline);
        m_wipe.path.reverse();
    }
    // reset acceleration
    gcode += m_writer.set_print_acceleration((unsigned int)floor(m_config.default_acceleration.value + 0.5));
    return gcode;
}

References _extrude(), Slic3r::Wipe::enable, floor(), m_config, m_scaled_resolution, m_wipe, m_writer, Slic3r::Wipe::path, Slic3r::ExtrusionPath::polyline, Slic3r::MultiPoint::reverse(), Slic3r::GCodeWriter::set_print_acceleration(), and Slic3r::ExtrusionPath::simplify().

Referenced by extrude_entity(), and extrude_support().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extrude_support()

std::string Slic3r::GCode::extrude_support ( const ExtrusionEntityCollection & support_fills )

private

{
    static constexpr const auto support_label            = "support material"sv;
    static constexpr const auto support_interface_label  = "support material interface"sv;
 
    std::string gcode;
    if (! support_fills.entities.empty()) {
        const double  support_speed            = m_config.support_material_speed.value;
        const double  support_interface_speed  = m_config.support_material_interface_speed.get_abs_value(support_speed);
        for (const ExtrusionEntity *ee : support_fills.entities) {
            ExtrusionRole role = ee->role();
            assert(role == ExtrusionRole::SupportMaterial || role == ExtrusionRole::SupportMaterialInterface);
            const auto   label = (role == ExtrusionRole::SupportMaterial) ? support_label : support_interface_label;
            const double speed = (role == ExtrusionRole::SupportMaterial) ? support_speed : support_interface_speed;
            const ExtrusionPath *path = dynamic_cast<const ExtrusionPath*>(ee);
            if (path)
                gcode += this->extrude_path(*path, label, speed);
            else {
                const ExtrusionMultiPath *multipath = dynamic_cast<const ExtrusionMultiPath*>(ee);
                if (multipath)
                    gcode += this->extrude_multi_path(*multipath, label, speed);
                else {
                    const ExtrusionEntityCollection *eec = dynamic_cast<const ExtrusionEntityCollection*>(ee);
                    assert(eec);
                    if (eec)
                        gcode += this->extrude_support(*eec);
                }
            }
        }
    }
    return gcode;
}

References Slic3r::ExtrusionEntityCollection::entities, extrude_multi_path(), extrude_path(), extrude_support(), m_config, Slic3r::ExtrusionRole::SupportMaterial, and Slic3r::ExtrusionRole::SupportMaterialInterface.

Referenced by extrude_support(), and process_layer_single_object().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gcode_to_point()

Point Slic3r::GCode::gcode_to_point ( const Vec2d & point ) const

{
    Vec2d pt = point - m_origin;
    if (const Extruder *extruder = m_writer.extruder(); extruder)
        // This function may be called at the very start from toolchange G-code when the extruder is not assigned yet.
        pt += m_config.extruder_offset.get_at(extruder->id());
    return scaled<coord_t>(pt);
        
}

References Slic3r::GCodeWriter::extruder(), m_config, m_origin, and m_writer.

Referenced by placeholder_parser_process(), and Slic3r::Wipe::wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ last_pos()

const Point & Slic3r::GCode::last_pos ( ) const

inline

166{ return m_last_pos; }

References m_last_pos.

Referenced by extrude_loop(), Slic3r::AvoidCrossingPerimeters::travel_to(), travel_to(), and Slic3r::Wipe::wipe().

Here is the caller graph for this function:

◆ last_pos_defined()

bool Slic3r::GCode::last_pos_defined ( ) const

inlineprivate

279{ return m_last_pos_defined; }

References m_last_pos_defined.

◆ layer()

const Layer * Slic3r::GCode::layer ( ) const

inline

173{ return m_layer; }

References m_layer.

Referenced by _do_export(), Slic3r::OozePrevention::_get_temp(), process_layer(), process_layer_single_object(), process_layers(), process_layers(), and Slic3r::AvoidCrossingPerimeters::travel_to().

Here is the caller graph for this function:

◆ layer_count()

unsigned int Slic3r::GCode::layer_count ( ) const

inline

184{ return m_layer_count; }

References m_layer_count.

◆ needs_retraction()

bool Slic3r::GCode::needs_retraction	(	const Polyline &	travel,
		ExtrusionRole	role = `ExtrusionRole::None`
	)

private

{
    if (travel.length() < scale_(EXTRUDER_CONFIG(retract_before_travel))) {
        // skip retraction if the move is shorter than the configured threshold
        return false;
    }
 
    if (role == ExtrusionRole::SupportMaterial)
        if (const SupportLayer *support_layer = dynamic_cast<const SupportLayer*>(m_layer);
            support_layer != nullptr && ! support_layer->support_islands_bboxes.empty()) {
            BoundingBox bbox_travel = get_extents(travel);
            Polylines   trimmed;
            bool        trimmed_initialized = false;
            for (const BoundingBox &bbox : support_layer->support_islands_bboxes)
                if (bbox.overlap(bbox_travel)) {
                    const auto &island = support_layer->support_islands[&bbox - support_layer->support_islands_bboxes.data()];
                    trimmed = trimmed_initialized ? diff_pl(trimmed, island) : diff_pl(travel, island);
                    trimmed_initialized = true;
                    if (trimmed.empty())
                        // skip retraction if this is a travel move inside a support material island
                        //FIXME not retracting over a long path may cause oozing, which in turn may result in missing material
                        // at the end of the extrusion path!
                        return false;
                    // Not sure whether updating the boudning box isn't too expensive.
                    //bbox_travel = get_extents(trimmed);
                }
        }
 
    if (m_config.only_retract_when_crossing_perimeters && m_layer != nullptr &&
        m_config.fill_density.value > 0 && m_retract_when_crossing_perimeters.travel_inside_internal_regions(*m_layer, travel))
        // Skip retraction if travel is contained in an internal slice *and*
        // internal infill is enabled (so that stringing is entirely not visible).
        //FIXME any_internal_region_slice_contains() is potentionally very slow, it shall test for the bounding boxes first.
        return false;
 
    // retract if only_retract_when_crossing_perimeters is disabled or doesn't apply
    return true;
}

References Slic3r::diff_pl(), EXTRUDER_CONFIG, Slic3r::get_extents(), Slic3r::Polyline::length(), m_config, m_layer, m_retract_when_crossing_perimeters, scale_, Slic3r::SupportLayer::support_islands_bboxes, Slic3r::ExtrusionRole::SupportMaterial, and Slic3r::RetractWhenCrossingPerimeters::travel_inside_internal_regions().

Referenced by travel_to().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ object_layer_over_raft()

bool Slic3r::GCode::object_layer_over_raft ( ) const

inlineprivate

444{ return m_object_layer_over_raft; }

References m_object_layer_over_raft.

Referenced by _extrude().

Here is the caller graph for this function:

◆ on_first_layer()

bool Slic3r::GCode::on_first_layer ( ) const

inlineprivate

442{ return m_layer != nullptr && m_layer->id() == 0; }

Slic3r::Layer::id

size_t id() const

Definition Layer.hpp:315

References Slic3r::Layer::id(), and m_layer.

Referenced by _extrude().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ origin()

const Vec2d & Slic3r::GCode::origin ( ) const

inline

163{ return m_origin; }

References m_origin.

Referenced by Slic3r::AvoidCrossingPerimeters::travel_to(), travel_to(), and Slic3r::wipe_tower_point_to_object_point().

Here is the caller graph for this function:

◆ placeholder_parser() [1/2]

PlaceholderParser & Slic3r::GCode::placeholder_parser ( )

inline

176{ return m_placeholder_parser_integration.parser; }

References m_placeholder_parser_integration, and Slic3r::GCode::PlaceholderParserIntegration::parser.

Referenced by _do_export(), and set_extruder().

Here is the caller graph for this function:

◆ placeholder_parser() [2/2]

const PlaceholderParser & Slic3r::GCode::placeholder_parser ( ) const

inline

177{ return m_placeholder_parser_integration.parser; }

References m_placeholder_parser_integration, and Slic3r::GCode::PlaceholderParserIntegration::parser.

◆ placeholder_parser_process()

std::string Slic3r::GCode::placeholder_parser_process	(	const std::string &	name,
		const std::string &	templ,
		unsigned int	current_extruder_id,
		const DynamicConfig *	config_override = `nullptr`
	)

{
    PlaceholderParserIntegration &ppi = m_placeholder_parser_integration;
    try {
        ppi.update_from_gcodewriter(m_writer);
        std::string output = ppi.parser.process(templ, current_extruder_id, config_override, &ppi.output_config, &ppi.context);
        ppi.validate_output_vector_variables();
 
        if (const std::vector<double> &pos = ppi.opt_position->values; ppi.position != pos) {
            // Update G-code writer.
            m_writer.update_position({ pos[0], pos[1], pos[2] });
            this->set_last_pos(this->gcode_to_point({ pos[0], pos[1] }));
        }
 
        for (const Extruder &e : m_writer.extruders()) {
            unsigned int eid = e.id();
            assert(eid < ppi.num_extruders);
            if ( eid < ppi.num_extruders) {
                if (! m_writer.config.use_relative_e_distances && ! is_approx(ppi.e_position[eid], ppi.opt_e_position->values[eid]))
                    const_cast<Extruder&>(e).set_position(ppi.opt_e_position->values[eid]);
                if (! is_approx(ppi.e_retracted[eid], ppi.opt_e_retracted->values[eid]) || 
                    ! is_approx(ppi.e_restart_extra[eid], ppi.opt_e_restart_extra->values[eid]))
                    const_cast<Extruder&>(e).set_retracted(ppi.opt_e_retracted->values[eid], ppi.opt_e_restart_extra->values[eid]);
            }
        }
 
        return output;
    } 
    catch (std::runtime_error &err) 
    {
        // Collect the names of failed template substitutions for error reporting.
        auto it = ppi.failed_templates.find(name);
        if (it == ppi.failed_templates.end())
            // Only if there was no error reported for this template, store the first error message into the map to be reported.
            // We don't want to collect error message for each and every occurence of a single custom G-code section.
            ppi.failed_templates.insert(it, std::make_pair(name, std::string(err.what())));
        // Insert the macro error message into the G-code.
        return
            std::string("\n!!!!! Failed to process the custom G-code template ") + name + "\n" +
            err.what() +
            "!!!!! End of an error report for the custom G-code template " + name + "\n\n";
    }
}

Referenced by _do_export(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::ProcessLayer::emit_custom_gcode_per_print_z(), process_layer(), and set_extruder().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ point_to_gcode()

Vec2d Slic3r::GCode::point_to_gcode ( const Point & point ) const

{
    Vec2d extruder_offset = EXTRUDER_CONFIG(extruder_offset);
    return unscaled<double>(point) + m_origin - extruder_offset;
}

References EXTRUDER_CONFIG, and m_origin.

Referenced by extrude_loop(), and point_to_gcode_quantized().

Here is the caller graph for this function:

◆ point_to_gcode_quantized()

Vec2d Slic3r::GCode::point_to_gcode_quantized ( const Point & point ) const

{
    Vec2d p = this->point_to_gcode(point);
    return { GCodeFormatter::quantize_xyzf(p.x()), GCodeFormatter::quantize_xyzf(p.y()) };
}

References point_to_gcode(), and Slic3r::GCodeFormatter::quantize_xyzf().

Referenced by _extrude(), and Slic3r::Wipe::wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ preamble()

std::string Slic3r::GCode::preamble ( )

private

{
    std::string gcode = m_writer.preamble();
 
    /*  Perform a *silent* move to z_offset: we need this to initialize the Z
        position of our writer object so that any initial lift taking place
        before the first layer change will raise the extruder from the correct
        initial Z instead of 0.  */
    m_writer.travel_to_z(m_config.z_offset.value);
 
    return gcode;
}

References m_config, m_writer, Slic3r::GCodeWriter::preamble(), and Slic3r::GCodeWriter::travel_to_z().

Referenced by _do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_machine_envelope()

void Slic3r::GCode::print_machine_envelope	(	GCodeOutputStream &	file,
		Print &	print
	)

private

{
    const GCodeFlavor flavor = print.config().gcode_flavor.value;
    if ( (flavor == gcfMarlinLegacy || flavor == gcfMarlinFirmware || flavor == gcfRepRapFirmware)
     && print.config().machine_limits_usage.value == MachineLimitsUsage::EmitToGCode) {
        int factor = flavor == gcfRepRapFirmware ? 60 : 1; // RRF M203 and M566 are in mm/min
        file.write_format("M201 X%d Y%d Z%d E%d ; sets maximum accelerations, mm/sec^2\n",
            int(print.config().machine_max_acceleration_x.values.front() + 0.5),
            int(print.config().machine_max_acceleration_y.values.front() + 0.5),
            int(print.config().machine_max_acceleration_z.values.front() + 0.5),
            int(print.config().machine_max_acceleration_e.values.front() + 0.5));
        file.write_format("M203 X%d Y%d Z%d E%d ; sets maximum feedrates, %s\n",
            int(print.config().machine_max_feedrate_x.values.front() * factor + 0.5),
            int(print.config().machine_max_feedrate_y.values.front() * factor + 0.5),
            int(print.config().machine_max_feedrate_z.values.front() * factor + 0.5),
            int(print.config().machine_max_feedrate_e.values.front() * factor + 0.5),
            factor == 60 ? "mm / min" : "mm / sec");
 
        // Now M204 - acceleration. This one is quite hairy...
        if (flavor == gcfRepRapFirmware)
            // Uses M204 P[print] T[travel]
            file.write_format("M204 P%d T%d ; sets acceleration (P, T), mm/sec^2\n",
                int(print.config().machine_max_acceleration_extruding.values.front() + 0.5),
                int(print.config().machine_max_acceleration_travel.values.front() + 0.5));
        else if (flavor == gcfMarlinLegacy)
            // Legacy Marlin uses M204 S[print] T[retract]
            file.write_format("M204 S%d T%d ; sets acceleration (S) and retract acceleration (R), mm/sec^2\n",
                int(print.config().machine_max_acceleration_extruding.values.front() + 0.5),
                int(print.config().machine_max_acceleration_retracting.values.front() + 0.5));
        else if (flavor == gcfMarlinFirmware)
            // New Marlin uses M204 P[print] R[retract] T[travel]
            file.write_format("M204 P%d R%d T%d ; sets acceleration (P, T) and retract acceleration (R), mm/sec^2\n",
                int(print.config().machine_max_acceleration_extruding.values.front() + 0.5),
                int(print.config().machine_max_acceleration_retracting.values.front() + 0.5),
                int(print.config().machine_max_acceleration_travel.values.front() + 0.5));
        else
            assert(false);
 
        assert(is_decimal_separator_point());
        file.write_format(flavor == gcfRepRapFirmware
            ? "M566 X%.2lf Y%.2lf Z%.2lf E%.2lf ; sets the jerk limits, mm/min\n"
            : "M205 X%.2lf Y%.2lf Z%.2lf E%.2lf ; sets the jerk limits, mm/sec\n",
            print.config().machine_max_jerk_x.values.front() * factor,
            print.config().machine_max_jerk_y.values.front() * factor,
            print.config().machine_max_jerk_z.values.front() * factor,
            print.config().machine_max_jerk_e.values.front() * factor);
        if (flavor != gcfRepRapFirmware)
            file.write_format("M205 S%d T%d ; sets the minimum extruding and travel feed rate, mm/sec\n",
                int(print.config().machine_min_extruding_rate.values.front() + 0.5),
                int(print.config().machine_min_travel_rate.values.front() + 0.5));
        else {
            // M205 Sn Tn not supported in RRF. They use M203 Inn to set minimum feedrate for
            // all moves. This is currently not implemented.
        }
    }
}

References Slic3r::Print::config(), Slic3r::EmitToGCode, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepRapFirmware, Slic3r::is_decimal_separator_point(), and Slic3r::GCode::GCodeOutputStream::write_format().

Referenced by _do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_layer()

LayerResult Slic3r::GCode::process_layer	(	const Print &	print,
		const ObjectsLayerToPrint &	layers,
		const LayerTools &	layer_tools,
		const bool	last_layer,
		const std::vector< const PrintInstance * > *	ordering,
		const size_t	single_object_idx = `size_t(-1)`
	)

private

{
    assert(! layers.empty());
    // Either printing all copies of all objects, or just a single copy of a single object.
    assert(single_object_instance_idx == size_t(-1) || layers.size() == 1);
 
    // First object, support and raft layer, if available.
    const Layer         *object_layer  = nullptr;
    const SupportLayer  *support_layer = nullptr;
    const SupportLayer  *raft_layer    = nullptr;
    for (const ObjectLayerToPrint &l : layers) {
        if (l.object_layer && ! object_layer)
            object_layer = l.object_layer;
        if (l.support_layer) {
            if (! support_layer)
                support_layer = l.support_layer;
            if (! raft_layer && support_layer->id() < support_layer->object()->slicing_parameters().raft_layers())
                raft_layer = support_layer;
        }
    }
    const Layer  &layer = (object_layer != nullptr) ? *object_layer : *support_layer;
    LayerResult   result { {}, layer.id(), false, last_layer, false};
    if (layer_tools.extruders.empty())
        // Nothing to extrude.
        return result;
 
    // Extract 1st object_layer and support_layer of this set of layers with an equal print_z.
    coordf_t             print_z       = layer.print_z;
    bool                 first_layer   = layer.id() == 0;
    unsigned int         first_extruder_id = layer_tools.extruders.front();
 
    // Initialize config with the 1st object to be printed at this layer.
    m_config.apply(layer.object()->config(), true);
 
    // Check whether it is possible to apply the spiral vase logic for this layer.
    // Just a reminder: A spiral vase mode is allowed for a single object, single material print only.
    m_enable_loop_clipping = true;
    if (m_spiral_vase && layers.size() == 1 && support_layer == nullptr) {
        bool enable = (layer.id() > 0 || !print.has_brim()) && (layer.id() >= (size_t)print.config().skirt_height.value && ! print.has_infinite_skirt());
        if (enable) {
            for (const LayerRegion *layer_region : layer.regions())
                if (size_t(layer_region->region().config().bottom_solid_layers.value) > layer.id() ||
                    layer_region->perimeters().items_count() > 1u ||
                    layer_region->fills().items_count() > 0) {
                    enable = false;
                    break;
                }
        }
        result.spiral_vase_enable = enable;
        // If we're going to apply spiralvase to this layer, disable loop clipping.
        m_enable_loop_clipping = !enable;
    }
 
    std::string gcode;
    assert(is_decimal_separator_point()); // for the sprintfs
 
    // add tag for processor
    gcode += ";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Layer_Change) + "\n";
    // export layer z
    gcode += std::string(";Z:") + float_to_string_decimal_point(print_z) + "\n";
 
    // export layer height
    float height = first_layer ? static_cast<float>(print_z) : static_cast<float>(print_z) - m_last_layer_z;
    gcode += std::string(";") + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height)
        + float_to_string_decimal_point(height) + "\n";
 
    // update caches
    m_last_layer_z = static_cast<float>(print_z);
    m_max_layer_z  = std::max(m_max_layer_z, m_last_layer_z);
    m_last_height = height;
 
    // Set new layer - this will change Z and force a retraction if retract_layer_change is enabled.
    if (! print.config().before_layer_gcode.value.empty()) {
        DynamicConfig config;
        config.set_key_value("layer_num",   new ConfigOptionInt(m_layer_index + 1));
        config.set_key_value("layer_z",     new ConfigOptionFloat(print_z));
        config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
        gcode += this->placeholder_parser_process("before_layer_gcode",
            print.config().before_layer_gcode.value, m_writer.extruder()->id(), &config)
            + "\n";
    }
    gcode += this->change_layer(print_z);  // this will increase m_layer_index
    m_layer = &layer;
    m_object_layer_over_raft = false;
    if (! print.config().layer_gcode.value.empty()) {
        DynamicConfig config;
        config.set_key_value("layer_num", new ConfigOptionInt(m_layer_index));
        config.set_key_value("layer_z",   new ConfigOptionFloat(print_z));
        config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
        gcode += this->placeholder_parser_process("layer_gcode",
            print.config().layer_gcode.value, m_writer.extruder()->id(), &config)
            + "\n";
    }
 
    if (! first_layer && ! m_second_layer_things_done) {
        // Transition from 1st to 2nd layer. Adjust nozzle temperatures as prescribed by the nozzle dependent
        // first_layer_temperature vs. temperature settings.
        for (const Extruder &extruder : m_writer.extruders()) {
            if (print.config().single_extruder_multi_material.value || m_ooze_prevention.enable) {
                // In single extruder multi material mode, set the temperature for the current extruder only.
                // The same applies when ooze prevention is enabled.
                if (extruder.id() != m_writer.extruder()->id())
                    continue;
            }
            int temperature = print.config().temperature.get_at(extruder.id());
            if (temperature > 0 && (temperature != print.config().first_layer_temperature.get_at(extruder.id())))
                gcode += m_writer.set_temperature(temperature, false, extruder.id());
        }
        gcode += m_writer.set_bed_temperature(print.config().bed_temperature.get_at(first_extruder_id));
        // Mark the temperature transition from 1st to 2nd layer to be finished.
        m_second_layer_things_done = true;
    }
 
    // Map from extruder ID to <begin, end> index of skirt loops to be extruded with that extruder.
    std::map<unsigned int, std::pair<size_t, size_t>> skirt_loops_per_extruder;
 
    if (single_object_instance_idx == size_t(-1)) {
        // Normal (non-sequential) print.
        gcode += ProcessLayer::emit_custom_gcode_per_print_z(*this, layer_tools.custom_gcode, m_writer.extruder()->id(), first_extruder_id, print.config());
    }
    // Extrude skirt at the print_z of the raft layers and normal object layers
    // not at the print_z of the interlaced support material layers.
    skirt_loops_per_extruder = first_layer ?
        Skirt::make_skirt_loops_per_extruder_1st_layer(print, layer_tools, m_skirt_done) :
        Skirt::make_skirt_loops_per_extruder_other_layers(print, layer_tools, m_skirt_done);
 
    if (this->config().avoid_crossing_curled_overhangs) {
        m_avoid_crossing_curled_overhangs.clear();
        for (const ObjectLayerToPrint &layer_to_print : layers) {
            if (layer_to_print.object() == nullptr)
                continue;
            for (const auto &instance : layer_to_print.object()->instances()) {
                m_avoid_crossing_curled_overhangs.add_obstacles(layer_to_print.object_layer, instance.shift);
                m_avoid_crossing_curled_overhangs.add_obstacles(layer_to_print.support_layer, instance.shift);
            }
        }
    }
 
    for (const ObjectLayerToPrint &layer_to_print : layers) {
        m_extrusion_quality_estimator.prepare_for_new_layer(layer_to_print.object_layer);
    }
 
    // Extrude the skirt, brim, support, perimeters, infill ordered by the extruders.
    for (unsigned int extruder_id : layer_tools.extruders)
    {
        gcode += (layer_tools.has_wipe_tower && m_wipe_tower) ?
            m_wipe_tower->tool_change(*this, extruder_id, extruder_id == layer_tools.extruders.back()) :
            this->set_extruder(extruder_id, print_z);
 
        // let analyzer tag generator aware of a role type change
        if (layer_tools.has_wipe_tower && m_wipe_tower)
            m_last_processor_extrusion_role = GCodeExtrusionRole::WipeTower;
 
        if (auto loops_it = skirt_loops_per_extruder.find(extruder_id); loops_it != skirt_loops_per_extruder.end()) {
            const std::pair<size_t, size_t> loops = loops_it->second;
            this->set_origin(0., 0.);
            m_avoid_crossing_perimeters.use_external_mp();
            Flow layer_skirt_flow = print.skirt_flow().with_height(float(m_skirt_done.back() - (m_skirt_done.size() == 1 ? 0. : m_skirt_done[m_skirt_done.size() - 2])));
            double mm3_per_mm = layer_skirt_flow.mm3_per_mm();
            for (size_t i = loops.first; i < loops.second; ++i) {
                // Adjust flow according to this layer's layer height.
                ExtrusionLoop loop = *dynamic_cast<const ExtrusionLoop*>(print.skirt().entities[i]);
                for (ExtrusionPath &path : loop.paths) {
                    path.height = layer_skirt_flow.height();
                    path.mm3_per_mm = mm3_per_mm;
                }
                //FIXME using the support_material_speed of the 1st object printed.
                gcode += this->extrude_loop(loop, "skirt"sv, m_config.support_material_speed.value);
            }
            m_avoid_crossing_perimeters.use_external_mp(false);
            // Allow a straight travel move to the first object point if this is the first layer (but don't in next layers).
            if (first_layer && loops.first == 0)
                m_avoid_crossing_perimeters.disable_once();
        }
 
        // Extrude brim with the extruder of the 1st region.
        if (! m_brim_done) {
            this->set_origin(0., 0.);
            m_avoid_crossing_perimeters.use_external_mp();
            for (const ExtrusionEntity *ee : print.brim().entities) {
                gcode += this->extrude_entity(*ee, "brim"sv, m_config.support_material_speed.value);
            }
            m_brim_done = true;
            m_avoid_crossing_perimeters.use_external_mp(false);
            // Allow a straight travel move to the first object point.
            m_avoid_crossing_perimeters.disable_once();
        }
 
        std::vector<InstanceToPrint> instances_to_print = sort_print_object_instances(layers, ordering, single_object_instance_idx);
 
        // We are almost ready to print. However, we must go through all the objects twice to print the the overridden extrusions first (infill/perimeter wiping feature):
        bool is_anything_overridden = layer_tools.wiping_extrusions().is_anything_overridden();
        if (is_anything_overridden) {
            // Extrude wipes.
            size_t gcode_size_old = gcode.size();
            for (const InstanceToPrint &instance : instances_to_print)
                this->process_layer_single_object(
                    gcode, extruder_id, instance,
                    layers[instance.object_layer_to_print_id], layer_tools,
                    is_anything_overridden, true /* print_wipe_extrusions */);
            if (gcode_size_old < gcode.size())
                gcode+="; PURGING FINISHED\n";
        }
        // Extrude normal extrusions.
        for (const InstanceToPrint &instance : instances_to_print)
            this->process_layer_single_object(
                gcode, extruder_id, instance,
                layers[instance.object_layer_to_print_id], layer_tools,
                is_anything_overridden, false /* print_wipe_extrusions */);
    }
 
    BOOST_LOG_TRIVIAL(trace) << "Exported layer " << layer.id() << " print_z " << print_z <<
    log_memory_info();
 
    result.gcode = std::move(gcode);
    result.cooling_buffer_flush = object_layer || raft_layer || last_layer;
    return result;
}

References Slic3r::JPSPathFinder::add_obstacles(), Slic3r::Print::brim(), change_layer(), Slic3r::JPSPathFinder::clear(), config(), Slic3r::PrintObject::config(), Slic3r::Print::config(), Slic3r::LayerTools::custom_gcode, Slic3r::AvoidCrossingPerimeters::disable_once(), Slic3r::ProcessLayer::emit_custom_gcode_per_print_z(), Slic3r::OozePrevention::enable, Slic3r::ExtrusionEntityCollection::entities, extrude_entity(), extrude_loop(), Slic3r::GCodeWriter::extruder(), Slic3r::LayerTools::extruders, Slic3r::GCodeWriter::extruders(), Slic3r::float_to_string_decimal_point(), Slic3r::Print::has_brim(), Slic3r::Print::has_infinite_skirt(), Slic3r::LayerTools::has_wipe_tower, Slic3r::Flow::height(), Slic3r::GCodeProcessor::Height, Slic3r::Extruder::id(), Slic3r::Layer::id(), Slic3r::WipingExtrusions::is_anything_overridden(), Slic3r::is_decimal_separator_point(), layer(), Slic3r::GCodeProcessor::Layer_Change, Slic3r::log_memory_info(), m_avoid_crossing_curled_overhangs, m_avoid_crossing_perimeters, m_brim_done, m_config, m_enable_loop_clipping, m_extrusion_quality_estimator, m_last_height, m_last_layer_z, m_last_processor_extrusion_role, m_layer, m_layer_index, m_max_layer_z, m_object_layer_over_raft, m_ooze_prevention, m_second_layer_things_done, m_skirt_done, m_spiral_vase, m_wipe_tower, m_writer, Slic3r::Skirt::make_skirt_loops_per_extruder_1st_layer(), Slic3r::Skirt::make_skirt_loops_per_extruder_other_layers(), Slic3r::Flow::mm3_per_mm(), Slic3r::Layer::object(), ordering, placeholder_parser_process(), Slic3r::ExtrusionQualityEstimator::prepare_for_new_layer(), Slic3r::Layer::print_z, process_layer_single_object(), Slic3r::SlicingParameters::raft_layers(), Slic3r::Layer::regions(), Slic3r::GCodeProcessor::reserved_tag(), Slic3r::GCodeWriter::set_bed_temperature(), set_extruder(), set_origin(), Slic3r::GCodeWriter::set_temperature(), Slic3r::Print::skirt(), Slic3r::Print::skirt_flow(), Slic3r::PrintObject::slicing_parameters(), sort_print_object_instances(), Slic3r::AvoidCrossingPerimeters::use_external_mp(), Slic3r::WipeTower, Slic3r::LayerTools::wiping_extrusions(), and Slic3r::Flow::with_height().

Referenced by process_layers(), and process_layers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_layer_single_object()

void Slic3r::GCode::process_layer_single_object	(	std::string &	gcode,
		const unsigned int	extruder_id,
		const InstanceToPrint &	print_instance,
		const ObjectLayerToPrint &	layer_to_print,
		const LayerTools &	layer_tools,
		const bool	is_anything_overridden,
		const bool	print_wipe_extrusions
	)

private

{
    bool     first     = true;
    int      object_id = 0;
    // Delay layer initialization as many layers may not print with all extruders.
    auto init_layer_delayed = [this, &print_instance, &layer_to_print, &first, &object_id, &gcode]() {
        if (first) {
            first = false;
            const PrintObject &print_object = print_instance.print_object;
            const Print       &print        = *print_object.print();
            m_config.apply(print_object.config(), true);
            m_layer = layer_to_print.layer();
            if (print.config().avoid_crossing_perimeters)
                m_avoid_crossing_perimeters.init_layer(*m_layer);
            // When starting a new object, use the external motion planner for the first travel move.
            const Point &offset = print_object.instances()[print_instance.instance_id].shift;
            std::pair<const PrintObject*, Point> this_object_copy(&print_object, offset);
            if (m_last_obj_copy != this_object_copy)
                m_avoid_crossing_perimeters.use_external_mp_once();
            m_last_obj_copy = this_object_copy;
            this->set_origin(unscale(offset));
            if (this->config().gcode_label_objects) {
                for (const PrintObject *po : print_object.print()->objects())
                    if (po == &print_object)
                        break;
                    else
                        ++ object_id;
                gcode += std::string("; printing object ") + print_object.model_object()->name + " id:" + std::to_string(object_id) + " copy " + std::to_string(print_instance.instance_id) + "\n";
            }
        }
    };
 
    const PrintObject &print_object = print_instance.print_object;
    const Print       &print        = *print_object.print();
 
    m_extrusion_quality_estimator.set_current_object(&print_object);
 
    if (! print_wipe_extrusions && layer_to_print.support_layer != nullptr)
        if (const SupportLayer &support_layer = *layer_to_print.support_layer; ! support_layer.support_fills.entities.empty()) {
            ExtrusionRole   role               = support_layer.support_fills.role();
            bool            has_support        = role.is_mixed() || role.is_support_base();
            bool            has_interface      = role.is_mixed() || role.is_support_interface();
            // Extruder ID of the support base. -1 if "don't care".
            unsigned int    support_extruder   = print_object.config().support_material_extruder.value - 1;
            // Shall the support be printed with the active extruder, preferably with non-soluble, to avoid tool changes?
            bool            support_dontcare   = support_extruder == std::numeric_limits<unsigned int>::max();
            // Extruder ID of the support interface. -1 if "don't care".
            unsigned int    interface_extruder = print_object.config().support_material_interface_extruder.value - 1;
            // Shall the support interface be printed with the active extruder, preferably with non-soluble, to avoid tool changes?
            bool            interface_dontcare = interface_extruder == std::numeric_limits<unsigned int>::max();
            if (support_dontcare || interface_dontcare) {
                // Some support will be printed with "don't care" material, preferably non-soluble.
                // Is the current extruder assigned a soluble filament?
                auto it_nonsoluble = std::find_if(layer_tools.extruders.begin(), layer_tools.extruders.end(), 
                    [&soluble = std::as_const(print.config().filament_soluble)](unsigned int extruder_id) { return ! soluble.get_at(extruder_id); });
                // There should be a non-soluble extruder available.
                assert(it_nonsoluble != layer_tools.extruders.end());
                unsigned int dontcare_extruder = it_nonsoluble == layer_tools.extruders.end() ? layer_tools.extruders.front() : *it_nonsoluble;
                if (support_dontcare)
                    support_extruder = dontcare_extruder;
                if (interface_dontcare)
                    interface_extruder = dontcare_extruder;
            }
            bool extrude_support   = has_support && support_extruder == extruder_id;
            bool extrude_interface = has_interface && interface_extruder == extruder_id;
            if (extrude_support || extrude_interface) {
                init_layer_delayed();
                m_layer = layer_to_print.support_layer;
                m_object_layer_over_raft = false;
                gcode += this->extrude_support(
                    // support_extrusion_role is ExtrusionRole::SupportMaterial, ExtrusionRole::SupportMaterialInterface or ExtrusionRole::Mixed for all extrusion paths.
                    support_layer.support_fills.chained_path_from(m_last_pos, extrude_support ? (extrude_interface ? ExtrusionRole::Mixed : ExtrusionRole::SupportMaterial) : ExtrusionRole::SupportMaterialInterface));
            }
        }
 
    m_layer = layer_to_print.layer();
    // To control print speed of the 1st object layer printed over raft interface.
    m_object_layer_over_raft = layer_to_print.object_layer && layer_to_print.object_layer->id() > 0 &&
        print_object.slicing_parameters().raft_layers() == layer_to_print.object_layer->id();
 
    // Check whether this ExtrusionEntityCollection should be printed now with extruder_id, given print_wipe_extrusions
    // (wipe extrusions are printed before regular extrusions).
    auto shall_print_this_extrusion_collection = [extruder_id, instance_id = print_instance.instance_id, &layer_tools, is_anything_overridden, print_wipe_extrusions](const ExtrusionEntityCollection *eec, const PrintRegion &region) -> bool {
        assert(eec != nullptr);
        if (eec->entities.empty())
            // This shouldn't happen. FIXME why? but first_point() would fail.
            return false;
        // This extrusion is part of certain Region, which tells us which extruder should be used for it:
        int correct_extruder_id = layer_tools.extruder(*eec, region);
        if (! layer_tools.has_extruder(correct_extruder_id)) {
            // this entity is not overridden, but its extruder is not in layer_tools - we'll print it
            // by last extruder on this layer (could happen e.g. when a wiping object is taller than others - dontcare extruders are eradicated from layer_tools)
            correct_extruder_id = layer_tools.extruders.back();
        }
        int extruder_override_id = is_anything_overridden ? layer_tools.wiping_extrusions().get_extruder_override(eec, instance_id) : -1;
        return print_wipe_extrusions ?
            extruder_override_id == int(extruder_id) :
            extruder_override_id < 0 && int(extruder_id) == correct_extruder_id;
    };
 
    ExtrusionEntitiesPtr temp_fill_extrusions;
    if (const Layer *layer = layer_to_print.object_layer; layer)
        for (size_t idx : layer->lslice_indices_sorted_by_print_order) {
            const LayerSlice &lslice = layer->lslices_ex[idx];
            auto extrude_infill_range = [&](
                const LayerRegion &layerm, const ExtrusionEntityCollection &fills,
                LayerExtrusionRanges::const_iterator it_fill_ranges_begin, LayerExtrusionRanges::const_iterator it_fill_ranges_end, bool ironing) {
                // PrintObjects own the PrintRegions, thus the pointer to PrintRegion would be unique to a PrintObject, they would not
                // identify the content of PrintRegion accross the whole print uniquely. Translate to a Print specific PrintRegion.
                const PrintRegion &region = print.get_print_region(layerm.region().print_region_id());
                temp_fill_extrusions.clear();
                for (auto it_fill_range = it_fill_ranges_begin; it_fill_range != it_fill_ranges_end; ++ it_fill_range) {
                    assert(it_fill_range->region() == it_fill_ranges_begin->region());
                    for (uint32_t fill_id : *it_fill_range) {
                        assert(dynamic_cast<ExtrusionEntityCollection*>(fills.entities[fill_id]));
                        if (auto *eec = static_cast<ExtrusionEntityCollection*>(fills.entities[fill_id]);
                            (eec->role() == ExtrusionRole::Ironing) == ironing && shall_print_this_extrusion_collection(eec, region)) {
                            if (eec->can_reverse())
                                // Flatten the infill collection for better path planning.
                                for (auto *ee : eec->entities)
                                    temp_fill_extrusions.emplace_back(ee);
                            else
                                temp_fill_extrusions.emplace_back(eec);
                        }
                    }
                }
                if (! temp_fill_extrusions.empty()) {
                    init_layer_delayed();
                    m_config.apply(region.config());
                    //FIXME The source extrusions may be reversed, thus modifying the extrusions! Is it a problem? How about the initial G-code preview?
                    // Will parallel access of initial G-code preview to these extrusions while reordering them at backend cause issues?
                    chain_and_reorder_extrusion_entities(temp_fill_extrusions, &m_last_pos);
                    const auto extrusion_name = ironing ? "ironing"sv : "infill"sv;
                    for (const ExtrusionEntity *fill : temp_fill_extrusions)
                        if (auto *eec = dynamic_cast<const ExtrusionEntityCollection*>(fill); eec) {
                            for (const ExtrusionEntity *ee : eec->chained_path_from(m_last_pos).entities)
                                gcode += this->extrude_entity(*ee, extrusion_name);
                        } else
                            gcode += this->extrude_entity(*fill, extrusion_name);
                }
            };
 
            //FIXME order islands?
            // Sequential tool path ordering of multiple parts within the same object, aka. perimeter tracking (#5511)
            for (const LayerIsland &island : lslice.islands) {
                auto process_perimeters = [&]() {
                    const LayerRegion &layerm = *layer->get_region(island.perimeters.region());
                    // PrintObjects own the PrintRegions, thus the pointer to PrintRegion would be unique to a PrintObject, they would not
                    // identify the content of PrintRegion accross the whole print uniquely. Translate to a Print specific PrintRegion.
                    const PrintRegion &region = print.get_print_region(layerm.region().print_region_id());
                    bool first = true;
                    for (uint32_t perimeter_id : island.perimeters) {
                        assert(dynamic_cast<const ExtrusionEntityCollection*>(layerm.perimeters().entities[perimeter_id]));
                        if (const auto *eec = static_cast<const ExtrusionEntityCollection*>(layerm.perimeters().entities[perimeter_id]);
                            shall_print_this_extrusion_collection(eec, region)) {
                            // This may not apply to Arachne, but maybe the Arachne gap fill should disable reverse as well?
                            // assert(! eec->can_reverse());
                            if (first) {
                                first = false;
                                init_layer_delayed();
                                m_config.apply(region.config());
                            }
                            for (const ExtrusionEntity *ee : *eec)
                                gcode += this->extrude_entity(*ee, comment_perimeter, -1.);
                        }
                    }
                };
                auto process_infill = [&]() {
                    for (auto it = island.fills.begin(); it != island.fills.end();) {
                        // Gather range of fill ranges with the same region.
                        auto it_end = it;
                        for (++ it_end; it_end != island.fills.end() && it->region() == it_end->region(); ++ it_end) ;
                        const LayerRegion &layerm = *layer->get_region(it->region());
                        extrude_infill_range(layerm, layerm.fills(), it, it_end, false /* normal extrusions, not ironing */);
                        it = it_end;
                    }
                };
                if (print.config().infill_first) {
                    process_infill();
                    process_perimeters();
                } else {
                    process_perimeters();
                    process_infill();
                }
            }
            // ironing
            //FIXME move ironing into the loop above over LayerIslands?
            // First Ironing changes extrusion rate quickly, second single ironing may be done over multiple perimeter regions.
            // Ironing in a second phase is safer, but it may be less efficient.
            for (const LayerIsland &island : lslice.islands) {
                for (auto it = island.fills.begin(); it != island.fills.end();) {
                    // Gather range of fill ranges with the same region.
                    auto it_end = it;
                    for (++ it_end; it_end != island.fills.end() && it->region() == it_end->region(); ++ it_end) ;
                    const LayerRegion &layerm = *layer->get_region(it->region());
                    extrude_infill_range(layerm, layerm.fills(), it, it_end, true /* ironing, not normal extrusions */);
                    it = it_end;
                }
            }
        }
    if (! first && this->config().gcode_label_objects)
        gcode += std::string("; stop printing object ") + print_object.model_object()->name + " id:" + std::to_string(object_id) + " copy " + std::to_string(print_instance.instance_id) + "\n";
}

References Slic3r::chain_and_reorder_extrusion_entities(), Slic3r::comment_perimeter, config(), Slic3r::PrintRegion::config(), Slic3r::PrintObject::config(), Slic3r::Print::config(), Slic3r::ExtrusionEntityCollection::entities, extrude_entity(), extrude_support(), Slic3r::LayerTools::extruder(), Slic3r::LayerTools::extruders, Slic3r::LayerRegion::fills(), Slic3r::WipingExtrusions::get_extruder_override(), Slic3r::Print::get_print_region(), Slic3r::Layer::get_region(), Slic3r::LayerTools::has_extruder(), Slic3r::Layer::id(), Slic3r::AvoidCrossingPerimeters::init_layer(), Slic3r::GCode::InstanceToPrint::instance_id, Slic3r::PrintObject::instances(), Slic3r::ExtrusionRole::Ironing, Slic3r::ironing(), Slic3r::ExtrusionRole::is_mixed(), Slic3r::ExtrusionRole::is_support_base(), Slic3r::ExtrusionRole::is_support_interface(), Slic3r::LayerSlice::islands, layer(), Slic3r::GCode::ObjectLayerToPrint::layer(), Slic3r::Layer::lslice_indices_sorted_by_print_order, Slic3r::Layer::lslices_ex, m_avoid_crossing_perimeters, m_config, m_extrusion_quality_estimator, m_last_obj_copy, m_last_pos, m_layer, m_object_layer_over_raft, Slic3r::ExtrusionRole::Mixed, Slic3r::PrintObjectBase::model_object(), Slic3r::ModelObject::name, Slic3r::GCode::ObjectLayerToPrint::object_layer, Slic3r::Print::objects(), Slic3r::offset(), Slic3r::LayerRegion::perimeters(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::print(), Slic3r::GCode::InstanceToPrint::print_object, Slic3r::PrintRegion::print_region_id(), Slic3r::SlicingParameters::raft_layers(), Slic3r::LayerRegion::region(), Slic3r::ExtrusionQualityEstimator::set_current_object(), set_origin(), Slic3r::PrintObject::slicing_parameters(), Slic3r::GCode::ObjectLayerToPrint::support_layer, Slic3r::ExtrusionRole::SupportMaterial, Slic3r::ExtrusionRole::SupportMaterialInterface, Slic3r::unscale(), Slic3r::AvoidCrossingPerimeters::use_external_mp_once(), and Slic3r::LayerTools::wiping_extrusions().

Referenced by process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_layers() [1/2]

void Slic3r::GCode::process_layers	(	const Print &	print,
		const ToolOrdering &	tool_ordering,
		const std::vector< const PrintInstance * > &	print_object_instances_ordering,
		const std::vector< std::pair< coordf_t, ObjectsLayerToPrint > > &	layers_to_print,
		GCodeOutputStream &	output_stream
	)

private

{
    // The pipeline is variable: The vase mode filter is optional.
    size_t layer_to_print_idx = 0;
    const auto generator = tbb::make_filter<void, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
        [this, &print, &tool_ordering, &print_object_instances_ordering, &layers_to_print, &layer_to_print_idx](tbb::flow_control& fc) -> LayerResult {
            if (layer_to_print_idx >= layers_to_print.size()) {
                if ((!m_pressure_equalizer && layer_to_print_idx == layers_to_print.size()) || (m_pressure_equalizer && layer_to_print_idx == (layers_to_print.size() + 1))) {
                    fc.stop();
                    return {};
                } else {
                    // Pressure equalizer need insert empty input. Because it returns one layer back.
                    // Insert NOP (no operation) layer;
                    ++layer_to_print_idx;
                    return LayerResult::make_nop_layer_result();
                }
            } else {
                const std::pair<coordf_t, ObjectsLayerToPrint> &layer = layers_to_print[layer_to_print_idx++];
                const LayerTools& layer_tools = tool_ordering.tools_for_layer(layer.first);
                if (m_wipe_tower && layer_tools.has_wipe_tower)
                    m_wipe_tower->next_layer();
                print.throw_if_canceled();
                return this->process_layer(print, layer.second, layer_tools, &layer == &layers_to_print.back(), &print_object_instances_ordering, size_t(-1));
            }
        });
    const auto spiral_vase = tbb::make_filter<LayerResult, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
        [spiral_vase = this->m_spiral_vase.get()](LayerResult in) -> LayerResult {
            if (in.nop_layer_result)
                return in;
 
            spiral_vase->enable(in.spiral_vase_enable);
            return { spiral_vase->process_layer(std::move(in.gcode)), in.layer_id, in.spiral_vase_enable, in.cooling_buffer_flush};
        });
    const auto pressure_equalizer = tbb::make_filter<LayerResult, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
        [pressure_equalizer = this->m_pressure_equalizer.get()](LayerResult in) -> LayerResult {
            return pressure_equalizer->process_layer(std::move(in));
        });
    const auto cooling = tbb::make_filter<LayerResult, std::string>(slic3r_tbb_filtermode::serial_in_order,
        [cooling_buffer = this->m_cooling_buffer.get()](LayerResult in) -> std::string {
             if (in.nop_layer_result)
                return in.gcode;
 
             return cooling_buffer->process_layer(std::move(in.gcode), in.layer_id, in.cooling_buffer_flush);
        });
    const auto find_replace = tbb::make_filter<std::string, std::string>(slic3r_tbb_filtermode::serial_in_order,
        [find_replace = this->m_find_replace.get()](std::string s) -> std::string {
            return find_replace->process_layer(std::move(s));
        });
    const auto output = tbb::make_filter<std::string, void>(slic3r_tbb_filtermode::serial_in_order,
        [&output_stream](std::string s) { output_stream.write(s); }
    );
 
    // It registers a handler that sets locales to "C" before any TBB thread starts participating in tbb::parallel_pipeline.
    // Handler is unregistered when the destructor is called.
    TBBLocalesSetter locales_setter;
 
    // The pipeline elements are joined using const references, thus no copying is performed.
    output_stream.find_replace_supress();
    if (m_spiral_vase && m_find_replace && m_pressure_equalizer)
        tbb::parallel_pipeline(12, generator & spiral_vase & pressure_equalizer & cooling & find_replace & output);
    else if (m_spiral_vase && m_find_replace)
        tbb::parallel_pipeline(12, generator & spiral_vase &                      cooling & find_replace & output);
    else if (m_spiral_vase && m_pressure_equalizer)
        tbb::parallel_pipeline(12, generator & spiral_vase & pressure_equalizer & cooling &                output);
    else if (m_find_replace && m_pressure_equalizer)
        tbb::parallel_pipeline(12, generator &               pressure_equalizer & cooling & find_replace & output);
    else if (m_spiral_vase)
        tbb::parallel_pipeline(12, generator & spiral_vase &                      cooling &                output);
    else if (m_find_replace)
        tbb::parallel_pipeline(12, generator &                                    cooling & find_replace & output);
    else if (m_pressure_equalizer)
        tbb::parallel_pipeline(12, generator &               pressure_equalizer & cooling &                output);
    else
        tbb::parallel_pipeline(12, generator &                                    cooling &                output);
    output_stream.find_replace_enable();
}

References Slic3r::LayerTools::has_wipe_tower, layer(), m_wipe_tower, process_layer(), Slic3r::PrintBase::throw_if_canceled(), and Slic3r::ToolOrdering::tools_for_layer().

Referenced by _do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_layers() [2/2]

void Slic3r::GCode::process_layers	(	const Print &	print,
		const ToolOrdering &	tool_ordering,
		ObjectsLayerToPrint	layers_to_print,
		const size_t	single_object_idx,
		GCodeOutputStream &	output_stream
	)

private

{
    // The pipeline is variable: The vase mode filter is optional.
    size_t layer_to_print_idx = 0;
    const auto generator = tbb::make_filter<void, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
        [this, &print, &tool_ordering, &layers_to_print, &layer_to_print_idx, single_object_idx](tbb::flow_control& fc) -> LayerResult {
            if (layer_to_print_idx >= layers_to_print.size()) {
                if ((!m_pressure_equalizer && layer_to_print_idx == layers_to_print.size()) || (m_pressure_equalizer && layer_to_print_idx == (layers_to_print.size() + 1))) {
                    fc.stop();
                    return {};
                } else {
                    // Pressure equalizer need insert empty input. Because it returns one layer back.
                    // Insert NOP (no operation) layer;
                    ++layer_to_print_idx;
                    return LayerResult::make_nop_layer_result();
                }
            } else {
                ObjectLayerToPrint &layer = layers_to_print[layer_to_print_idx ++];
                print.throw_if_canceled();
                return this->process_layer(print, { std::move(layer) }, tool_ordering.tools_for_layer(layer.print_z()), &layer == &layers_to_print.back(), nullptr, single_object_idx);
            }
        });
    const auto spiral_vase = tbb::make_filter<LayerResult, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
        [spiral_vase = this->m_spiral_vase.get()](LayerResult in)->LayerResult {
            if (in.nop_layer_result)
                return in;
            spiral_vase->enable(in.spiral_vase_enable);
            return { spiral_vase->process_layer(std::move(in.gcode)), in.layer_id, in.spiral_vase_enable, in.cooling_buffer_flush };
        });
    const auto pressure_equalizer = tbb::make_filter<LayerResult, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
        [pressure_equalizer = this->m_pressure_equalizer.get()](LayerResult in) -> LayerResult {
             return pressure_equalizer->process_layer(std::move(in));
        });
    const auto cooling = tbb::make_filter<LayerResult, std::string>(slic3r_tbb_filtermode::serial_in_order,
        [cooling_buffer = this->m_cooling_buffer.get()](LayerResult in)->std::string {
            if (in.nop_layer_result)
                return in.gcode;
            return cooling_buffer->process_layer(std::move(in.gcode), in.layer_id, in.cooling_buffer_flush);
        });
    const auto find_replace = tbb::make_filter<std::string, std::string>(slic3r_tbb_filtermode::serial_in_order,
        [find_replace = this->m_find_replace.get()](std::string s) -> std::string {
            return find_replace->process_layer(std::move(s));
        });
    const auto output = tbb::make_filter<std::string, void>(slic3r_tbb_filtermode::serial_in_order,
        [&output_stream](std::string s) { output_stream.write(s); }
    );
 
    // It registers a handler that sets locales to "C" before any TBB thread starts participating in tbb::parallel_pipeline.
    // Handler is unregistered when the destructor is called.
    TBBLocalesSetter locales_setter;
 
    // The pipeline elements are joined using const references, thus no copying is performed.
    output_stream.find_replace_supress();
    if (m_spiral_vase && m_find_replace && m_pressure_equalizer)
        tbb::parallel_pipeline(12, generator & spiral_vase & pressure_equalizer & cooling & find_replace & output);
    else if (m_spiral_vase && m_find_replace)
        tbb::parallel_pipeline(12, generator & spiral_vase &                      cooling & find_replace & output);
    else if (m_spiral_vase && m_pressure_equalizer)
        tbb::parallel_pipeline(12, generator & spiral_vase & pressure_equalizer & cooling &                output);
    else if (m_find_replace && m_pressure_equalizer)
        tbb::parallel_pipeline(12, generator &               pressure_equalizer & cooling & find_replace & output);
    else if (m_spiral_vase)
        tbb::parallel_pipeline(12, generator & spiral_vase &                      cooling &                output);
    else if (m_find_replace)
        tbb::parallel_pipeline(12, generator &                                    cooling & find_replace & output);
    else if (m_pressure_equalizer)
        tbb::parallel_pipeline(12, generator &               pressure_equalizer & cooling &                output);
    else
        tbb::parallel_pipeline(12, generator &                                    cooling &                output);
    output_stream.find_replace_enable();
}

References layer(), Slic3r::Layer::print_z, process_layer(), Slic3r::PrintBase::throw_if_canceled(), and Slic3r::ToolOrdering::tools_for_layer().

Here is the call graph for this function:

◆ retract()

std::string Slic3r::GCode::retract ( bool toolchange = false )

private

{
    std::string gcode;
 
    if (m_writer.extruder() == nullptr)
        return gcode;
 
    // wipe (if it's enabled for this extruder and we have a stored wipe path)
    if (EXTRUDER_CONFIG(wipe) && m_wipe.has_path()) {
        gcode += toolchange ? m_writer.retract_for_toolchange(true) : m_writer.retract(true);
        gcode += m_wipe.wipe(*this, toolchange);
    }
 
    /*  The parent class will decide whether we need to perform an actual retraction
        (the extruder might be already retracted fully or partially). We call these
        methods even if we performed wipe, since this will ensure the entire retraction
        length is honored in case wipe path was too short.  */
    gcode += toolchange ? m_writer.retract_for_toolchange() : m_writer.retract();
 
    gcode += m_writer.reset_e();
    if (m_writer.extruder()->retract_length() > 0 || m_config.use_firmware_retraction)
        gcode += m_writer.lift();
 
    return gcode;
}

References Slic3r::GCodeWriter::extruder(), EXTRUDER_CONFIG, Slic3r::Wipe::has_path(), Slic3r::GCodeWriter::lift(), m_config, m_wipe, m_writer, Slic3r::GCodeWriter::reset_e(), Slic3r::GCodeWriter::retract(), Slic3r::GCodeWriter::retract_for_toolchange(), Slic3r::Extruder::retract_length(), and Slic3r::Wipe::wipe().

Referenced by _do_export(), Slic3r::WipeTowerIntegration::append_tcr(), change_layer(), set_extruder(), and travel_to().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_extruder()

std::string Slic3r::GCode::set_extruder	(	unsigned int	extruder_id,
		double	print_z
	)

private

{
    if (!m_writer.need_toolchange(extruder_id))
        return "";
 
    // if we are running a single-extruder setup, just set the extruder and return nothing
    if (!m_writer.multiple_extruders) {
        this->placeholder_parser().set("current_extruder", extruder_id);
 
        std::string gcode;
        // Append the filament start G-code.
        const std::string &start_filament_gcode = m_config.start_filament_gcode.get_at(extruder_id);
        if (! start_filament_gcode.empty()) {
            // Process the start_filament_gcode for the filament.
            DynamicConfig config;
            config.set_key_value("layer_num", new ConfigOptionInt(m_layer_index));
            config.set_key_value("layer_z",   new ConfigOptionFloat(this->writer().get_position().z() - m_config.z_offset.value));
            config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
            config.set_key_value("filament_extruder_id", new ConfigOptionInt(int(extruder_id)));
            gcode += this->placeholder_parser_process("start_filament_gcode", start_filament_gcode, extruder_id, &config);
            check_add_eol(gcode);
        }
        gcode += m_writer.toolchange(extruder_id);
        return gcode;
    }
 
    // prepend retraction on the current extruder
    std::string gcode = this->retract(true);
 
    // Always reset the extrusion path, even if the tool change retract is set to zero.
    m_wipe.reset_path();
 
    if (m_writer.extruder() != nullptr) {
        // Process the custom end_filament_gcode.
        unsigned int        old_extruder_id     = m_writer.extruder()->id();
        const std::string  &end_filament_gcode  = m_config.end_filament_gcode.get_at(old_extruder_id);
        if (! end_filament_gcode.empty()) {
            gcode += placeholder_parser_process("end_filament_gcode", end_filament_gcode, old_extruder_id);
            check_add_eol(gcode);
        }
    }
 
 
    // If ooze prevention is enabled, set current extruder to the standby temperature.
    if (m_ooze_prevention.enable && m_writer.extruder() != nullptr)
        gcode += m_ooze_prevention.pre_toolchange(*this);
 
    const std::string& toolchange_gcode = m_config.toolchange_gcode.value;
    std::string toolchange_gcode_parsed;
 
    // Process the custom toolchange_gcode. If it is empty, insert just a Tn command.
    if (!toolchange_gcode.empty()) {
        DynamicConfig config;
        config.set_key_value("previous_extruder", new ConfigOptionInt((int)(m_writer.extruder() != nullptr ? m_writer.extruder()->id() : -1 )));
        config.set_key_value("next_extruder",     new ConfigOptionInt((int)extruder_id));
        config.set_key_value("layer_num",         new ConfigOptionInt(m_layer_index));
        config.set_key_value("layer_z",           new ConfigOptionFloat(print_z));
        config.set_key_value("toolchange_z",      new ConfigOptionFloat(print_z));
        config.set_key_value("max_layer_z",       new ConfigOptionFloat(m_max_layer_z));
        toolchange_gcode_parsed = placeholder_parser_process("toolchange_gcode", toolchange_gcode, extruder_id, &config);
        gcode += toolchange_gcode_parsed;
        check_add_eol(gcode);
    }
 
    // We inform the writer about what is happening, but we may not use the resulting gcode.
    std::string toolchange_command = m_writer.toolchange(extruder_id);
    if (! custom_gcode_changes_tool(toolchange_gcode_parsed, m_writer.toolchange_prefix(), extruder_id))
        gcode += toolchange_command;
    else {
        // user provided his own toolchange gcode, no need to do anything
    }
 
    // Set the temperature if the wipe tower didn't (not needed for non-single extruder MM)
    if (m_config.single_extruder_multi_material && !m_config.wipe_tower) {
        int temp = (m_layer_index <= 0 ? m_config.first_layer_temperature.get_at(extruder_id) :
                                         m_config.temperature.get_at(extruder_id));
 
        gcode += m_writer.set_temperature(temp, false);
    }
 
    this->placeholder_parser().set("current_extruder", extruder_id);
 
    // Append the filament start G-code.
    const std::string &start_filament_gcode = m_config.start_filament_gcode.get_at(extruder_id);
    if (! start_filament_gcode.empty()) {
        // Process the start_filament_gcode for the new filament.
        DynamicConfig config;
        config.set_key_value("layer_num", new ConfigOptionInt(m_layer_index));
        config.set_key_value("layer_z",   new ConfigOptionFloat(this->writer().get_position().z() - m_config.z_offset.value));
        config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
        config.set_key_value("filament_extruder_id", new ConfigOptionInt(int(extruder_id)));
        gcode += this->placeholder_parser_process("start_filament_gcode", start_filament_gcode, extruder_id, &config);
        check_add_eol(gcode);
    }
    // Set the new extruder to the operating temperature.
    if (m_ooze_prevention.enable)
        gcode += m_ooze_prevention.post_toolchange(*this);
 
    return gcode;
}

References Slic3r::check_add_eol(), config(), Slic3r::custom_gcode_changes_tool(), Slic3r::OozePrevention::enable, Slic3r::GCodeWriter::extruder(), Slic3r::Extruder::id(), m_config, m_layer_index, m_max_layer_z, m_ooze_prevention, m_wipe, m_writer, Slic3r::GCodeWriter::multiple_extruders, Slic3r::GCodeWriter::need_toolchange(), placeholder_parser(), placeholder_parser_process(), Slic3r::OozePrevention::post_toolchange(), Slic3r::OozePrevention::pre_toolchange(), Slic3r::Wipe::reset_path(), retract(), Slic3r::PlaceholderParser::set(), Slic3r::GCodeWriter::set_temperature(), Slic3r::start_filament_gcode(), Slic3r::GCodeWriter::toolchange(), Slic3r::toolchange_gcode(), Slic3r::GCodeWriter::toolchange_prefix(), and writer().

Referenced by _do_export(), Slic3r::WipeTowerIntegration::append_tcr(), and process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_extruders()

void Slic3r::GCode::set_extruders ( const std::vector< unsigned int > & extruder_ids )

private

{
    m_writer.set_extruders(extruder_ids);
 
    // enable wipe path generation if any extruder has wipe enabled
    m_wipe.enable = false;
    for (auto id : extruder_ids)
        if (m_config.wipe.get_at(id)) {
            m_wipe.enable = true;
            break;
        }
}

References Slic3r::Wipe::enable, m_config, m_wipe, m_writer, and Slic3r::GCodeWriter::set_extruders().

Referenced by _do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_last_pos()

void Slic3r::GCode::set_last_pos ( const Point & pos )

inlineprivate

278{ m_last_pos = pos; m_last_pos_defined = true; }

References m_last_pos, and m_last_pos_defined.

Referenced by _extrude(), Slic3r::WipeTowerIntegration::append_tcr(), placeholder_parser_process(), travel_to(), and Slic3r::Wipe::wipe().

Here is the caller graph for this function:

◆ set_layer_count()

void Slic3r::GCode::set_layer_count ( unsigned int value )

inline

185{ m_layer_count = value; }

References m_layer_count.

◆ set_origin() [1/2]

void Slic3r::GCode::set_origin	(	const coordf_t	x,
		const coordf_t	y
	)

inline

165{ this->set_origin(Vec2d(x, y)); }

References set_origin().

Referenced by set_origin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_origin() [2/2]

void Slic3r::GCode::set_origin ( const Vec2d & pointf )

{
    // if origin increases (goes towards right), last_pos decreases because it goes towards left
    const Point translate(
        scale_(m_origin(0) - pointf(0)),
        scale_(m_origin(1) - pointf(1))
    );
    m_last_pos += translate;
    m_wipe.path.translate(translate);
    m_origin = pointf;
}

References m_last_pos, m_origin, m_wipe, Slic3r::Wipe::path, scale_, and Slic3r::MultiPoint::translate().

Referenced by _do_export(), process_layer(), and process_layer_single_object().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sort_print_object_instances()

std::vector< GCode::InstanceToPrint > Slic3r::GCode::sort_print_object_instances	(	const std::vector< ObjectLayerToPrint > &	layers,
		const std::vector< const PrintInstance * > *	ordering,
		const size_t	single_object_instance_idx
	)

private

{
    std::vector<InstanceToPrint> out;
 
    if (ordering == nullptr) {
        // Sequential print, single object is being printed.
        assert(object_layers.size() == 1);
        out.emplace_back(0, *object_layers.front().object(), single_object_instance_idx);
    } else {
        // Create mapping from PrintObject* to ObjectLayerToPrint ID.
        std::vector<std::pair<const PrintObject*, size_t>> sorted;
        sorted.reserve(object_layers.size());
        for (const ObjectLayerToPrint &object : object_layers)
            if (const PrintObject* print_object = object.object(); print_object)
                sorted.emplace_back(print_object, &object - object_layers.data());
        std::sort(sorted.begin(), sorted.end());
 
        if (! sorted.empty()) {
            out.reserve(sorted.size());
            for (const PrintInstance *instance : *ordering) {
                const PrintObject &print_object = *instance->print_object;
                std::pair<const PrintObject*, size_t> key(&print_object, 0);
                auto it = std::lower_bound(sorted.begin(), sorted.end(), key);
                if (it != sorted.end() && it->first == &print_object)
                    // ObjectLayerToPrint for this PrintObject was found.
                    out.emplace_back(it->second, print_object, instance - print_object.instances().data());
            }
        }
    }
    return out;
}

References Slic3r::PrintObject::instances(), and ordering.

Referenced by process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ travel_to()

std::string Slic3r::GCode::travel_to	(	const Point &	point,
		ExtrusionRole	role,
		std::string	comment
	)

private

{
    /*  Define the travel move as a line between current position and the taget point.
        This is expressed in print coordinates, so it will need to be translated by
        this->origin in order to get G-code coordinates.  */
    Polyline travel { this->last_pos(), point };
 
    if (this->config().avoid_crossing_curled_overhangs) {
        if (m_config.avoid_crossing_perimeters) {
            BOOST_LOG_TRIVIAL(warning)
                << "Option >avoid crossing curled overhangs< is not compatible with avoid crossing perimeters and it will be ignored!";
        } else {
            Point scaled_origin = Point(scaled(this->origin()));
            travel              = m_avoid_crossing_curled_overhangs.find_path(this->last_pos() + scaled_origin, point + scaled_origin);
            travel.translate(-scaled_origin);
        }
    }
 
    // check whether a straight travel move would need retraction
    bool needs_retraction             = this->needs_retraction(travel, role);
    // check whether wipe could be disabled without causing visible stringing
    bool could_be_wipe_disabled       = false;
    // Save state of use_external_mp_once for the case that will be needed to call twice m_avoid_crossing_perimeters.travel_to.
    const bool used_external_mp_once  = m_avoid_crossing_perimeters.used_external_mp_once();
 
    // if a retraction would be needed, try to use avoid_crossing_perimeters to plan a
    // multi-hop travel path inside the configuration space
    if (needs_retraction
        && m_config.avoid_crossing_perimeters
        && ! m_avoid_crossing_perimeters.disabled_once()) {
        travel = m_avoid_crossing_perimeters.travel_to(*this, point, &could_be_wipe_disabled);
        // check again whether the new travel path still needs a retraction
        needs_retraction = this->needs_retraction(travel, role);
        //if (needs_retraction && m_layer_index > 1) exit(0);
    }
 
    // Re-allow avoid_crossing_perimeters for the next travel moves
    m_avoid_crossing_perimeters.reset_once_modifiers();
 
    // generate G-code for the travel move
    std::string gcode;
    if (needs_retraction) {
        if (m_config.avoid_crossing_perimeters && could_be_wipe_disabled)
            m_wipe.reset_path();
 
        Point last_post_before_retract = this->last_pos();
        gcode += this->retract();
        // When "Wipe while retracting" is enabled, then extruder moves to another position, and travel from this position can cross perimeters.
        // Because of it, it is necessary to call avoid crossing perimeters again with new starting point after calling retraction()
        // FIXME Lukas H.: Try to predict if this second calling of avoid crossing perimeters will be needed or not. It could save computations.
        if (last_post_before_retract != this->last_pos() && m_config.avoid_crossing_perimeters) {
            // If in the previous call of m_avoid_crossing_perimeters.travel_to was use_external_mp_once set to true restore this value for next call.
            if (used_external_mp_once)
                m_avoid_crossing_perimeters.use_external_mp_once();
            travel = m_avoid_crossing_perimeters.travel_to(*this, point);
            // If state of use_external_mp_once was changed reset it to right value.
            if (used_external_mp_once)
                m_avoid_crossing_perimeters.reset_once_modifiers();
        }
    } else
        // Reset the wipe path when traveling, so one would not wipe along an old path.
        m_wipe.reset_path();
 
    // use G1 because we rely on paths being straight (G0 may make round paths)
    if (travel.size() >= 2) {
 
        gcode += m_writer.set_travel_acceleration((unsigned int)(m_config.travel_acceleration.value + 0.5));
 
        for (size_t i = 1; i < travel.size(); ++ i)
            gcode += m_writer.travel_to_xy(this->point_to_gcode(travel.points[i]), comment);
 
        if (! GCodeWriter::supports_separate_travel_acceleration(config().gcode_flavor)) {
            // In case that this flavor does not support separate print and travel acceleration,
            // reset acceleration to default.
            gcode += m_writer.set_travel_acceleration((unsigned int)(m_config.travel_acceleration.value + 0.5));
        }
 
        this->set_last_pos(travel.points.back());
    }
    return gcode;
}