#include <src/libslic3r/GCode/GCodeProcessor.hpp>

Collaboration diagram for Slic3r::GCodeProcessor:

Classes
struct	CachedPosition

struct	CpColor

struct	FeedMultiply

struct	FeedrateProfile

class	OptionsZCorrector

class	SeamsDetector

struct	TimeBlock

struct	TimeMachine

struct	TimeProcessor

struct	Trapezoid

struct	UsedFilaments

Public Types
enum class	ETags : unsigned char { Role , Wipe_Start , Wipe_End , Height , Width , Layer_Change , Color_Change , Pause_Print , Custom_Code , First_Line_M73_Placeholder , Last_Line_M73_Placeholder , Estimated_Printing_Time_Placeholder }

Public Member Functions
	GCodeProcessor ()

void	apply_config (const PrintConfig &config)

void	set_print (Print *print)

void	enable_stealth_time_estimator (bool enabled)

bool	is_stealth_time_estimator_enabled () const

void	enable_machine_envelope_processing (bool enabled)

void	reset ()

const GCodeProcessorResult &	get_result () const

GCodeProcessorResult &&	extract_result ()

void	process_file (const std::string &filename, std::function< void()> cancel_callback=nullptr)

void	initialize (const std::string &filename)

void	initialize_result_moves ()

void	process_buffer (const std::string &buffer)

void	finalize (bool post_process)

float	get_time (PrintEstimatedStatistics::ETimeMode mode) const

std::string	get_time_dhm (PrintEstimatedStatistics::ETimeMode mode) const

float	get_travel_time (PrintEstimatedStatistics::ETimeMode mode) const

std::string	get_travel_time_dhm (PrintEstimatedStatistics::ETimeMode mode) const

std::vector< std::pair< CustomGCode::Type, std::pair< float, float > > >	get_custom_gcode_times (PrintEstimatedStatistics::ETimeMode mode, bool include_remaining) const

std::vector< std::pair< EMoveType, float > >	get_moves_time (PrintEstimatedStatistics::ETimeMode mode) const

std::vector< std::pair< GCodeExtrusionRole, float > >	get_roles_time (PrintEstimatedStatistics::ETimeMode mode) const

std::vector< float >	get_layers_time (PrintEstimatedStatistics::ETimeMode mode) const

Static Public Member Functions
static const std::string &	reserved_tag (ETags tag)

static bool	contains_reserved_tag (const std::string &gcode, std::string &found_tag)

static bool	contains_reserved_tags (const std::string &gcode, unsigned int max_count, std::vector< std::string > &found_tag)

Static Public Attributes
static const float	Wipe_Width = 0.05f

static const float	Wipe_Height = 0.05f

Private Types
enum class	EUnits : unsigned char { Millimeters , Inches }

enum class	EPositioningType : unsigned char { Absolute , Relative }

enum class	EProducer { Unknown , PrusaSlicer , Slic3rPE , Slic3r , SuperSlicer , Cura , Simplify3D , CraftWare , ideaMaker , KissSlicer , BambuStudio }

using	AxisCoords = std::array< double, 4 >

using	ExtruderColors = std::vector< unsigned char >

using	ExtruderTemps = std::vector< float >

Private Member Functions
void	apply_config (const DynamicPrintConfig &config)

void	apply_config_simplify3d (const std::string &filename)

void	apply_config_superslicer (const std::string &filename)

void	apply_config_kissslicer (const std::string &filename)

void	process_gcode_line (const GCodeReader::GCodeLine &line, bool producers_enabled)

void	process_tags (const std::string_view comment, bool producers_enabled)

bool	process_producers_tags (const std::string_view comment)

bool	process_prusaslicer_tags (const std::string_view comment)

bool	process_cura_tags (const std::string_view comment)

bool	process_simplify3d_tags (const std::string_view comment)

bool	process_craftware_tags (const std::string_view comment)

bool	process_ideamaker_tags (const std::string_view comment)

bool	process_kissslicer_tags (const std::string_view comment)

bool	process_bambustudio_tags (const std::string_view comment)

bool	detect_producer (const std::string_view comment)

void	process_G0 (const GCodeReader::GCodeLine &line)

void	process_G1 (const GCodeReader::GCodeLine &line)

void	process_G1 (const std::array< std::optional< double >, 4 > &axes={ std::nullopt, std::nullopt, std::nullopt, std::nullopt }, std::optional< double > feedrate=std::nullopt, std::optional< std::string > cmt=std::nullopt)

void	process_G2_G3 (const GCodeReader::GCodeLine &line, bool clockwise)

void	process_G10 (const GCodeReader::GCodeLine &line)

void	process_G11 (const GCodeReader::GCodeLine &line)

void	process_G20 (const GCodeReader::GCodeLine &line)

void	process_G21 (const GCodeReader::GCodeLine &line)

void	process_G22 (const GCodeReader::GCodeLine &line)

void	process_G23 (const GCodeReader::GCodeLine &line)

void	process_G28 (const GCodeReader::GCodeLine &line)

void	process_G60 (const GCodeReader::GCodeLine &line)

void	process_G61 (const GCodeReader::GCodeLine &line)

void	process_G90 (const GCodeReader::GCodeLine &line)

void	process_G91 (const GCodeReader::GCodeLine &line)

void	process_G92 (const GCodeReader::GCodeLine &line)

void	process_M1 (const GCodeReader::GCodeLine &line)

void	process_M82 (const GCodeReader::GCodeLine &line)

void	process_M83 (const GCodeReader::GCodeLine &line)

void	process_M104 (const GCodeReader::GCodeLine &line)

void	process_M106 (const GCodeReader::GCodeLine &line)

void	process_M107 (const GCodeReader::GCodeLine &line)

void	process_M108 (const GCodeReader::GCodeLine &line)

void	process_M109 (const GCodeReader::GCodeLine &line)

void	process_M132 (const GCodeReader::GCodeLine &line)

void	process_M135 (const GCodeReader::GCodeLine &line)

void	process_M201 (const GCodeReader::GCodeLine &line)

void	process_M203 (const GCodeReader::GCodeLine &line)

void	process_M204 (const GCodeReader::GCodeLine &line)

void	process_M205 (const GCodeReader::GCodeLine &line)

void	process_M220 (const GCodeReader::GCodeLine &line)

void	process_M221 (const GCodeReader::GCodeLine &line)

void	process_M401 (const GCodeReader::GCodeLine &line)

void	process_M402 (const GCodeReader::GCodeLine &line)

void	process_M566 (const GCodeReader::GCodeLine &line)

void	process_M702 (const GCodeReader::GCodeLine &line)

void	process_T (const GCodeReader::GCodeLine &line)

void	process_T (const std::string_view command)

void	post_process ()

void	store_move_vertex (EMoveType type, bool internal_only=false)

void	set_extrusion_role (GCodeExtrusionRole role)

float	minimum_feedrate (PrintEstimatedStatistics::ETimeMode mode, float feedrate) const

float	minimum_travel_feedrate (PrintEstimatedStatistics::ETimeMode mode, float feedrate) const

float	get_axis_max_feedrate (PrintEstimatedStatistics::ETimeMode mode, Axis axis) const

float	get_axis_max_acceleration (PrintEstimatedStatistics::ETimeMode mode, Axis axis) const

float	get_axis_max_jerk (PrintEstimatedStatistics::ETimeMode mode, Axis axis) const

float	get_retract_acceleration (PrintEstimatedStatistics::ETimeMode mode) const

void	set_retract_acceleration (PrintEstimatedStatistics::ETimeMode mode, float value)

float	get_acceleration (PrintEstimatedStatistics::ETimeMode mode) const

void	set_acceleration (PrintEstimatedStatistics::ETimeMode mode, float value)

float	get_travel_acceleration (PrintEstimatedStatistics::ETimeMode mode) const

void	set_travel_acceleration (PrintEstimatedStatistics::ETimeMode mode, float value)

float	get_filament_load_time (size_t extruder_id)

float	get_filament_unload_time (size_t extruder_id)

void	process_custom_gcode_time (CustomGCode::Type code)

void	process_filaments (CustomGCode::Type code)

void	simulate_st_synchronize (float additional_time=0.0f)

void	update_estimated_times_stats ()

double	extract_absolute_position_on_axis (Axis axis, const GCodeReader::GCodeLine &line, double area_filament_cross_section)

Private Attributes
GCodeReader	m_parser

EUnits	m_units

EPositioningType	m_global_positioning_type

EPositioningType	m_e_local_positioning_type

std::vector< Vec3f >	m_extruder_offsets

GCodeFlavor	m_flavor

AxisCoords	m_start_position

AxisCoords	m_end_position

AxisCoords	m_saved_position

AxisCoords	m_origin

CachedPosition	m_cached_position

bool	m_wiping

unsigned int	m_line_id

unsigned int	m_last_line_id

float	m_feedrate

FeedMultiply	m_feed_multiply

float	m_width

float	m_height

float	m_forced_width

float	m_forced_height

float	m_mm3_per_mm

float	m_fan_speed

float	m_z_offset

GCodeExtrusionRole	m_extrusion_role

unsigned char	m_extruder_id

ExtruderColors	m_extruder_colors

ExtruderTemps	m_extruder_temps

ExtruderTemps	m_extruder_temps_config

ExtruderTemps	m_extruder_temps_first_layer_config

bool	m_is_XL_printer = false

float	m_parking_position

float	m_extra_loading_move

float	m_extruded_last_z

float	m_first_layer_height

unsigned int	m_g1_line_id

unsigned int	m_layer_id

CpColor	m_cp_color

bool	m_use_volumetric_e

SeamsDetector	m_seams_detector

OptionsZCorrector	m_options_z_corrector

size_t	m_last_default_color_id

bool	m_spiral_vase_active

float	m_kissslicer_toolchange_time_correction

bool	m_single_extruder_multi_material

EProducer	m_producer

TimeProcessor	m_time_processor

UsedFilaments	m_used_filaments

Print *	m_print { nullptr }

GCodeProcessorResult	m_result

Static Private Attributes
static const std::vector< std::string >	Reserved_Tags

static const std::vector< std::pair< GCodeProcessor::EProducer, std::string > >	Producers

static unsigned int	s_result_id = 0

Detailed Description

Class Documentation

◆ Slic3r::GCodeProcessor::FeedrateProfile

struct Slic3r::GCodeProcessor::FeedrateProfile

Class Members
float	cruise { 0.0f }
float	entry { 0.0f }
float	exit { 0.0f }

Member Typedef Documentation

◆ AxisCoords

using Slic3r::GCodeProcessor::AxisCoords = std::array<double, 4>

private

◆ ExtruderColors

using Slic3r::GCodeProcessor::ExtruderColors = std::vector<unsigned char>

private

◆ ExtruderTemps

using Slic3r::GCodeProcessor::ExtruderTemps = std::vector<float>

private

Member Enumeration Documentation

◆ EPositioningType

enum class Slic3r::GCodeProcessor::EPositioningType : unsigned char

strongprivate

Enumerator
Absolute
Relative

        {
            Absolute,
            Relative
        };

◆ EProducer

enum class Slic3r::GCodeProcessor::EProducer

strongprivate

Enumerator
Unknown
PrusaSlicer
Slic3rPE
Slic3r
SuperSlicer
Cura
Simplify3D
CraftWare
ideaMaker
KissSlicer
BambuStudio

        {
            Unknown,
            PrusaSlicer,
            Slic3rPE,
            Slic3r,
            SuperSlicer,
            Cura,
            Simplify3D,
            CraftWare,
            ideaMaker,
            KissSlicer,
            BambuStudio
        };

◆ ETags

enum class Slic3r::GCodeProcessor::ETags : unsigned char

strong

Enumerator
Role
Wipe_Start
Wipe_End
Height
Width
Layer_Change
Color_Change
Pause_Print
Custom_Code
First_Line_M73_Placeholder
Last_Line_M73_Placeholder
Estimated_Printing_Time_Placeholder

        {
            Role,
            Wipe_Start,
            Wipe_End,
            Height,
            Width,
            Layer_Change,
            Color_Change,
            Pause_Print,
            Custom_Code,
            First_Line_M73_Placeholder,
            Last_Line_M73_Placeholder,
            Estimated_Printing_Time_Placeholder
        };

◆ EUnits

enum class Slic3r::GCodeProcessor::EUnits : unsigned char

strongprivate

Enumerator
Millimeters
Inches

        {
            Millimeters,
            Inches
        };

Constructor & Destructor Documentation

◆ GCodeProcessor()

Slic3r::GCodeProcessor::GCodeProcessor ( )

: m_options_z_corrector(m_result)
{
    reset();
    m_time_processor.machines[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Normal)].line_m73_main_mask = "M73 P%s R%s\n";
    m_time_processor.machines[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Normal)].line_m73_stop_mask = "M73 C%s\n";
    m_time_processor.machines[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Stealth)].line_m73_main_mask = "M73 Q%s S%s\n";
    m_time_processor.machines[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Stealth)].line_m73_stop_mask = "M73 D%s\n";
}

References m_time_processor, Slic3r::GCodeProcessor::TimeProcessor::machines, Slic3r::PrintEstimatedStatistics::Normal, reset(), and Slic3r::PrintEstimatedStatistics::Stealth.

Here is the call graph for this function:

Member Function Documentation

◆ apply_config() [1/2]

void Slic3r::GCodeProcessor::apply_config ( const DynamicPrintConfig & config )

private

{
    m_parser.apply_config(config);
 
    const ConfigOptionEnum<GCodeFlavor>* gcode_flavor = config.option<ConfigOptionEnum<GCodeFlavor>>("gcode_flavor");
    if (gcode_flavor != nullptr)
        m_flavor = gcode_flavor->value;
 
    const ConfigOptionPoints* bed_shape = config.option<ConfigOptionPoints>("bed_shape");
    if (bed_shape != nullptr)
        m_result.bed_shape = bed_shape->values;
 
    const ConfigOptionString* print_settings_id = config.option<ConfigOptionString>("print_settings_id");
    if (print_settings_id != nullptr)
        m_result.settings_ids.print = print_settings_id->value;
 
    const ConfigOptionStrings* filament_settings_id = config.option<ConfigOptionStrings>("filament_settings_id");
    if (filament_settings_id != nullptr)
        m_result.settings_ids.filament = filament_settings_id->values;
 
    const ConfigOptionString* printer_settings_id = config.option<ConfigOptionString>("printer_settings_id");
    if (printer_settings_id != nullptr)
        m_result.settings_ids.printer = printer_settings_id->value;
 
    m_result.extruders_count = config.option<ConfigOptionFloats>("nozzle_diameter")->values.size();
 
    const ConfigOptionFloats* filament_diameters = config.option<ConfigOptionFloats>("filament_diameter");
    if (filament_diameters != nullptr) {
        m_result.filament_diameters.clear();
        m_result.filament_diameters.resize(filament_diameters->values.size());
        for (size_t i = 0; i < filament_diameters->values.size(); ++i) {
            m_result.filament_diameters[i] = static_cast<float>(filament_diameters->values[i]);
        }
    }
 
    if (m_result.filament_diameters.size() < m_result.extruders_count) {
        for (size_t i = m_result.filament_diameters.size(); i < m_result.extruders_count; ++i) {
            m_result.filament_diameters.emplace_back(DEFAULT_FILAMENT_DIAMETER);
        }
    }
 
    const ConfigOptionFloats* filament_densities = config.option<ConfigOptionFloats>("filament_density");
    if (filament_densities != nullptr) {
        m_result.filament_densities.clear();
        m_result.filament_densities.resize(filament_densities->values.size());
        for (size_t i = 0; i < filament_densities->values.size(); ++i) {
            m_result.filament_densities[i] = static_cast<float>(filament_densities->values[i]);
        }
    }
 
    if (m_result.filament_densities.size() < m_result.extruders_count) {
        for (size_t i = m_result.filament_densities.size(); i < m_result.extruders_count; ++i) {
            m_result.filament_densities.emplace_back(DEFAULT_FILAMENT_DENSITY);
        }
    }
 
    const ConfigOptionFloats* filament_cost = config.option<ConfigOptionFloats>("filament_cost");
    if (filament_cost != nullptr) {
        m_result.filament_cost.clear();
        m_result.filament_cost.resize(filament_cost->values.size());
        for (size_t i = 0; i < filament_cost->values.size(); ++i) {
            m_result.filament_cost[i] = static_cast<float>(filament_cost->values[i]);
        }
    }
 
    if (m_result.filament_cost.size() < m_result.extruders_count) {
        for (size_t i = m_result.filament_cost.size(); i < m_result.extruders_count; ++i) {
            m_result.filament_cost.emplace_back(DEFAULT_FILAMENT_COST);
        }
    }
 
    const ConfigOptionPoints* extruder_offset = config.option<ConfigOptionPoints>("extruder_offset");
    if (extruder_offset != nullptr) {
        m_extruder_offsets.resize(extruder_offset->values.size());
        for (size_t i = 0; i < extruder_offset->values.size(); ++i) {
            Vec2f offset = extruder_offset->values[i].cast<float>();
            m_extruder_offsets[i] = { offset(0), offset(1), 0.0f };
        }
    }
    
    if (m_extruder_offsets.size() < m_result.extruders_count) {
        for (size_t i = m_extruder_offsets.size(); i < m_result.extruders_count; ++i) {
            m_extruder_offsets.emplace_back(DEFAULT_EXTRUDER_OFFSET);
        }
    }
 
    const ConfigOptionStrings* extruder_colour = config.option<ConfigOptionStrings>("extruder_colour");
    if (extruder_colour != nullptr) {
        // takes colors from config
        m_result.extruder_colors = extruder_colour->values;
        // try to replace missing values with filament colors
        const ConfigOptionStrings* filament_colour = config.option<ConfigOptionStrings>("filament_colour");
        if (filament_colour != nullptr && filament_colour->values.size() == m_result.extruder_colors.size()) {
            for (size_t i = 0; i < m_result.extruder_colors.size(); ++i) {
                if (m_result.extruder_colors[i].empty())
                    m_result.extruder_colors[i] = filament_colour->values[i];
            }
        }
    }
 
    if (m_result.extruder_colors.size() < m_result.extruders_count) {
        for (size_t i = m_result.extruder_colors.size(); i < m_result.extruders_count; ++i) {
            m_result.extruder_colors.emplace_back(std::string());
        }
    }
 
    // replace missing values with default
    for (size_t i = 0; i < m_result.extruder_colors.size(); ++i) {
        if (m_result.extruder_colors[i].empty())
            m_result.extruder_colors[i] = "#FF8000";
    }
 
    m_extruder_colors.resize(m_result.extruder_colors.size());
    for (size_t i = 0; i < m_result.extruder_colors.size(); ++i) {
        m_extruder_colors[i] = static_cast<unsigned char>(i);
    }
 
    m_extruder_temps.resize(m_result.extruders_count);
 
    const ConfigOptionFloats* filament_load_time = config.option<ConfigOptionFloats>("filament_load_time");
    if (filament_load_time != nullptr) {
        m_time_processor.filament_load_times.resize(filament_load_time->values.size());
        for (size_t i = 0; i < filament_load_time->values.size(); ++i) {
            m_time_processor.filament_load_times[i] = static_cast<float>(filament_load_time->values[i]);
        }
    }
 
    const ConfigOptionFloats* filament_unload_time = config.option<ConfigOptionFloats>("filament_unload_time");
    if (filament_unload_time != nullptr) {
        m_time_processor.filament_unload_times.resize(filament_unload_time->values.size());
        for (size_t i = 0; i < filament_unload_time->values.size(); ++i) {
            m_time_processor.filament_unload_times[i] = static_cast<float>(filament_unload_time->values[i]);
        }
    }
 
    // With MM setups like Prusa MMU2, the filaments may be expected to be parked at the beginning.
    // Remember the parking position so the initial load is not included in filament estimate.
    const ConfigOptionBool* single_extruder_multi_material = config.option<ConfigOptionBool>("single_extruder_multi_material");
    const ConfigOptionBool* wipe_tower = config.option<ConfigOptionBool>("wipe_tower");
    const ConfigOptionFloat* parking_pos_retraction = config.option<ConfigOptionFloat>("parking_pos_retraction");
    const ConfigOptionFloat* extra_loading_move = config.option<ConfigOptionFloat>("extra_loading_move");
 
    m_single_extruder_multi_material = single_extruder_multi_material != nullptr && single_extruder_multi_material->value;
 
    if (m_single_extruder_multi_material && wipe_tower != nullptr && parking_pos_retraction != nullptr && extra_loading_move != nullptr) {
        if (m_single_extruder_multi_material && m_result.extruders_count > 1 && wipe_tower->value) {
            m_parking_position = float(parking_pos_retraction->value);
            m_extra_loading_move = float(extra_loading_move->value);
        }
    }
 
    bool use_machine_limits = false;
    const ConfigOptionEnum<MachineLimitsUsage>* machine_limits_usage = config.option<ConfigOptionEnum<MachineLimitsUsage>>("machine_limits_usage");
    if (machine_limits_usage != nullptr)
        use_machine_limits = machine_limits_usage->value != MachineLimitsUsage::Ignore;
 
    if (use_machine_limits && (m_flavor == gcfMarlinLegacy || m_flavor == gcfMarlinFirmware || m_flavor == gcfRepRapFirmware || m_flavor == gcfKlipper)) {
        const ConfigOptionFloats* machine_max_acceleration_x = config.option<ConfigOptionFloats>("machine_max_acceleration_x");
        if (machine_max_acceleration_x != nullptr)
            m_time_processor.machine_limits.machine_max_acceleration_x.values = machine_max_acceleration_x->values;
 
        const ConfigOptionFloats* machine_max_acceleration_y = config.option<ConfigOptionFloats>("machine_max_acceleration_y");
        if (machine_max_acceleration_y != nullptr)
            m_time_processor.machine_limits.machine_max_acceleration_y.values = machine_max_acceleration_y->values;
 
        const ConfigOptionFloats* machine_max_acceleration_z = config.option<ConfigOptionFloats>("machine_max_acceleration_z");
        if (machine_max_acceleration_z != nullptr)
            m_time_processor.machine_limits.machine_max_acceleration_z.values = machine_max_acceleration_z->values;
 
        const ConfigOptionFloats* machine_max_acceleration_e = config.option<ConfigOptionFloats>("machine_max_acceleration_e");
        if (machine_max_acceleration_e != nullptr)
            m_time_processor.machine_limits.machine_max_acceleration_e.values = machine_max_acceleration_e->values;
 
        const ConfigOptionFloats* machine_max_feedrate_x = config.option<ConfigOptionFloats>("machine_max_feedrate_x");
        if (machine_max_feedrate_x != nullptr)
            m_time_processor.machine_limits.machine_max_feedrate_x.values = machine_max_feedrate_x->values;
 
        const ConfigOptionFloats* machine_max_feedrate_y = config.option<ConfigOptionFloats>("machine_max_feedrate_y");
        if (machine_max_feedrate_y != nullptr)
            m_time_processor.machine_limits.machine_max_feedrate_y.values = machine_max_feedrate_y->values;
 
        const ConfigOptionFloats* machine_max_feedrate_z = config.option<ConfigOptionFloats>("machine_max_feedrate_z");
        if (machine_max_feedrate_z != nullptr)
            m_time_processor.machine_limits.machine_max_feedrate_z.values = machine_max_feedrate_z->values;
 
        const ConfigOptionFloats* machine_max_feedrate_e = config.option<ConfigOptionFloats>("machine_max_feedrate_e");
        if (machine_max_feedrate_e != nullptr)
            m_time_processor.machine_limits.machine_max_feedrate_e.values = machine_max_feedrate_e->values;
 
        const ConfigOptionFloats* machine_max_jerk_x = config.option<ConfigOptionFloats>("machine_max_jerk_x");
        if (machine_max_jerk_x != nullptr)
            m_time_processor.machine_limits.machine_max_jerk_x.values = machine_max_jerk_x->values;
 
        const ConfigOptionFloats* machine_max_jerk_y = config.option<ConfigOptionFloats>("machine_max_jerk_y");
        if (machine_max_jerk_y != nullptr)
            m_time_processor.machine_limits.machine_max_jerk_y.values = machine_max_jerk_y->values;
 
        const ConfigOptionFloats* machine_max_jerk_z = config.option<ConfigOptionFloats>("machine_max_jerkz");
        if (machine_max_jerk_z != nullptr)
            m_time_processor.machine_limits.machine_max_jerk_z.values = machine_max_jerk_z->values;
 
        const ConfigOptionFloats* machine_max_jerk_e = config.option<ConfigOptionFloats>("machine_max_jerk_e");
        if (machine_max_jerk_e != nullptr)
            m_time_processor.machine_limits.machine_max_jerk_e.values = machine_max_jerk_e->values;
 
        const ConfigOptionFloats* machine_max_acceleration_extruding = config.option<ConfigOptionFloats>("machine_max_acceleration_extruding");
        if (machine_max_acceleration_extruding != nullptr)
            m_time_processor.machine_limits.machine_max_acceleration_extruding.values = machine_max_acceleration_extruding->values;
 
        const ConfigOptionFloats* machine_max_acceleration_retracting = config.option<ConfigOptionFloats>("machine_max_acceleration_retracting");
        if (machine_max_acceleration_retracting != nullptr)
            m_time_processor.machine_limits.machine_max_acceleration_retracting.values = machine_max_acceleration_retracting->values;
 
 
        // Legacy Marlin and Klipper don't have separate travel acceleration, they use the 'extruding' value instead.
        const ConfigOptionFloats* machine_max_acceleration_travel = config.option<ConfigOptionFloats>((m_flavor == gcfMarlinLegacy || m_flavor == gcfKlipper)
                                                                                                    ? "machine_max_acceleration_extruding"
                                                                                                    : "machine_max_acceleration_travel");
        if (machine_max_acceleration_travel != nullptr)
            m_time_processor.machine_limits.machine_max_acceleration_travel.values = machine_max_acceleration_travel->values;
 
 
        const ConfigOptionFloats* machine_min_extruding_rate = config.option<ConfigOptionFloats>("machine_min_extruding_rate");
        if (machine_min_extruding_rate != nullptr) {
            m_time_processor.machine_limits.machine_min_extruding_rate.values = machine_min_extruding_rate->values;
            if (m_flavor == gcfRepRapFirmware) {
                // RRF does not support setting min feedrates. Set zero.
                m_time_processor.machine_limits.machine_min_extruding_rate.values.assign(m_time_processor.machine_limits.machine_min_extruding_rate.size(), 0.);
            }
        }
 
        const ConfigOptionFloats* machine_min_travel_rate = config.option<ConfigOptionFloats>("machine_min_travel_rate");
        if (machine_min_travel_rate != nullptr) {
            m_time_processor.machine_limits.machine_min_travel_rate.values = machine_min_travel_rate->values;
            if (m_flavor == gcfRepRapFirmware) {
                // RRF does not support setting min feedrates. Set zero.
                m_time_processor.machine_limits.machine_min_travel_rate.values.assign(m_time_processor.machine_limits.machine_min_travel_rate.size(), 0.);
            }
        }
    }
 
    for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
        float max_acceleration = get_option_value(m_time_processor.machine_limits.machine_max_acceleration_extruding, i);
        m_time_processor.machines[i].max_acceleration = max_acceleration;
        m_time_processor.machines[i].acceleration = (max_acceleration > 0.0f) ? max_acceleration : DEFAULT_ACCELERATION;
        float max_retract_acceleration = get_option_value(m_time_processor.machine_limits.machine_max_acceleration_retracting, i);
        m_time_processor.machines[i].max_retract_acceleration = max_retract_acceleration;
        m_time_processor.machines[i].retract_acceleration = (max_retract_acceleration > 0.0f) ? max_retract_acceleration : DEFAULT_RETRACT_ACCELERATION;
        float max_travel_acceleration = get_option_value(m_time_processor.machine_limits.machine_max_acceleration_travel, i);
        m_time_processor.machines[i].max_travel_acceleration = max_travel_acceleration;
        m_time_processor.machines[i].travel_acceleration = (max_travel_acceleration > 0.0f) ? max_travel_acceleration : DEFAULT_TRAVEL_ACCELERATION;
    }
 
    if (m_flavor == gcfMarlinLegacy || m_flavor == gcfMarlinFirmware) { // No Klipper here, it does not support silent mode.
        const ConfigOptionBool* silent_mode = config.option<ConfigOptionBool>("silent_mode");
        if (silent_mode != nullptr) {
            if (silent_mode->value && m_time_processor.machine_limits.machine_max_acceleration_x.values.size() > 1)
                enable_stealth_time_estimator(true);
        }
    }
 
    const ConfigOptionBool* use_volumetric_e = config.option<ConfigOptionBool>("use_volumetric_e");
    if (use_volumetric_e != nullptr)
        m_use_volumetric_e = use_volumetric_e->value;
 
    const ConfigOptionFloatOrPercent* first_layer_height = config.option<ConfigOptionFloatOrPercent>("first_layer_height");
    if (first_layer_height != nullptr)
        m_first_layer_height = std::abs(first_layer_height->value);
 
    const ConfigOptionFloat* max_print_height = config.option<ConfigOptionFloat>("max_print_height");
    if (max_print_height != nullptr)
        m_result.max_print_height = max_print_height->value;
 
    const ConfigOptionBool* spiral_vase = config.option<ConfigOptionBool>("spiral_vase");
    if (spiral_vase != nullptr)
        m_spiral_vase_active = spiral_vase->value;
 
    const ConfigOptionFloat* z_offset = config.option<ConfigOptionFloat>("z_offset");
    if (z_offset != nullptr)
        m_z_offset = z_offset->value;
}

Here is the call graph for this function:

◆ apply_config() [2/2]

void Slic3r::GCodeProcessor::apply_config ( const PrintConfig & config )

{
    m_parser.apply_config(config);
 
    m_producer = EProducer::PrusaSlicer;
    m_flavor = config.gcode_flavor;
 
    m_result.backtrace_enabled = is_XL_printer(config);
 
    size_t extruders_count = config.nozzle_diameter.values.size();
    m_result.extruders_count = extruders_count;
 
    m_extruder_offsets.resize(extruders_count);
    m_extruder_colors.resize(extruders_count);
    m_result.filament_diameters.resize(extruders_count);
    m_result.filament_densities.resize(extruders_count);
    m_result.filament_cost.resize(extruders_count);
    m_extruder_temps.resize(extruders_count);
    m_extruder_temps_config.resize(extruders_count);
    m_extruder_temps_first_layer_config.resize(extruders_count);
    m_is_XL_printer = is_XL_printer(config);
 
    for (size_t i = 0; i < extruders_count; ++ i) {
        m_extruder_offsets[i]           = to_3d(config.extruder_offset.get_at(i).cast<float>().eval(), 0.f);
        m_extruder_colors[i]            = static_cast<unsigned char>(i);
        m_extruder_temps_config[i]      = static_cast<int>(config.temperature.get_at(i));
        m_extruder_temps_first_layer_config[i] = static_cast<int>(config.first_layer_temperature.get_at(i));
        m_result.filament_diameters[i]  = static_cast<float>(config.filament_diameter.get_at(i));
        m_result.filament_densities[i]  = static_cast<float>(config.filament_density.get_at(i));
        m_result.filament_cost[i]       = static_cast<float>(config.filament_cost.get_at(i));
    }
 
    if ((m_flavor == gcfMarlinLegacy || m_flavor == gcfMarlinFirmware || m_flavor == gcfRepRapFirmware || m_flavor == gcfKlipper)
         && config.machine_limits_usage.value != MachineLimitsUsage::Ignore) {
        m_time_processor.machine_limits = reinterpret_cast<const MachineEnvelopeConfig&>(config);
        if (m_flavor == gcfMarlinLegacy || m_flavor == gcfKlipper) {
            // Legacy Marlin and Klipper don't have separate travel acceleration, they use the 'extruding' value instead.
            m_time_processor.machine_limits.machine_max_acceleration_travel = m_time_processor.machine_limits.machine_max_acceleration_extruding;
        }
        if (m_flavor == gcfRepRapFirmware) {
            // RRF does not support setting min feedrates. Set them to zero.
            m_time_processor.machine_limits.machine_min_travel_rate.values.assign(m_time_processor.machine_limits.machine_min_travel_rate.size(), 0.);
            m_time_processor.machine_limits.machine_min_extruding_rate.values.assign(m_time_processor.machine_limits.machine_min_extruding_rate.size(), 0.);
        }
    }
 
    // Filament load / unload times are not specific to a firmware flavor. Let anybody use it if they find it useful.
    // As of now the fields are shown at the UI dialog in the same combo box as the ramming values, so they
    // are considered to be active for the single extruder multi-material printers only.
    m_time_processor.filament_load_times.resize(config.filament_load_time.values.size());
    for (size_t i = 0; i < config.filament_load_time.values.size(); ++i) {
        m_time_processor.filament_load_times[i] = static_cast<float>(config.filament_load_time.values[i]);
    }
    m_time_processor.filament_unload_times.resize(config.filament_unload_time.values.size());
    for (size_t i = 0; i < config.filament_unload_time.values.size(); ++i) {
        m_time_processor.filament_unload_times[i] = static_cast<float>(config.filament_unload_time.values[i]);
    }
 
    m_single_extruder_multi_material = config.single_extruder_multi_material;
 
    // With MM setups like Prusa MMU2, the filaments may be expected to be parked at the beginning.
    // Remember the parking position so the initial load is not included in filament estimate.
    if (m_single_extruder_multi_material && extruders_count > 1 && config.wipe_tower) {
        m_parking_position = float(config.parking_pos_retraction.value);
        m_extra_loading_move = float(config.extra_loading_move);
    }
 
for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
        float max_acceleration = get_option_value(m_time_processor.machine_limits.machine_max_acceleration_extruding, i);
        m_time_processor.machines[i].max_acceleration = max_acceleration;
        m_time_processor.machines[i].acceleration = (max_acceleration > 0.0f) ? max_acceleration : DEFAULT_ACCELERATION;
        float max_retract_acceleration = get_option_value(m_time_processor.machine_limits.machine_max_acceleration_retracting, i);
        m_time_processor.machines[i].max_retract_acceleration = max_retract_acceleration;
        m_time_processor.machines[i].retract_acceleration = (max_retract_acceleration > 0.0f) ? max_retract_acceleration : DEFAULT_RETRACT_ACCELERATION;
 
        float max_travel_acceleration = get_option_value(m_time_processor.machine_limits.machine_max_acceleration_travel, i);
        if ( ! GCodeWriter::supports_separate_travel_acceleration(config.gcode_flavor.value) || config.machine_limits_usage.value != MachineLimitsUsage::EmitToGCode) {
            // Only clamp travel acceleration when it is accessible in machine limits.
            max_travel_acceleration = 0;
        }
        m_time_processor.machines[i].max_travel_acceleration = max_travel_acceleration;
        m_time_processor.machines[i].travel_acceleration = (max_travel_acceleration > 0.0f) ? max_travel_acceleration : DEFAULT_TRAVEL_ACCELERATION;
    }
 
    m_time_processor.export_remaining_time_enabled = config.remaining_times.value;
    m_use_volumetric_e = config.use_volumetric_e;
 
    const ConfigOptionFloatOrPercent* first_layer_height = config.option<ConfigOptionFloatOrPercent>("first_layer_height");
    if (first_layer_height != nullptr)
        m_first_layer_height = std::abs(first_layer_height->value);
 
    m_result.max_print_height = config.max_print_height;
 
    const ConfigOptionBool* spiral_vase = config.option<ConfigOptionBool>("spiral_vase");
    if (spiral_vase != nullptr)
        m_spiral_vase_active = spiral_vase->value;
 
    const ConfigOptionFloat* z_offset = config.option<ConfigOptionFloat>("z_offset");
    if (z_offset != nullptr)
        m_z_offset = z_offset->value;
}

Referenced by apply_config_superslicer(), Slic3r::DoExport::init_gcode_processor(), and process_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_config_kissslicer()

void Slic3r::GCodeProcessor::apply_config_kissslicer ( const std::string & filename )

private

{
    size_t found_counter = 0;
    m_parser.parse_file_raw(filename, [this, &found_counter](GCodeReader& reader, const char* begin, const char* end) {
        auto detect_flavor = [this](const std::string_view comment) {
            static const std::string search_str = "firmware_type";
            const size_t pos = comment.find(search_str);
            if (pos != comment.npos) {
                std::vector<std::string> elements;
                boost::split(elements, comment, boost::is_any_of("="));
                if (elements.size() == 2) {
                    try
                    {
                        switch (std::stoi(elements[1]))
                        {
                        default: { break; }
                        case 1:
                        case 2:
                        case 3: { m_flavor = gcfMarlinLegacy; break; }
                        }
                        return true;
                    }
                    catch (...)
                    {
                        // invalid data, do nothing
                    }
                }
            }
            return false;
        };
 
        auto detect_printer = [this](const std::string_view comment) {
            static const std::string search_str = "printer_name";
            const size_t pos = comment.find(search_str);
            if (pos != comment.npos) {
                std::vector<std::string> elements;
                boost::split(elements, comment, boost::is_any_of("="));
                if (elements.size() == 2) {
                    elements[1] = boost::to_upper_copy(elements[1]);
                    if (boost::contains(elements[1], "MK2.5") || boost::contains(elements[1], "MK3"))
                        m_kissslicer_toolchange_time_correction = 18.0f; // MMU2
                    else if (boost::contains(elements[1], "MK2"))
                        m_kissslicer_toolchange_time_correction = 5.0f; // MMU
                }
                return true;
            }
 
            return false;
        };
 
        begin = skip_whitespaces(begin, end);
        if (begin != end) {
            if (*begin == ';') {
                // Comment.
                begin = skip_whitespaces(++begin, end);
                end = remove_eols(begin, end);
                if (begin != end) {
                    const std::string_view comment(begin, end - begin);
                    if (detect_flavor(comment) || detect_printer(comment))
                        ++found_counter;
                }
 
                // we got the data,
                // force early exit to avoid parsing the entire file
                if (found_counter == 2)
                    m_parser.quit_parsing();
            }
            else if (*begin == 'M' || *begin == 'G')
                // the header has been fully parsed, quit search
                m_parser.quit_parsing();
        }
        }
    );
    m_parser.reset();
}

References comment, Slic3r::gcfMarlinLegacy, m_flavor, m_kissslicer_toolchange_time_correction, m_parser, Slic3r::GCodeReader::parse_file_raw(), Slic3r::GCodeReader::quit_parsing(), Slic3r::remove_eols(), Slic3r::GCodeReader::reset(), and Slic3r::skip_whitespaces().

Referenced by process_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_config_simplify3d()

void Slic3r::GCodeProcessor::apply_config_simplify3d ( const std::string & filename )

private

{
    struct BedSize
    {
        double x{ 0.0 };
        double y{ 0.0 };
 
        bool is_defined() const { return x > 0.0 && y > 0.0; }
    };
 
    BedSize bed_size;
    bool    producer_detected = false;
 
    m_parser.parse_file_raw(filename, [this, &bed_size, &producer_detected](GCodeReader& reader, const char* begin, const char* end) {
 
        auto extract_double = [](const std::string_view cmt, const std::string& key, double& out) {
            size_t pos = cmt.find(key);
            if (pos != cmt.npos) {
                pos = cmt.find(',', pos);
                if (pos != cmt.npos) {
                    out = string_to_double_decimal_point(cmt.substr(pos+1));
                    return true;
                }
            }
            return false;
        };
 
        auto extract_floats = [](const std::string_view cmt, const std::string& key, std::vector<float>& out) {
            size_t pos = cmt.find(key);
            if (pos != cmt.npos) {
                pos = cmt.find(',', pos);
                if (pos != cmt.npos) {
                    const std::string_view data_str = cmt.substr(pos + 1);
                    std::vector<std::string> values_str;
                    boost::split(values_str, data_str, boost::is_any_of("|,"), boost::token_compress_on);
                    for (const std::string& s : values_str) {
                        out.emplace_back(static_cast<float>(string_to_double_decimal_point(s)));
                    }
                    return true;
                }
            }
            return false;
        };
        
        begin = skip_whitespaces(begin, end);
        end   = remove_eols(begin, end);
        if (begin != end) {
            if (*begin == ';') {
                // Comment.
                begin = skip_whitespaces(++ begin, end);
                if (begin != end) {
                    std::string_view comment(begin, end - begin);
                    if (producer_detected) {
                        if (bed_size.x == 0.0 && comment.find("strokeXoverride") != comment.npos)
                            extract_double(comment, "strokeXoverride", bed_size.x);
                        else if (bed_size.y == 0.0 && comment.find("strokeYoverride") != comment.npos)
                            extract_double(comment, "strokeYoverride", bed_size.y);
                        else if (comment.find("filamentDiameters") != comment.npos) {
                            m_result.filament_diameters.clear();
                            extract_floats(comment, "filamentDiameters", m_result.filament_diameters);
                        } else if (comment.find("filamentDensities") != comment.npos) {
                            m_result.filament_densities.clear();
                            extract_floats(comment, "filamentDensities", m_result.filament_densities);
                        }
                        else if (comment.find("filamentPricesPerKg") != comment.npos) {
                            m_result.filament_cost.clear();
                            extract_floats(comment, "filamentPricesPerKg", m_result.filament_cost);
                        } else if (comment.find("extruderDiameter") != comment.npos) {
                            std::vector<float> extruder_diameters;
                            extract_floats(comment, "extruderDiameter", extruder_diameters);
                            m_result.extruders_count = extruder_diameters.size();
                        }
                    } else if (boost::starts_with(comment, "G-Code generated by Simplify3D(R)"))
                        producer_detected = true;
                }
            } else {
                // Some non-empty G-code line detected, stop parsing config comments.
                reader.quit_parsing();
            }
        }
    });
 
    if (m_result.extruders_count == 0)
        m_result.extruders_count = std::max<size_t>(1, std::min(m_result.filament_diameters.size(), 
            std::min(m_result.filament_densities.size(), m_result.filament_cost.size())));
 
    if (bed_size.is_defined()) {
        m_result.bed_shape = {
            { 0.0, 0.0 },
            { bed_size.x, 0.0 },
            { bed_size.x, bed_size.y },
            { 0.0, bed_size.y }
        };
    }
}

References Slic3r::GCodeProcessorResult::bed_shape, comment, Slic3r::GCodeProcessorResult::extruders_count, Slic3r::GCodeProcessorResult::filament_cost, Slic3r::GCodeProcessorResult::filament_densities, Slic3r::GCodeProcessorResult::filament_diameters, m_parser, m_result, Slic3r::GCodeReader::parse_file_raw(), Slic3r::GCodeReader::quit_parsing(), Slic3r::remove_eols(), Slic3r::skip_whitespaces(), and Slic3r::string_to_double_decimal_point().

Referenced by process_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_config_superslicer()

void Slic3r::GCodeProcessor::apply_config_superslicer ( const std::string & filename )

private

{
    DynamicPrintConfig config;
    config.apply(FullPrintConfig::defaults());
    load_from_superslicer_gcode_file(filename, config, ForwardCompatibilitySubstitutionRule::EnableSilent);
    apply_config(config);
}

References Slic3r::ConfigBase::apply(), apply_config(), Slic3r::EnableSilent, and Slic3r::load_from_superslicer_gcode_file().

Referenced by process_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ contains_reserved_tag()

bool Slic3r::GCodeProcessor::contains_reserved_tag	(	const std::string &	gcode,
		std::string &	found_tag
	)

static

{
    bool ret = false;
 
    GCodeReader parser;
    parser.parse_buffer(gcode, [&ret, &found_tag](GCodeReader& parser, const GCodeReader::GCodeLine& line) {
        std::string comment = line.raw();
        if (comment.length() > 2 && comment.front() == ';') {
            comment = comment.substr(1);
            for (const std::string& s : Reserved_Tags) {
                if (boost::starts_with(comment, s)) {
                    ret = true;
                    found_tag = comment;
                    parser.quit_parsing();
                    return;
                }
            }
        }
        });
 
    return ret;
}

References comment, Slic3r::GCodeReader::parse_buffer(), and Slic3r::GCodeReader::GCodeLine::raw().

Here is the call graph for this function:

◆ contains_reserved_tags()

bool Slic3r::GCodeProcessor::contains_reserved_tags	(	const std::string &	gcode,
		unsigned int	max_count,
		std::vector< std::string > &	found_tag
	)

static

{
    max_count = std::max(max_count, 1U);
 
    bool ret = false;
 
    CNumericLocalesSetter locales_setter;
 
    GCodeReader parser;
    parser.parse_buffer(gcode, [&ret, &found_tag, max_count](GCodeReader& parser, const GCodeReader::GCodeLine& line) {
        std::string comment = line.raw();
        if (comment.length() > 2 && comment.front() == ';') {
            comment = comment.substr(1);
            for (const std::string& s : Reserved_Tags) {
                if (boost::starts_with(comment, s)) {
                    ret = true;
                    found_tag.push_back(comment);
                    if (found_tag.size() == max_count) {
                        parser.quit_parsing();
                        return;
                    }
                }
            }
        }
        });
 
    return ret;
}

References comment, Slic3r::GCodeReader::parse_buffer(), and Slic3r::GCodeReader::GCodeLine::raw().

Referenced by Slic3r::GUI::Tab::validate_custom_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ detect_producer()

bool Slic3r::GCodeProcessor::detect_producer ( const std::string_view comment )

private

{
    for (const auto& [id, search_string] : Producers) {
        const size_t pos = comment.find(search_string);
        if (pos != comment.npos) {
            m_producer = id;
            BOOST_LOG_TRIVIAL(info) << "Detected gcode producer: " << search_string;
            return true;
        }
    }
    return false;
}

References comment, m_producer, and Producers.

Referenced by process_file().

Here is the caller graph for this function:

◆ enable_machine_envelope_processing()

void Slic3r::GCodeProcessor::enable_machine_envelope_processing ( bool enabled )

inline

630{ m_time_processor.machine_envelope_processing_enabled = enabled; }

Slic3r::GCodeProcessor::TimeProcessor::machine_envelope_processing_enabled

bool machine_envelope_processing_enabled

Definition GCodeProcessor.hpp:363

References m_time_processor, and Slic3r::GCodeProcessor::TimeProcessor::machine_envelope_processing_enabled.

◆ enable_stealth_time_estimator()

void Slic3r::GCodeProcessor::enable_stealth_time_estimator ( bool enabled )

{
    m_time_processor.machines[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Stealth)].enabled = enabled;
}

References m_time_processor, Slic3r::GCodeProcessor::TimeProcessor::machines, and Slic3r::PrintEstimatedStatistics::Stealth.

Referenced by apply_config(), and Slic3r::DoExport::init_gcode_processor().

Here is the caller graph for this function:

◆ extract_absolute_position_on_axis()

double Slic3r::GCodeProcessor::extract_absolute_position_on_axis	(	Axis	axis,
		const GCodeReader::GCodeLine &	line,
		double	area_filament_cross_section
	)

private

{
    if (line.has(Slic3r::Axis(axis))) {
        bool is_relative = (m_global_positioning_type == EPositioningType::Relative);
        if (axis == E)
            is_relative |= (m_e_local_positioning_type == EPositioningType::Relative);
 
        const double lengthsScaleFactor = (m_units == EUnits::Inches) ? double(INCHES_TO_MM) : 1.0;
        double ret = line.value(Slic3r::Axis(axis)) * lengthsScaleFactor;
        if (axis == E && m_use_volumetric_e)
            ret /= area_filament_cross_section;
        return is_relative ? m_start_position[axis] + ret : m_origin[axis] + ret;
    }
    else
        return m_start_position[axis];
}

References Slic3r::E, Slic3r::GCodeReader::GCodeLine::has(), Inches, INCHES_TO_MM, m_e_local_positioning_type, m_global_positioning_type, m_origin, m_start_position, m_units, m_use_volumetric_e, Relative, and Slic3r::GCodeReader::GCodeLine::value().

Referenced by process_G1(), and process_G2_G3().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extract_result()

GCodeProcessorResult && Slic3r::GCodeProcessor::extract_result ( )

inline

634{ return std::move(m_result); }

References m_result.

Referenced by Slic3r::GCode::do_export(), and Slic3r::GUI::Plater::load_gcode().

Here is the caller graph for this function:

◆ finalize()

void Slic3r::GCodeProcessor::finalize ( bool post_process )

{
    // update width/height of wipe moves
    for (GCodeProcessorResult::MoveVertex& move : m_result.moves) {
        if (move.type == EMoveType::Wipe) {
            move.width = Wipe_Width;
            move.height = Wipe_Height;
        }
    }
 
    // process the time blocks
    for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
        TimeMachine& machine = m_time_processor.machines[i];
        TimeMachine::CustomGCodeTime& gcode_time = machine.gcode_time;
        machine.calculate_time();
        if (gcode_time.needed && gcode_time.cache != 0.0f)
            gcode_time.times.push_back({ CustomGCode::ColorChange, gcode_time.cache });
    }
 
    m_used_filaments.process_caches(this);
 
    update_estimated_times_stats();
 
#if ENABLE_GCODE_VIEWER_DATA_CHECKING
    std::cout << "\n";
    m_mm3_per_mm_compare.output();
    m_height_compare.output();
    m_width_compare.output();
#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
 
    if (perform_post_process)
        post_process();
#if ENABLE_GCODE_VIEWER_STATISTICS
    m_result.time = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - m_start_time).count();
#endif // ENABLE_GCODE_VIEWER_STATISTICS
}

Referenced by Slic3r::GCode::do_export(), and process_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_acceleration()

float Slic3r::GCodeProcessor::get_acceleration ( PrintEstimatedStatistics::ETimeMode mode ) const

private

{
    size_t id = static_cast<size_t>(mode);
    return (id < m_time_processor.machines.size()) ? m_time_processor.machines[id].acceleration : DEFAULT_ACCELERATION;
}

References DEFAULT_ACCELERATION, m_time_processor, and Slic3r::GCodeProcessor::TimeProcessor::machines.

Referenced by process_G1().

Here is the caller graph for this function:

◆ get_axis_max_acceleration()

float Slic3r::GCodeProcessor::get_axis_max_acceleration	(	PrintEstimatedStatistics::ETimeMode	mode,
		Axis	axis
	)		const

private

{
    switch (axis)
    {
    case X: { return get_option_value(m_time_processor.machine_limits.machine_max_acceleration_x, static_cast<size_t>(mode)); }
    case Y: { return get_option_value(m_time_processor.machine_limits.machine_max_acceleration_y, static_cast<size_t>(mode)); }
    case Z: { return get_option_value(m_time_processor.machine_limits.machine_max_acceleration_z, static_cast<size_t>(mode)); }
    case E: { return get_option_value(m_time_processor.machine_limits.machine_max_acceleration_e, static_cast<size_t>(mode)); }
    default: { return 0.0f; }
    }
}

References Slic3r::E, Slic3r::get_option_value(), m_time_processor, Slic3r::GCodeProcessor::TimeProcessor::machine_limits, Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by process_G1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_axis_max_feedrate()

float Slic3r::GCodeProcessor::get_axis_max_feedrate	(	PrintEstimatedStatistics::ETimeMode	mode,
		Axis	axis
	)		const

private

{
    switch (axis)
    {
    case X: { return get_option_value(m_time_processor.machine_limits.machine_max_feedrate_x, static_cast<size_t>(mode)); }
    case Y: { return get_option_value(m_time_processor.machine_limits.machine_max_feedrate_y, static_cast<size_t>(mode)); }
    case Z: { return get_option_value(m_time_processor.machine_limits.machine_max_feedrate_z, static_cast<size_t>(mode)); }
    case E: { return get_option_value(m_time_processor.machine_limits.machine_max_feedrate_e, static_cast<size_t>(mode)); }
    default: { return 0.0f; }
    }
}

References Slic3r::E, Slic3r::get_option_value(), m_time_processor, Slic3r::GCodeProcessor::TimeProcessor::machine_limits, Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by process_G1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_axis_max_jerk()

float Slic3r::GCodeProcessor::get_axis_max_jerk	(	PrintEstimatedStatistics::ETimeMode	mode,
		Axis	axis
	)		const

private

{
    switch (axis)
    {
    case X: { return get_option_value(m_time_processor.machine_limits.machine_max_jerk_x, static_cast<size_t>(mode)); }
    case Y: { return get_option_value(m_time_processor.machine_limits.machine_max_jerk_y, static_cast<size_t>(mode)); }
    case Z: { return get_option_value(m_time_processor.machine_limits.machine_max_jerk_z, static_cast<size_t>(mode)); }
    case E: { return get_option_value(m_time_processor.machine_limits.machine_max_jerk_e, static_cast<size_t>(mode)); }
    default: { return 0.0f; }
    }
}

References Slic3r::E, Slic3r::get_option_value(), m_time_processor, Slic3r::GCodeProcessor::TimeProcessor::machine_limits, Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by process_G1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_custom_gcode_times()

std::vector< std::pair< CustomGCode::Type, std::pair< float, float > > > Slic3r::GCodeProcessor::get_custom_gcode_times	(	PrintEstimatedStatistics::ETimeMode	mode,
		bool	include_remaining
	)		const

{
    std::vector<std::pair<CustomGCode::Type, std::pair<float, float>>> ret;
    if (mode < PrintEstimatedStatistics::ETimeMode::Count) {
        const TimeMachine& machine = m_time_processor.machines[static_cast<size_t>(mode)];
        float total_time = 0.0f;
        for (const auto& [type, time] : machine.gcode_time.times) {
            float remaining = include_remaining ? machine.time - total_time : 0.0f;
            ret.push_back({ type, { time, remaining } });
            total_time += time;
        }
    }
    return ret;
}

References Slic3r::PrintEstimatedStatistics::Count, Slic3r::GCodeProcessor::TimeMachine::gcode_time, m_time_processor, Slic3r::GCodeProcessor::TimeProcessor::machines, Slic3r::GCodeProcessor::TimeMachine::time, and Slic3r::GCodeProcessor::TimeMachine::CustomGCodeTime::times.

Referenced by update_estimated_times_stats().

Here is the caller graph for this function:

◆ get_filament_load_time()

float Slic3r::GCodeProcessor::get_filament_load_time ( size_t extruder_id )

private

{
    if (m_is_XL_printer)
        return 4.5f; // FIXME
    return (m_time_processor.filament_load_times.empty() || m_time_processor.extruder_unloaded) ?
        0.0f :
        ((extruder_id < m_time_processor.filament_load_times.size()) ?
            m_time_processor.filament_load_times[extruder_id] : m_time_processor.filament_load_times.front());
}

References Slic3r::GCodeProcessor::TimeProcessor::extruder_unloaded, Slic3r::GCodeProcessor::TimeProcessor::filament_load_times, m_is_XL_printer, and m_time_processor.

Referenced by process_T().

Here is the caller graph for this function:

◆ get_filament_unload_time()

float Slic3r::GCodeProcessor::get_filament_unload_time ( size_t extruder_id )

private

{
    if (m_is_XL_printer)
        return 0.f; // FIXME
    return (m_time_processor.filament_unload_times.empty() || m_time_processor.extruder_unloaded) ?
        0.0f :
        ((extruder_id < m_time_processor.filament_unload_times.size()) ?
            m_time_processor.filament_unload_times[extruder_id] : m_time_processor.filament_unload_times.front());
}

References Slic3r::GCodeProcessor::TimeProcessor::extruder_unloaded, Slic3r::GCodeProcessor::TimeProcessor::filament_unload_times, m_is_XL_printer, and m_time_processor.

Referenced by process_M702(), and process_T().

Here is the caller graph for this function:

◆ get_layers_time()

std::vector< float > Slic3r::GCodeProcessor::get_layers_time ( PrintEstimatedStatistics::ETimeMode mode ) const

{
    return (mode < PrintEstimatedStatistics::ETimeMode::Count) ?
        m_time_processor.machines[static_cast<size_t>(mode)].layers_time :
        std::vector<float>();
}

References Slic3r::PrintEstimatedStatistics::Count, m_time_processor, and Slic3r::GCodeProcessor::TimeProcessor::machines.

Referenced by update_estimated_times_stats().

Here is the caller graph for this function:

◆ get_moves_time()

std::vector< std::pair< EMoveType, float > > Slic3r::GCodeProcessor::get_moves_time ( PrintEstimatedStatistics::ETimeMode mode ) const

{
    std::vector<std::pair<EMoveType, float>> ret;
    if (mode < PrintEstimatedStatistics::ETimeMode::Count) {
        for (size_t i = 0; i < m_time_processor.machines[static_cast<size_t>(mode)].moves_time.size(); ++i) {
            float time = m_time_processor.machines[static_cast<size_t>(mode)].moves_time[i];
            if (time > 0.0f)
                ret.push_back({ static_cast<EMoveType>(i), time });
        }
    }
    return ret;
}

References Slic3r::PrintEstimatedStatistics::Count, m_time_processor, and Slic3r::GCodeProcessor::TimeProcessor::machines.

Referenced by update_estimated_times_stats().

Here is the caller graph for this function:

◆ get_result()

const GCodeProcessorResult & Slic3r::GCodeProcessor::get_result ( ) const

inline

633{ return m_result; }

References m_result.

Referenced by Slic3r::DoExport::update_print_estimated_stats().

Here is the caller graph for this function:

◆ get_retract_acceleration()

float Slic3r::GCodeProcessor::get_retract_acceleration ( PrintEstimatedStatistics::ETimeMode mode ) const

private

{
    size_t id = static_cast<size_t>(mode);
    return (id < m_time_processor.machines.size()) ? m_time_processor.machines[id].retract_acceleration : DEFAULT_RETRACT_ACCELERATION;
}

References DEFAULT_RETRACT_ACCELERATION, m_time_processor, and Slic3r::GCodeProcessor::TimeProcessor::machines.

Referenced by process_G1().

Here is the caller graph for this function:

◆ get_roles_time()

std::vector< std::pair< GCodeExtrusionRole, float > > Slic3r::GCodeProcessor::get_roles_time ( PrintEstimatedStatistics::ETimeMode mode ) const

{
    std::vector<std::pair<GCodeExtrusionRole, float>> ret;
    if (mode < PrintEstimatedStatistics::ETimeMode::Count) {
        for (size_t i = 0; i < m_time_processor.machines[static_cast<size_t>(mode)].roles_time.size(); ++i) {
            float time = m_time_processor.machines[static_cast<size_t>(mode)].roles_time[i];
            if (time > 0.0f)
                ret.push_back({ static_cast<GCodeExtrusionRole>(i), time });
        }
    }
    return ret;
}

References Slic3r::PrintEstimatedStatistics::Count, m_time_processor, and Slic3r::GCodeProcessor::TimeProcessor::machines.

Referenced by update_estimated_times_stats().

Here is the caller graph for this function:

◆ get_time()

float Slic3r::GCodeProcessor::get_time ( PrintEstimatedStatistics::ETimeMode mode ) const

{
    return (mode < PrintEstimatedStatistics::ETimeMode::Count) ? m_time_processor.machines[static_cast<size_t>(mode)].time : 0.0f;
}

References Slic3r::PrintEstimatedStatistics::Count, m_time_processor, and Slic3r::GCodeProcessor::TimeProcessor::machines.

Referenced by update_estimated_times_stats().

Here is the caller graph for this function:

◆ get_time_dhm()

std::string Slic3r::GCodeProcessor::get_time_dhm ( PrintEstimatedStatistics::ETimeMode mode ) const

{
    return (mode < PrintEstimatedStatistics::ETimeMode::Count) ? short_time(get_time_dhms(m_time_processor.machines[static_cast<size_t>(mode)].time)) : std::string("N/A");
}

References Slic3r::PrintEstimatedStatistics::Count, Slic3r::get_time_dhms(), m_time_processor, Slic3r::GCodeProcessor::TimeProcessor::machines, and Slic3r::short_time().

Here is the call graph for this function:

◆ get_travel_acceleration()

float Slic3r::GCodeProcessor::get_travel_acceleration ( PrintEstimatedStatistics::ETimeMode mode ) const

private

{
    size_t id = static_cast<size_t>(mode);
    return (id < m_time_processor.machines.size()) ? m_time_processor.machines[id].travel_acceleration : DEFAULT_TRAVEL_ACCELERATION;
}

References DEFAULT_TRAVEL_ACCELERATION, m_time_processor, and Slic3r::GCodeProcessor::TimeProcessor::machines.

Referenced by process_G1().

Here is the caller graph for this function:

◆ get_travel_time()

float Slic3r::GCodeProcessor::get_travel_time ( PrintEstimatedStatistics::ETimeMode mode ) const

{
    return (mode < PrintEstimatedStatistics::ETimeMode::Count) ? m_time_processor.machines[static_cast<size_t>(mode)].travel_time : 0.0f;
}

References Slic3r::PrintEstimatedStatistics::Count, m_time_processor, and Slic3r::GCodeProcessor::TimeProcessor::machines.

Referenced by update_estimated_times_stats().

Here is the caller graph for this function:

◆ get_travel_time_dhm()

std::string Slic3r::GCodeProcessor::get_travel_time_dhm ( PrintEstimatedStatistics::ETimeMode mode ) const

{
    return (mode < PrintEstimatedStatistics::ETimeMode::Count) ? short_time(get_time_dhms(m_time_processor.machines[static_cast<size_t>(mode)].travel_time)) : std::string("N/A");
}

References Slic3r::PrintEstimatedStatistics::Count, Slic3r::get_time_dhms(), m_time_processor, Slic3r::GCodeProcessor::TimeProcessor::machines, and Slic3r::short_time().

Here is the call graph for this function:

◆ initialize()

void Slic3r::GCodeProcessor::initialize ( const std::string & filename )

{
    assert(is_decimal_separator_point());
 
#if ENABLE_GCODE_VIEWER_STATISTICS
    m_start_time = std::chrono::high_resolution_clock::now();
#endif // ENABLE_GCODE_VIEWER_STATISTICS
 
    // process gcode
    m_result.filename = filename;
    m_result.id = ++s_result_id;
}

References Slic3r::GCodeProcessorResult::filename, Slic3r::GCodeProcessorResult::id, Slic3r::is_decimal_separator_point(), m_result, and s_result_id.

Referenced by Slic3r::GCode::do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialize_result_moves()

void Slic3r::GCodeProcessor::initialize_result_moves ( )

inline

                                       {
            // 1st move must be a dummy move
            assert(m_result.moves.empty());
            m_result.moves.emplace_back(GCodeProcessorResult::MoveVertex());
        }

References m_result, and Slic3r::GCodeProcessorResult::moves.

Referenced by Slic3r::DoExport::init_gcode_processor(), and process_file().

Here is the caller graph for this function:

◆ is_stealth_time_estimator_enabled()

bool Slic3r::GCodeProcessor::is_stealth_time_estimator_enabled ( ) const

inline

                                                       {
            return m_time_processor.machines[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Stealth)].enabled;
        }

References m_time_processor, Slic3r::GCodeProcessor::TimeProcessor::machines, and Slic3r::PrintEstimatedStatistics::Stealth.

Referenced by Slic3r::DoExport::update_print_estimated_stats().

Here is the caller graph for this function:

◆ minimum_feedrate()

float Slic3r::GCodeProcessor::minimum_feedrate	(	PrintEstimatedStatistics::ETimeMode	mode,
		float	feedrate
	)		const

private

{
    if (m_time_processor.machine_limits.machine_min_extruding_rate.empty())
        return feedrate;
 
    return std::max(feedrate, get_option_value(m_time_processor.machine_limits.machine_min_extruding_rate, static_cast<size_t>(mode)));
}

References Slic3r::get_option_value(), m_time_processor, and Slic3r::GCodeProcessor::TimeProcessor::machine_limits.

Referenced by process_G1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ minimum_travel_feedrate()

float Slic3r::GCodeProcessor::minimum_travel_feedrate	(	PrintEstimatedStatistics::ETimeMode	mode,
		float	feedrate
	)		const

private

{
    if (m_time_processor.machine_limits.machine_min_travel_rate.empty())
        return feedrate;
 
    return std::max(feedrate, get_option_value(m_time_processor.machine_limits.machine_min_travel_rate, static_cast<size_t>(mode)));
}

References Slic3r::get_option_value(), m_time_processor, and Slic3r::GCodeProcessor::TimeProcessor::machine_limits.

Referenced by process_G1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ post_process()

void Slic3r::GCodeProcessor::post_process ( )

private

{
    FilePtr in{ boost::nowide::fopen(m_result.filename.c_str(), "rb") };
    if (in.f == nullptr)
        throw Slic3r::RuntimeError(std::string("GCode processor post process export failed.\nCannot open file for reading.\n"));
 
    // temporary file to contain modified gcode
    std::string out_path = m_result.filename + ".postprocess";
    FilePtr out{ boost::nowide::fopen(out_path.c_str(), "wb") };
    if (out.f == nullptr) {
        throw Slic3r::RuntimeError(std::string("GCode processor post process export failed.\nCannot open file for writing.\n"));
    }
 
    auto time_in_minutes = [](float time_in_seconds) {
        assert(time_in_seconds >= 0.f);
        return int((time_in_seconds + 0.5f) / 60.0f);
    };
 
    auto time_in_last_minute = [](float time_in_seconds) {
        assert(time_in_seconds <= 60.0f);
        return time_in_seconds / 60.0f;
    };
 
    auto format_line_M73_main = [](const std::string& mask, int percent, int time) {
        char line_M73[64];
        sprintf(line_M73, mask.c_str(),
            std::to_string(percent).c_str(),
            std::to_string(time).c_str());
        return std::string(line_M73);
    };
 
    auto format_line_M73_stop_int = [](const std::string& mask, int time) {
        char line_M73[64];
        sprintf(line_M73, mask.c_str(), std::to_string(time).c_str());
        return std::string(line_M73);
    };
 
    auto format_time_float = [](float time) {
        return Slic3r::float_to_string_decimal_point(time, 2);
    };
 
    auto format_line_M73_stop_float = [format_time_float](const std::string& mask, float time) {
        char line_M73[64];
        sprintf(line_M73, mask.c_str(), format_time_float(time).c_str());
        return std::string(line_M73);
    };
 
    std::string gcode_line;
    size_t g1_lines_counter = 0;
    // keeps track of last exported pair <percent, remaining time>
    std::array<std::pair<int, int>, static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count)> last_exported_main;
    for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
        last_exported_main[i] = { 0, time_in_minutes(m_time_processor.machines[i].time) };
    }
 
    // keeps track of last exported remaining time to next printer stop
    std::array<int, static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count)> last_exported_stop;
    for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
        last_exported_stop[i] = time_in_minutes(m_time_processor.machines[i].time);
    }
 
    // Helper class to modify and export gcode to file
    class ExportLines
    {
    public:
        struct Backtrace
        {
            float time{ 60.0f };
            unsigned int steps{ 10 };
            float time_step() const { return time / float(steps); }
        };
 
        enum class EWriteType
        {
            BySize,
            ByTime
        };
 
    private:
        struct LineData
        {
            std::string line;
            float time;
        };
 
#ifndef NDEBUG
        class Statistics
        {
            ExportLines& m_parent;
            size_t m_max_size{ 0 };
            size_t m_lines_count{ 0 };
            size_t m_max_lines_count{ 0 };
 
        public:
            explicit Statistics(ExportLines& parent)
            : m_parent(parent)
            {}
 
            void add_line(size_t line_size) {
                ++m_lines_count;
                m_max_size = std::max(m_max_size, m_parent.get_size() + line_size);
                m_max_lines_count = std::max(m_max_lines_count, m_lines_count);
            }
 
            void remove_line() { --m_lines_count; }
            void remove_all_lines() { m_lines_count = 0; }
        };
 
        Statistics m_statistics;
#endif // NDEBUG
 
        EWriteType m_write_type{ EWriteType::BySize };
        // Time machine containing g1 times cache
        TimeMachine& m_machine;
        // Current time
        float m_time{ 0.0f };
        // Current size in bytes
        size_t m_size{ 0 };
 
        // gcode lines cache
        std::deque<LineData> m_lines;
        size_t m_added_lines_counter{ 0 };
        // map of gcode line ids from original to final 
        // used to update m_result.moves[].gcode_id
        std::vector<std::pair<size_t, size_t>> m_gcode_lines_map;
 
        size_t m_curr_g1_id{ 0 };
        size_t m_out_file_pos{ 0 };
 
    public:
        ExportLines(EWriteType type, TimeMachine& machine)
#ifndef NDEBUG
        : m_statistics(*this), m_write_type(type), m_machine(machine) {}
#else
        : m_write_type(type), m_machine(machine) {}
#endif // NDEBUG
 
        void update(size_t lines_counter, size_t g1_lines_counter) {
            m_gcode_lines_map.push_back({ lines_counter, 0 });
 
            if (g1_lines_counter == 0)
                return;
 
            auto init_it = m_machine.g1_times_cache.begin() + m_curr_g1_id;
            auto it = init_it;
            while (it != m_machine.g1_times_cache.end() && it->id < g1_lines_counter + 1) {
                ++it;
                ++m_curr_g1_id;
            }
 
            if ((it != m_machine.g1_times_cache.end() && it != init_it) || m_curr_g1_id == 0)
                m_time = it->elapsed_time;
        }
 
        // add the given gcode line to the cache
        void append_line(const std::string& line) {
            m_lines.push_back({ line, m_time });
#ifndef NDEBUG
            m_statistics.add_line(line.length());
#endif // NDEBUG
            m_size += line.length();
            ++m_added_lines_counter;
            assert(!m_gcode_lines_map.empty());
            m_gcode_lines_map.back().second = m_added_lines_counter;
        }
 
        // Insert the gcode lines required by the command cmd by backtracing into the cache
        void insert_lines(const Backtrace& backtrace, const std::string& cmd, std::function<std::string(unsigned int, float, float)> line_inserter,
            std::function<std::string(const std::string&)> line_replacer) {
            assert(!m_lines.empty());
            const float time_step = backtrace.time_step();
            size_t rev_it_dist = 0; // distance from the end of the cache of the starting point of the backtrace
            float last_time_insertion = 0.0f; // used to avoid inserting two lines at the same time
            for (unsigned int i = 0; i < backtrace.steps; ++i) {
                const float backtrace_time_i = (i + 1) * time_step;
                const float time_threshold_i = m_time - backtrace_time_i;
                auto rev_it = m_lines.rbegin() + rev_it_dist;
                auto start_rev_it = rev_it;
 
                std::string curr_cmd = GCodeReader::GCodeLine::extract_cmd(rev_it->line);
                // backtrace into the cache to find the place where to insert the line
                while (rev_it != m_lines.rend() && rev_it->time > time_threshold_i && curr_cmd != cmd && curr_cmd != "G28" && curr_cmd != "G29") {
                    rev_it->line = line_replacer(rev_it->line);
                    ++rev_it;
                    curr_cmd = GCodeReader::GCodeLine::extract_cmd(rev_it->line);
                }
 
                // we met the previous evenience of cmd, or a G28/G29 command. stop inserting lines
                if (rev_it != m_lines.rend() && (curr_cmd == cmd || curr_cmd == "G28" || curr_cmd == "G29"))
                    break;
 
                // insert the line for the current step
                if (rev_it != m_lines.rend() && rev_it != start_rev_it && rev_it->time != last_time_insertion) {
                    last_time_insertion = rev_it->time;
                    const std::string out_line = line_inserter(i + 1, last_time_insertion, m_time - last_time_insertion);
                    rev_it_dist = std::distance(m_lines.rbegin(), rev_it) + 1;
                    m_lines.insert(rev_it.base(), { out_line, rev_it->time });
#ifndef NDEBUG
                    m_statistics.add_line(out_line.length());
#endif // NDEBUG
                    m_size += out_line.length();
                    // synchronize gcode lines map
                    for (auto map_it = m_gcode_lines_map.rbegin(); map_it != m_gcode_lines_map.rbegin() + rev_it_dist - 1; ++map_it) {
                        ++map_it->second;
                    }
 
                    ++m_added_lines_counter;
                }
            }
        }
 
        // write to file:
        // m_write_type == EWriteType::ByTime - all lines older than m_time - backtrace_time
        // m_write_type == EWriteType::BySize - all lines if current size is greater than 65535 bytes
        void write(FilePtr& out, float backtrace_time, GCodeProcessorResult& result, const std::string& out_path) {
            if (m_lines.empty())
                return;
 
            // collect lines to write into a single string
            std::string out_string;
            if (!m_lines.empty()) {
                if (m_write_type == EWriteType::ByTime) {
                    while (m_lines.front().time < m_time - backtrace_time) {
                        const LineData& data = m_lines.front();
                        out_string += data.line;
                        m_size -= data.line.length();
                        m_lines.pop_front();
#ifndef NDEBUG
                        m_statistics.remove_line();
#endif // NDEBUG
                    }
                }
                else {
                    if (m_size > 65535) {
                        while (!m_lines.empty()) {
                            out_string += m_lines.front().line;
                            m_lines.pop_front();
                        }
                        m_size = 0;
#ifndef NDEBUG
                        m_statistics.remove_all_lines();
#endif // NDEBUG
                    }
                }
            }
 
            write_to_file(out, out_string, result, out_path);
        }
 
        // flush the current content of the cache to file
        void flush(FilePtr& out, GCodeProcessorResult& result, const std::string& out_path) {
            // collect lines to flush into a single string
            std::string out_string;
            while (!m_lines.empty()) {
                out_string += m_lines.front().line;
                m_lines.pop_front();
            }
            m_size = 0;
#ifndef NDEBUG
            m_statistics.remove_all_lines();
#endif // NDEBUG
 
            write_to_file(out, out_string, result, out_path);
        }
 
        void synchronize_moves(GCodeProcessorResult& result) const {
            auto it = m_gcode_lines_map.begin();
            for (GCodeProcessorResult::MoveVertex& move : result.moves) {
                while (it != m_gcode_lines_map.end() && it->first < move.gcode_id) {
                    ++it;
                }
                if (it != m_gcode_lines_map.end() && it->first == move.gcode_id)
                    move.gcode_id = it->second;
            }
        }
 
        size_t get_size() const { return m_size; }
 
    private:
        void write_to_file(FilePtr& out, const std::string& out_string, GCodeProcessorResult& result, const std::string& out_path) {
            if (!out_string.empty()) {
                fwrite((const void*)out_string.c_str(), 1, out_string.length(), out.f);
                if (ferror(out.f)) {
                    out.close();
                    boost::nowide::remove(out_path.c_str());
                    throw Slic3r::RuntimeError(std::string("GCode processor post process export failed.\nIs the disk full?\n"));
                }
                for (size_t i = 0; i < out_string.size(); ++i) {
                    if (out_string[i] == '\n')
                        result.lines_ends.emplace_back(m_out_file_pos + i + 1);
                }
                m_out_file_pos += out_string.size();
            }
        }
    };
 
    ExportLines export_lines(m_result.backtrace_enabled ? ExportLines::EWriteType::ByTime : ExportLines::EWriteType::BySize, m_time_processor.machines[0]);
 
    // replace placeholder lines with the proper final value
    // gcode_line is in/out parameter, to reduce expensive memory allocation
    auto process_placeholders = [&](std::string& gcode_line) {
        bool processed = false;
 
        // remove trailing '\n'
        auto line = std::string_view(gcode_line).substr(0, gcode_line.length() - 1);
 
        if (line.length() > 1) {
            line = line.substr(1);
            if (m_time_processor.export_remaining_time_enabled &&
                (line == reserved_tag(ETags::First_Line_M73_Placeholder) || line == reserved_tag(ETags::Last_Line_M73_Placeholder))) {
                for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
                    const TimeMachine& machine = m_time_processor.machines[i];
                    if (machine.enabled) {
                        // export pair <percent, remaining time>
                        export_lines.append_line(format_line_M73_main(machine.line_m73_main_mask.c_str(),
                            (line == reserved_tag(ETags::First_Line_M73_Placeholder)) ? 0 : 100,
                            (line == reserved_tag(ETags::First_Line_M73_Placeholder)) ? time_in_minutes(machine.time) : 0));
                        processed = true;
 
                        // export remaining time to next printer stop
                        if (line == reserved_tag(ETags::First_Line_M73_Placeholder) && !machine.stop_times.empty()) {
                            const int to_export_stop = time_in_minutes(machine.stop_times.front().elapsed_time);
                            export_lines.append_line(format_line_M73_stop_int(machine.line_m73_stop_mask.c_str(), to_export_stop));
                            last_exported_stop[i] = to_export_stop;
                        }
                    }
                }
            }
            else if (line == reserved_tag(ETags::Estimated_Printing_Time_Placeholder)) {
                for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
                    const TimeMachine& machine = m_time_processor.machines[i];
                    PrintEstimatedStatistics::ETimeMode mode = static_cast<PrintEstimatedStatistics::ETimeMode>(i);
                    if (mode == PrintEstimatedStatistics::ETimeMode::Normal || machine.enabled) {
                        char buf[128];
                        sprintf(buf, "; estimated printing time (%s mode) = %s\n",
                            (mode == PrintEstimatedStatistics::ETimeMode::Normal) ? "normal" : "silent",
                            get_time_dhms(machine.time).c_str());
                        export_lines.append_line(buf);
                        processed = true;
                    }
                }
                for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
                    const TimeMachine& machine = m_time_processor.machines[i];
                    PrintEstimatedStatistics::ETimeMode mode = static_cast<PrintEstimatedStatistics::ETimeMode>(i);
                    if (mode == PrintEstimatedStatistics::ETimeMode::Normal || machine.enabled) {
                        char buf[128];
                        sprintf(buf, "; estimated first layer printing time (%s mode) = %s\n",
                            (mode == PrintEstimatedStatistics::ETimeMode::Normal) ? "normal" : "silent",
                            get_time_dhms(machine.layers_time.empty() ? 0.f : machine.layers_time.front()).c_str());
                        export_lines.append_line(buf);
                        processed = true;
                    }
                }
            }
        }
 
        return processed;
    };
 
    std::vector<double> filament_mm(m_result.extruders_count, 0.0);
    std::vector<double> filament_cm3(m_result.extruders_count, 0.0);
    std::vector<double> filament_g(m_result.extruders_count, 0.0);
    std::vector<double> filament_cost(m_result.extruders_count, 0.0);
 
    double filament_total_g    = 0.0;
    double filament_total_cost = 0.0;
 
    for (const auto& [id, volume] : m_result.print_statistics.volumes_per_extruder) {
        filament_mm[id]   = volume / (static_cast<double>(M_PI) * sqr(0.5 * m_result.filament_diameters[id]));
        filament_cm3[id]  = volume * 0.001;
        filament_g[id]    = filament_cm3[id] * double(m_result.filament_densities[id]);
        filament_cost[id] = filament_g[id] * double(m_result.filament_cost[id]) * 0.001;
        filament_total_g    += filament_g[id];
        filament_total_cost += filament_cost[id];
    }
 
    auto process_used_filament = [&](std::string& gcode_line) {
        // Prefilter for parsing speed.
        if (gcode_line.size() < 8 || gcode_line[0] != ';' || gcode_line[1] != ' ')
            return false;
        if (const char c = gcode_line[2]; c != 'f' && c != 't')
            return false;
        auto process_tag = [](std::string& gcode_line, const std::string_view tag, const std::vector<double>& values) {
            if (boost::algorithm::starts_with(gcode_line, tag)) {
                gcode_line = tag;
                char buf[1024];
                for (size_t i = 0; i < values.size(); ++i) {
                    sprintf(buf, i == values.size() - 1 ? " %.2lf\n" : " %.2lf,", values[i]);
                    gcode_line += buf;
                }
                return true;
            }
            return false;
        };
 
        bool ret = false;
        ret |= process_tag(gcode_line, "; filament used [mm] =", filament_mm);
        ret |= process_tag(gcode_line, "; filament used [g] =", filament_g);
        ret |= process_tag(gcode_line, "; total filament used [g] =", { filament_total_g });
        ret |= process_tag(gcode_line, "; filament used [cm3] =", filament_cm3);
        ret |= process_tag(gcode_line, "; filament cost =", filament_cost);
        ret |= process_tag(gcode_line, "; total filament cost =", { filament_total_cost });
        return ret;
    };
 
    // check for temporary lines
    auto is_temporary_decoration = [](const std::string_view gcode_line) {
        // remove trailing '\n'
        assert(!gcode_line.empty());
        assert(gcode_line.back() == '\n');
 
        // return true for decorations which are used in processing the gcode but that should not be exported into the final gcode
        // i.e.:
        // bool ret = gcode_line.substr(0, gcode_line.length() - 1) == ";" + Layer_Change_Tag;
        // ...
        // return ret;
        return false;
    };
 
    // Iterators for the normal and silent cached time estimate entry recently processed, used by process_line_G1.
    auto g1_times_cache_it = Slic3r::reserve_vector<std::vector<TimeMachine::G1LinesCacheItem>::const_iterator>(m_time_processor.machines.size());
    for (const auto& machine : m_time_processor.machines)
        g1_times_cache_it.emplace_back(machine.g1_times_cache.begin());
 
    // add lines M73 to exported gcode
    auto process_line_G1 = [this,
        // Lambdas, mostly for string formatting, all with an empty capture block.
        time_in_minutes, format_time_float, format_line_M73_main, format_line_M73_stop_int, format_line_M73_stop_float, time_in_last_minute,
        // Caches, to be modified
        &g1_times_cache_it, &last_exported_main, &last_exported_stop,
        &export_lines]
        (const size_t g1_lines_counter) {
        if (m_time_processor.export_remaining_time_enabled) {
            for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
                const TimeMachine& machine = m_time_processor.machines[i];
                if (machine.enabled) {
                    // export pair <percent, remaining time>
                    // Skip all machine.g1_times_cache below g1_lines_counter.
                    auto& it = g1_times_cache_it[i];
                    while (it != machine.g1_times_cache.end() && it->id < g1_lines_counter)
                        ++it;
                    if (it != machine.g1_times_cache.end() && it->id == g1_lines_counter) {
                        std::pair<int, int> to_export_main = { int(100.0f * it->elapsed_time / machine.time),
                                                                time_in_minutes(machine.time - it->elapsed_time) };
                        if (last_exported_main[i] != to_export_main) {
                            export_lines.append_line(format_line_M73_main(machine.line_m73_main_mask.c_str(),
                                to_export_main.first, to_export_main.second));
                            last_exported_main[i] = to_export_main;
                        }
                        // export remaining time to next printer stop
                        auto it_stop = std::upper_bound(machine.stop_times.begin(), machine.stop_times.end(), it->elapsed_time,
                            [](float value, const TimeMachine::StopTime& t) { return value < t.elapsed_time; });
                        if (it_stop != machine.stop_times.end()) {
                            int to_export_stop = time_in_minutes(it_stop->elapsed_time - it->elapsed_time);
                            if (last_exported_stop[i] != to_export_stop) {
                                if (to_export_stop > 0) {
                                    if (last_exported_stop[i] != to_export_stop) {
                                        export_lines.append_line(format_line_M73_stop_int(machine.line_m73_stop_mask.c_str(), to_export_stop));
                                        last_exported_stop[i] = to_export_stop;
                                    }
                                }
                                else {
                                    bool is_last = false;
                                    auto next_it = it + 1;
                                    is_last |= (next_it == machine.g1_times_cache.end());
 
                                    if (next_it != machine.g1_times_cache.end()) {
                                        auto next_it_stop = std::upper_bound(machine.stop_times.begin(), machine.stop_times.end(), next_it->elapsed_time,
                                            [](float value, const TimeMachine::StopTime& t) { return value < t.elapsed_time; });
                                        is_last |= (next_it_stop != it_stop);
 
                                        std::string time_float_str = format_time_float(time_in_last_minute(it_stop->elapsed_time - it->elapsed_time));
                                        std::string next_time_float_str = format_time_float(time_in_last_minute(it_stop->elapsed_time - next_it->elapsed_time));
                                        is_last |= (string_to_double_decimal_point(time_float_str) > 0. && string_to_double_decimal_point(next_time_float_str) == 0.);
                                    }
 
                                    if (is_last) {
                                        if (std::distance(machine.stop_times.begin(), it_stop) == static_cast<ptrdiff_t>(machine.stop_times.size() - 1))
                                            export_lines.append_line(format_line_M73_stop_int(machine.line_m73_stop_mask.c_str(), to_export_stop));
                                        else
                                            export_lines.append_line(format_line_M73_stop_float(machine.line_m73_stop_mask.c_str(), time_in_last_minute(it_stop->elapsed_time - it->elapsed_time)));
 
                                        last_exported_stop[i] = to_export_stop;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    };
 
    // add lines XXX to exported gcode
    auto process_line_T = [this, &export_lines](const std::string& gcode_line, const size_t g1_lines_counter, const ExportLines::Backtrace& backtrace) {
        const std::string cmd = GCodeReader::GCodeLine::extract_cmd(gcode_line);
        if (cmd.size() >= 2) {
            std::stringstream ss(cmd.substr(1));
            int tool_number = -1;
            ss >> tool_number;
            if (tool_number != -1) {
                if (tool_number < 0 || (int)m_extruder_temps_config.size() <= tool_number) {
                    // found an invalid value, clamp it to a valid one
                    tool_number = std::clamp<int>(0, m_extruder_temps_config.size() - 1, tool_number);
                    // emit warning
                    std::string warning = _u8L("GCode Post-Processor encountered an invalid toolchange, maybe from a custom gcode:");
                    warning += "\n> ";
                    warning += gcode_line;
                    warning += _u8L("Generated M104 lines may be incorrect.");
                    BOOST_LOG_TRIVIAL(error) << warning;
                    if (m_print != nullptr)
                        m_print->active_step_add_warning(PrintStateBase::WarningLevel::CRITICAL, warning);
                }
            }
            export_lines.insert_lines(backtrace, cmd,
                // line inserter
                [tool_number, this](unsigned int id, float time, float time_diff) {
                    int temperature = int( m_layer_id != 1 ? m_extruder_temps_config[tool_number] : m_extruder_temps_first_layer_config[tool_number]);
                    const std::string out = "M104 T" + std::to_string(tool_number) + " P" + std::to_string(int(std::round(time_diff))) + " S" + std::to_string(temperature) + "\n";
                    return out;
                },
                // line replacer
                [this, tool_number](const std::string& line) {
                    if (GCodeReader::GCodeLine::cmd_is(line, "M104")) {
                        GCodeReader::GCodeLine gline;
                        GCodeReader reader;
                        reader.parse_line(line, [&gline](GCodeReader& reader, const GCodeReader::GCodeLine& l) { gline = l; });
 
                        float val;
                        if (gline.has_value('T', val) && gline.raw().find("cooldown") != std::string::npos && m_is_XL_printer) {
                            if (static_cast<int>(val) == tool_number)
                                return std::string("; removed M104\n");
                        }
                    }
                    return line;
                });
        }
    };
 
    m_result.lines_ends.clear();
 
    unsigned int line_id = 0;
    // Backtrace data for Tx gcode lines
    static const ExportLines::Backtrace backtrace_T = { 120.0f, 10 };
    // In case there are multiple sources of backtracing, keeps track of the longest backtrack time needed
    // to flush the backtrace cache accordingly
    float max_backtrace_time = 120.0f;
 
    {
        // Read the input stream 64kB at a time, extract lines and process them.
        std::vector<char> buffer(65536 * 10, 0);
        // Line buffer.
        assert(gcode_line.empty());
        for (;;) {
            size_t cnt_read = ::fread(buffer.data(), 1, buffer.size(), in.f);
            if (::ferror(in.f))
                throw Slic3r::RuntimeError(std::string("GCode processor post process export failed.\nError while reading from file.\n"));
            bool eof = cnt_read == 0;
            auto it = buffer.begin();
            auto it_bufend = buffer.begin() + cnt_read;
            while (it != it_bufend || (eof && !gcode_line.empty())) {
                // Find end of line.
                bool eol = false;
                auto it_end = it;
                for (; it_end != it_bufend && !(eol = *it_end == '\r' || *it_end == '\n'); ++it_end);
                // End of line is indicated also if end of file was reached.
                eol |= eof && it_end == it_bufend;
                gcode_line.insert(gcode_line.end(), it, it_end);
                if (eol) {
                    ++line_id;
                    export_lines.update(line_id, g1_lines_counter);
 
                    gcode_line += "\n";
                    // replace placeholder lines
                    bool processed = process_placeholders(gcode_line);
                    if (processed)
                        gcode_line.clear();
                    if (!processed)
                        processed = process_used_filament(gcode_line);
                    if (!processed && !is_temporary_decoration(gcode_line)) {
                        if (GCodeReader::GCodeLine::cmd_is(gcode_line, "G1"))
                            // add lines M73 where needed
                            process_line_G1(g1_lines_counter++);
                        else if (m_result.backtrace_enabled && GCodeReader::GCodeLine::cmd_starts_with(gcode_line, "T")) {
                            // add lines XXX where needed
                            process_line_T(gcode_line, g1_lines_counter, backtrace_T);
                            max_backtrace_time = std::max(max_backtrace_time, backtrace_T.time);
                        }
                    }
 
                    if (!gcode_line.empty())
                        export_lines.append_line(gcode_line);
                    export_lines.write(out, 1.1f * max_backtrace_time, m_result, out_path);
                    gcode_line.clear();
                }
                // Skip EOL.
                it = it_end;
                if (it != it_bufend && *it == '\r')
                    ++it;
                if (it != it_bufend && *it == '\n')
                    ++it;
            }
            if (eof)
                break;
        }
    }
 
    export_lines.flush(out, m_result, out_path);
 
    out.close();
    in.close();
 
    export_lines.synchronize_moves(m_result);
 
    if (rename_file(out_path, m_result.filename))
        throw Slic3r::RuntimeError(std::string("Failed to rename the output G-code file from ") + out_path + " to " + m_result.filename + '\n' +
            "Is " + out_path + " locked?" + '\n');
}

Referenced by finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_bambustudio_tags()

bool Slic3r::GCodeProcessor::process_bambustudio_tags ( const std::string_view comment )

private

{
    // extrusion roles
 
    std::string tag = "FEATURE: ";
    size_t pos = comment.find(tag);
    if (pos != comment.npos) {
        const std::string_view type = comment.substr(pos + tag.length());
        if (type == "Custom")
            set_extrusion_role(GCodeExtrusionRole::Custom);
        else if (type == "Inner wall")
            set_extrusion_role(GCodeExtrusionRole::Perimeter);
        else if (type == "Outer wall")
            set_extrusion_role(GCodeExtrusionRole::ExternalPerimeter);
        else if (type == "Overhang wall")
            set_extrusion_role(GCodeExtrusionRole::OverhangPerimeter);
        else if (type == "Gap infill")
            set_extrusion_role(GCodeExtrusionRole::GapFill);
        else if (type == "Bridge")
            set_extrusion_role(GCodeExtrusionRole::BridgeInfill);
        else if (type == "Sparse infill")
            set_extrusion_role(GCodeExtrusionRole::InternalInfill);
        else if (type == "Internal solid infill")
            set_extrusion_role(GCodeExtrusionRole::SolidInfill);
        else if (type == "Top surface")
            set_extrusion_role(GCodeExtrusionRole::TopSolidInfill);
        else if (type == "Bottom surface")
            set_extrusion_role(GCodeExtrusionRole::None);
        else if (type == "Ironing")
            set_extrusion_role(GCodeExtrusionRole::Ironing);
        else if (type == "Skirt")
            set_extrusion_role(GCodeExtrusionRole::Skirt);
        else if (type == "Brim")
            set_extrusion_role(GCodeExtrusionRole::Skirt);
        else if (type == "Support")
            set_extrusion_role(GCodeExtrusionRole::SupportMaterial);
        else if (type == "Support interface")
            set_extrusion_role(GCodeExtrusionRole::SupportMaterialInterface);
        else if (type == "Support transition")
            set_extrusion_role(GCodeExtrusionRole::None);
        else if (type == "Prime tower")
            set_extrusion_role(GCodeExtrusionRole::WipeTower);
        else {
            set_extrusion_role(GCodeExtrusionRole::None);
            BOOST_LOG_TRIVIAL(warning) << "GCodeProcessor found unknown extrusion role: " << type;
        }
 
        if (m_extrusion_role == GCodeExtrusionRole::ExternalPerimeter)
            m_seams_detector.activate(true);
 
        return true;
    }
 
    return false;
}

References Slic3r::GCodeProcessor::SeamsDetector::activate(), Slic3r::BridgeInfill, comment, Slic3r::Custom, Slic3r::ExternalPerimeter, Slic3r::GapFill, Slic3r::InternalInfill, Slic3r::Ironing, m_extrusion_role, m_seams_detector, Slic3r::None, Slic3r::OverhangPerimeter, Slic3r::Perimeter, set_extrusion_role(), Slic3r::Skirt, Slic3r::SolidInfill, Slic3r::SupportMaterial, Slic3r::SupportMaterialInterface, Slic3r::TopSolidInfill, and Slic3r::WipeTower.

Referenced by process_producers_tags().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_buffer()

void Slic3r::GCodeProcessor::process_buffer ( const std::string & buffer )

{
    //FIXME maybe cache GCodeLine gline to be over multiple parse_buffer() invocations.
    m_parser.parse_buffer(buffer, [this](GCodeReader&, const GCodeReader::GCodeLine& line) { 
        this->process_gcode_line(line, false);
    });
}

References m_parser, Slic3r::GCodeReader::parse_buffer(), and process_gcode_line().

Referenced by Slic3r::GCode::GCodeOutputStream::write().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_craftware_tags()

bool Slic3r::GCodeProcessor::process_craftware_tags ( const std::string_view comment )

private

{
    // segType -> extrusion role
    std::string tag = "segType:";
    size_t pos = comment.find(tag);
    if (pos != comment.npos) {
        const std::string_view type = comment.substr(pos + tag.length());
        if (type == "Skirt")
            set_extrusion_role(GCodeExtrusionRole::Skirt);
        else if (type == "Perimeter")
            set_extrusion_role(GCodeExtrusionRole::ExternalPerimeter);
        else if (type == "HShell")
            set_extrusion_role(GCodeExtrusionRole::None); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        else if (type == "InnerHair")
            set_extrusion_role(GCodeExtrusionRole::None); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        else if (type == "Loop")
            set_extrusion_role(GCodeExtrusionRole::None); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        else if (type == "Infill")
            set_extrusion_role(GCodeExtrusionRole::InternalInfill);
        else if (type == "Raft")
            set_extrusion_role(GCodeExtrusionRole::Skirt);
        else if (type == "Support")
            set_extrusion_role(GCodeExtrusionRole::SupportMaterial);
        else if (type == "SupportTouch")
            set_extrusion_role(GCodeExtrusionRole::SupportMaterial);
        else if (type == "SoftSupport")
            set_extrusion_role(GCodeExtrusionRole::SupportMaterialInterface);
        else if (type == "Pillar")
            set_extrusion_role(GCodeExtrusionRole::WipeTower);
        else {
            set_extrusion_role(GCodeExtrusionRole::None);
            BOOST_LOG_TRIVIAL(warning) << "GCodeProcessor found unknown extrusion role: " << type;
        }
 
        if (m_extrusion_role == GCodeExtrusionRole::ExternalPerimeter)
            m_seams_detector.activate(true);
 
        return true;
    }
 
    // layer
    pos = comment.find(" Layer #");
    if (pos == 0) {
        ++m_layer_id;
        return true;
    }
 
    return false;
}

References Slic3r::GCodeProcessor::SeamsDetector::activate(), comment, Slic3r::ExternalPerimeter, Slic3r::InternalInfill, m_extrusion_role, m_layer_id, m_seams_detector, Slic3r::None, set_extrusion_role(), Slic3r::Skirt, Slic3r::SupportMaterial, Slic3r::SupportMaterialInterface, and Slic3r::WipeTower.

Referenced by process_producers_tags().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_cura_tags()

bool Slic3r::GCodeProcessor::process_cura_tags ( const std::string_view comment )

private

{
    // TYPE -> extrusion role
    std::string tag = "TYPE:";
    size_t pos = comment.find(tag);
    if (pos != comment.npos) {
        const std::string_view type = comment.substr(pos + tag.length());
        if (type == "SKIRT")
            set_extrusion_role(GCodeExtrusionRole::Skirt);
        else if (type == "WALL-OUTER")
            set_extrusion_role(GCodeExtrusionRole::ExternalPerimeter);
        else if (type == "WALL-INNER")
            set_extrusion_role(GCodeExtrusionRole::Perimeter);
        else if (type == "SKIN")
            set_extrusion_role(GCodeExtrusionRole::SolidInfill);
        else if (type == "FILL")
            set_extrusion_role(GCodeExtrusionRole::InternalInfill);
        else if (type == "SUPPORT")
            set_extrusion_role(GCodeExtrusionRole::SupportMaterial);
        else if (type == "SUPPORT-INTERFACE")
            set_extrusion_role(GCodeExtrusionRole::SupportMaterialInterface);
        else if (type == "PRIME-TOWER")
            set_extrusion_role(GCodeExtrusionRole::WipeTower);
        else {
            set_extrusion_role(GCodeExtrusionRole::None);
            BOOST_LOG_TRIVIAL(warning) << "GCodeProcessor found unknown extrusion role: " << type;
        }
 
        if (m_extrusion_role == GCodeExtrusionRole::ExternalPerimeter)
            m_seams_detector.activate(true);
 
        return true;
    }
 
    // flavor
    tag = "FLAVOR:";
    pos = comment.find(tag);
    if (pos != comment.npos) {
        const std::string_view flavor = comment.substr(pos + tag.length());
        if (flavor == "BFB")
            m_flavor = gcfMarlinLegacy; // is this correct ?
        else if (flavor == "Mach3")
            m_flavor = gcfMach3;
        else if (flavor == "Makerbot")
            m_flavor = gcfMakerWare;
        else if (flavor == "UltiGCode")
            m_flavor = gcfMarlinLegacy; // is this correct ?
        else if (flavor == "Marlin(Volumetric)")
            m_flavor = gcfMarlinLegacy; // is this correct ?
        else if (flavor == "Griffin")
            m_flavor = gcfMarlinLegacy; // is this correct ?
        else if (flavor == "Repetier")
            m_flavor = gcfRepetier;
        else if (flavor == "RepRap")
            m_flavor = gcfRepRapFirmware;
        else if (flavor == "Marlin")
            m_flavor = gcfMarlinLegacy;
        else
            BOOST_LOG_TRIVIAL(warning) << "GCodeProcessor found unknown flavor: " << flavor;
 
        return true;
    }
 
    // layer
    tag = "LAYER:";
    pos = comment.find(tag);
    if (pos != comment.npos) {
        ++m_layer_id;
        return true;
    }
 
    return false;
}

References Slic3r::GCodeProcessor::SeamsDetector::activate(), comment, Slic3r::ExternalPerimeter, Slic3r::gcfMach3, Slic3r::gcfMakerWare, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepetier, Slic3r::gcfRepRapFirmware, Slic3r::InternalInfill, m_extrusion_role, m_flavor, m_layer_id, m_seams_detector, Slic3r::None, Slic3r::Perimeter, set_extrusion_role(), Slic3r::Skirt, Slic3r::SolidInfill, Slic3r::SupportMaterial, Slic3r::SupportMaterialInterface, and Slic3r::WipeTower.

Referenced by process_producers_tags().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_custom_gcode_time()

void Slic3r::GCodeProcessor::process_custom_gcode_time ( CustomGCode::Type code )

private

{
    for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
        TimeMachine& machine = m_time_processor.machines[i];
        if (!machine.enabled)
            continue;
 
        TimeMachine::CustomGCodeTime& gcode_time = machine.gcode_time;
        gcode_time.needed = true;
        //FIXME this simulates st_synchronize! is it correct?
        // The estimated time may be longer than the real print time.
        machine.simulate_st_synchronize();
        if (gcode_time.cache != 0.0f) {
            gcode_time.times.push_back({ code, gcode_time.cache });
            gcode_time.cache = 0.0f;
        }
    }
}

References Slic3r::GCodeProcessor::TimeMachine::CustomGCodeTime::cache, Slic3r::PrintEstimatedStatistics::Count, Slic3r::GCodeProcessor::TimeMachine::enabled, Slic3r::GCodeProcessor::TimeMachine::gcode_time, m_time_processor, Slic3r::GCodeProcessor::TimeProcessor::machines, Slic3r::GCodeProcessor::TimeMachine::CustomGCodeTime::needed, Slic3r::GCodeProcessor::TimeMachine::simulate_st_synchronize(), and Slic3r::GCodeProcessor::TimeMachine::CustomGCodeTime::times.

Referenced by process_tags().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_filaments()

void Slic3r::GCodeProcessor::process_filaments ( CustomGCode::Type code )

private

{
    if (code == CustomGCode::ColorChange)
        m_used_filaments.process_color_change_cache();
 
    if (code == CustomGCode::ToolChange)
        m_used_filaments.process_extruder_cache(m_extruder_id);
}

References Slic3r::CustomGCode::ColorChange, m_extruder_id, m_used_filaments, Slic3r::GCodeProcessor::UsedFilaments::process_color_change_cache(), Slic3r::GCodeProcessor::UsedFilaments::process_extruder_cache(), and Slic3r::CustomGCode::ToolChange.

Referenced by process_T(), and process_tags().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_file()

void Slic3r::GCodeProcessor::process_file	(	const std::string &	filename,
		std::function< void()>	cancel_callback = `nullptr`
	)

{
    CNumericLocalesSetter locales_setter;
 
#if ENABLE_GCODE_VIEWER_STATISTICS
    m_start_time = std::chrono::high_resolution_clock::now();
#endif // ENABLE_GCODE_VIEWER_STATISTICS
 
    // pre-processing
    // parse the gcode file to detect its producer
    {
        m_parser.parse_file_raw(filename, [this](GCodeReader& reader, const char *begin, const char *end) {
            begin = skip_whitespaces(begin, end);
            if (begin != end && *begin == ';') {
                // Comment.
                begin = skip_whitespaces(++ begin, end);
                end   = remove_eols(begin, end);
                if (begin != end && detect_producer(std::string_view(begin, end - begin)))
                    m_parser.quit_parsing();
            }
        });
        m_parser.reset();
 
        // if the gcode was produced by PrusaSlicer,
        // extract the config from it
        if (m_producer == EProducer::PrusaSlicer || m_producer == EProducer::Slic3rPE || m_producer == EProducer::Slic3r) {
            DynamicPrintConfig config;
            config.apply(FullPrintConfig::defaults());
            // Silently substitute unknown values by new ones for loading configurations from PrusaSlicer's own G-code.
            // Showing substitution log or errors may make sense, but we are not really reading many values from the G-code config,
            // thus a probability of incorrect substitution is low and the G-code viewer is a consumer-only anyways.
            config.load_from_gcode_file(filename, ForwardCompatibilitySubstitutionRule::EnableSilent);
            apply_config(config);
        }
        else {
            m_result.extruder_colors = DEFAULT_EXTRUDER_COLORS;
 
            if (m_producer == EProducer::Simplify3D)
                apply_config_simplify3d(filename);
            else if (m_producer == EProducer::SuperSlicer)
                apply_config_superslicer(filename);
            else if (m_producer == EProducer::KissSlicer)
                apply_config_kissslicer(filename);
 
            if (m_result.extruders_count == 0)
                m_result.extruders_count = MIN_EXTRUDERS_COUNT;
        }
    }
 
    // process gcode
    m_result.filename = filename;
    m_result.id = ++s_result_id;
    initialize_result_moves();
    size_t parse_line_callback_cntr = 10000;
    m_parser.parse_file(filename, [this, cancel_callback, &parse_line_callback_cntr](GCodeReader& reader, const GCodeReader::GCodeLine& line) {
        if (-- parse_line_callback_cntr == 0) {
            // Don't call the cancel_callback() too often, do it every at every 10000'th line.
            parse_line_callback_cntr = 10000;
            if (cancel_callback)
                cancel_callback();
        }
        this->process_gcode_line(line, true);
    }, m_result.lines_ends);
 
    // Don't post-process the G-code to update time stamps.
    this->finalize(false);
}

References Slic3r::ConfigBase::apply(), apply_config(), apply_config_kissslicer(), apply_config_simplify3d(), apply_config_superslicer(), DEFAULT_EXTRUDER_COLORS, detect_producer(), Slic3r::EnableSilent, Slic3r::GCodeProcessorResult::extruder_colors, Slic3r::GCodeProcessorResult::extruders_count, Slic3r::GCodeProcessorResult::filename, finalize(), Slic3r::GCodeProcessorResult::id, initialize_result_moves(), KissSlicer, Slic3r::GCodeProcessorResult::lines_ends, Slic3r::ConfigBase::load_from_gcode_file(), m_parser, m_producer, m_result, MIN_EXTRUDERS_COUNT, Slic3r::GCodeReader::parse_file(), Slic3r::GCodeReader::parse_file_raw(), process_gcode_line(), PrusaSlicer, Slic3r::GCodeReader::quit_parsing(), Slic3r::remove_eols(), Slic3r::GCodeReader::reset(), s_result_id, Simplify3D, Slic3r::skip_whitespaces(), Slic3r, Slic3rPE, and SuperSlicer.

Referenced by Slic3r::GUI::Plater::load_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_G0()

void Slic3r::GCodeProcessor::process_G0 ( const GCodeReader::GCodeLine & line )

private

{
    process_G1(line);
}

References process_G1().

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_G1() [1/2]

void Slic3r::GCodeProcessor::process_G1 ( const GCodeReader::GCodeLine & line )

private

{
    std::array<std::optional<double>, 4> g1_axes = { std::nullopt, std::nullopt, std::nullopt, std::nullopt };
    if (line.has_x()) g1_axes[X] = (double)line.x();
    if (line.has_y()) g1_axes[Y] = (double)line.y();
    if (line.has_z()) g1_axes[Z] = (double)line.z();
    if (line.has_e()) g1_axes[E] = (double)line.e();
    std::optional<double> g1_feedrate = std::nullopt;
    if (line.has_f()) g1_feedrate = (double)line.f();
    std::optional<std::string> g1_cmt = std::nullopt;
    if (!line.comment().empty()) g1_cmt = line.comment();
 
    process_G1(g1_axes, g1_feedrate, g1_cmt);
}

Referenced by process_G0(), process_G1(), process_G28(), process_G2_G3(), and process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_G1() [2/2]

void Slic3r::GCodeProcessor::process_G1	(	const std::array< std::optional< double >, 4 > &	axes = `{ std::nullopt, std::nullopt, std::nullopt, std::nullopt }`,
		std::optional< double >	feedrate = `std::nullopt`,
		std::optional< std::string >	cmt = `std::nullopt`
	)

private

{
    const float filament_diameter = (static_cast<size_t>(m_extruder_id) < m_result.filament_diameters.size()) ? m_result.filament_diameters[m_extruder_id] : m_result.filament_diameters.back();
    const float filament_radius = 0.5f * filament_diameter;
    const float area_filament_cross_section = static_cast<float>(M_PI) * sqr(filament_radius);
 
    auto move_type = [this](const AxisCoords& delta_pos) {
        if (m_wiping)
            return EMoveType::Wipe;
        else if (delta_pos[E] < 0.0f)
            return (delta_pos[X] != 0.0f || delta_pos[Y] != 0.0f || delta_pos[Z] != 0.0f) ? EMoveType::Travel : EMoveType::Retract;
        else if (delta_pos[E] > 0.0f) {
            if (delta_pos[X] == 0.0f && delta_pos[Y] == 0.0f)
                return (delta_pos[Z] == 0.0f) ? EMoveType::Unretract : EMoveType::Travel;
            else if (delta_pos[X] != 0.0f || delta_pos[Y] != 0.0f)
                return EMoveType::Extrude;
        }
        else if (delta_pos[X] != 0.0f || delta_pos[Y] != 0.0f || delta_pos[Z] != 0.0f)
            return EMoveType::Travel;
 
        return EMoveType::Noop;
    };
 
    auto extract_absolute_position_on_axis = [&](Axis axis, std::optional<double> value, double area_filament_cross_section)
    {
        if (value.has_value()) {
            bool is_relative = (m_global_positioning_type == EPositioningType::Relative);
            if (axis == E)
                is_relative |= (m_e_local_positioning_type == EPositioningType::Relative);
 
            const double lengthsScaleFactor = (m_units == EUnits::Inches) ? double(INCHES_TO_MM) : 1.0;
            double ret = *value * lengthsScaleFactor;
            if (axis == E && m_use_volumetric_e)
                ret /= area_filament_cross_section;
            return is_relative ? m_start_position[axis] + ret : m_origin[axis] + ret;
        }
        else
            return m_start_position[axis];
    };
 
    ++m_g1_line_id;
 
    // enable processing of lines M201/M203/M204/M205
    m_time_processor.machine_envelope_processing_enabled = true;
 
    // updates axes positions from line
    for (unsigned char a = X; a <= E; ++a) {
        m_end_position[a] = extract_absolute_position_on_axis((Axis)a, axes[a], double(area_filament_cross_section));
    }
 
    // updates feedrate from line, if present
    if (feedrate.has_value())
        m_feedrate = m_feed_multiply.current * (*feedrate) * MMMIN_TO_MMSEC;
 
    // calculates movement deltas
    AxisCoords delta_pos;
    for (unsigned char a = X; a <= E; ++a)
        delta_pos[a] = m_end_position[a] - m_start_position[a];
 
    if (std::all_of(delta_pos.begin(), delta_pos.end(), [](double d) { return d == 0.; }))
        return;
 
    const float volume_extruded_filament = area_filament_cross_section * delta_pos[E];
 
    if (volume_extruded_filament != 0.)
        m_used_filaments.increase_caches(volume_extruded_filament, m_extruder_id, area_filament_cross_section * m_parking_position,
                                        area_filament_cross_section * m_extra_loading_move);
 
    const EMoveType type = move_type(delta_pos);
    if (type == EMoveType::Extrude) {
        const float delta_xyz = std::sqrt(sqr(delta_pos[X]) + sqr(delta_pos[Y]) + sqr(delta_pos[Z]));
        const float area_toolpath_cross_section = volume_extruded_filament / delta_xyz;
 
        // volume extruded filament / tool displacement = area toolpath cross section
        m_mm3_per_mm = area_toolpath_cross_section;
#if ENABLE_GCODE_VIEWER_DATA_CHECKING
        m_mm3_per_mm_compare.update(area_toolpath_cross_section, m_extrusion_role);
#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
 
        if (m_forced_height > 0.0f)
            m_height = m_forced_height;
        else if (m_layer_id == 0)
            m_height = m_first_layer_height + m_z_offset;
        else if (!cmt.has_value() || *cmt != INTERNAL_G2G3_TAG) {
            if (m_end_position[Z] > m_extruded_last_z + EPSILON && delta_pos[Z] == 0.0)
                m_height = m_end_position[Z] - m_extruded_last_z;
        }
 
        if (m_height == 0.0f)
            m_height = DEFAULT_TOOLPATH_HEIGHT;
 
        if (m_end_position[Z] == 0.0f || (m_extrusion_role == GCodeExtrusionRole::Custom && m_layer_id == 0))
            m_end_position[Z] = m_height;
 
        if (!cmt.has_value() || *cmt != INTERNAL_G2G3_TAG)
            m_extruded_last_z = m_end_position[Z];
        m_options_z_corrector.update(m_height);
 
#if ENABLE_GCODE_VIEWER_DATA_CHECKING
        m_height_compare.update(m_height, m_extrusion_role);
#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
 
        if (m_forced_width > 0.0f)
            m_width = m_forced_width;
        else if (m_extrusion_role == GCodeExtrusionRole::ExternalPerimeter)
            // cross section: rectangle
            m_width = delta_pos[E] * static_cast<float>(M_PI * sqr(1.05f * filament_radius)) / (delta_xyz * m_height);
        else if (m_extrusion_role == GCodeExtrusionRole::BridgeInfill || m_extrusion_role == GCodeExtrusionRole::None)
            // cross section: circle
            m_width = static_cast<float>(m_result.filament_diameters[m_extruder_id]) * std::sqrt(delta_pos[E] / delta_xyz);
        else
            // cross section: rectangle + 2 semicircles
            m_width = delta_pos[E] * static_cast<float>(M_PI * sqr(filament_radius)) / (delta_xyz * m_height) + static_cast<float>(1.0 - 0.25 * M_PI) * m_height;
 
        if (m_width == 0.0f)
            m_width = DEFAULT_TOOLPATH_WIDTH;
 
        // clamp width to avoid artifacts which may arise from wrong values of m_height
        m_width = std::min(m_width, std::max(2.0f, 4.0f * m_height));
 
#if ENABLE_GCODE_VIEWER_DATA_CHECKING
        m_width_compare.update(m_width, m_extrusion_role);
#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
    }
 
    // time estimate section
    auto move_length = [](const AxisCoords& delta_pos) {
        const float sq_xyz_length = sqr(delta_pos[X]) + sqr(delta_pos[Y]) + sqr(delta_pos[Z]);
        return (sq_xyz_length > 0.0f) ? std::sqrt(sq_xyz_length) : std::abs(delta_pos[E]);
    };
 
    auto is_extrusion_only_move = [](const AxisCoords& delta_pos) {
        return delta_pos[X] == 0.0f && delta_pos[Y] == 0.0f && delta_pos[Z] == 0.0f && delta_pos[E] != 0.0f;
    };
 
    const float distance = move_length(delta_pos);
    assert(distance != 0.0f);
    const float inv_distance = 1.0f / distance;
 
    for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
        TimeMachine& machine = m_time_processor.machines[i];
        if (!machine.enabled)
            continue;
 
        TimeMachine::State& curr = machine.curr;
        TimeMachine::State& prev = machine.prev;
        std::vector<TimeBlock>& blocks = machine.blocks;
 
        curr.feedrate = (delta_pos[E] == 0.0f) ? minimum_travel_feedrate(static_cast<PrintEstimatedStatistics::ETimeMode>(i), m_feedrate) :
            minimum_feedrate(static_cast<PrintEstimatedStatistics::ETimeMode>(i), m_feedrate);
 
        TimeBlock block;
        block.move_type = type;
        block.role = m_extrusion_role;
        block.distance = distance;
        block.g1_line_id = m_g1_line_id;
        block.layer_id = std::max<unsigned int>(1, m_layer_id);
 
        // calculates block cruise feedrate
        float min_feedrate_factor = 1.0f;
        for (unsigned char a = X; a <= E; ++a) {
            curr.axis_feedrate[a] = curr.feedrate * delta_pos[a] * inv_distance;
            if (a == E)
                curr.axis_feedrate[a] *= machine.extrude_factor_override_percentage;
 
            curr.abs_axis_feedrate[a] = std::abs(curr.axis_feedrate[a]);
            if (curr.abs_axis_feedrate[a] != 0.0f) {
                const float axis_max_feedrate = get_axis_max_feedrate(static_cast<PrintEstimatedStatistics::ETimeMode>(i), static_cast<Axis>(a));
                if (axis_max_feedrate != 0.0f)
                    min_feedrate_factor = std::min<float>(min_feedrate_factor, axis_max_feedrate / curr.abs_axis_feedrate[a]);
            }
        }
 
        block.feedrate_profile.cruise = min_feedrate_factor * curr.feedrate;
 
        if (min_feedrate_factor < 1.0f) {
            for (unsigned char a = X; a <= E; ++a) {
                curr.axis_feedrate[a] *= min_feedrate_factor;
                curr.abs_axis_feedrate[a] *= min_feedrate_factor;
            }
        }
 
        // calculates block acceleration
        float acceleration = (type == EMoveType::Travel) ? get_travel_acceleration(static_cast<PrintEstimatedStatistics::ETimeMode>(i)) :
            (is_extrusion_only_move(delta_pos) ? get_retract_acceleration(static_cast<PrintEstimatedStatistics::ETimeMode>(i)) :
            get_acceleration(static_cast<PrintEstimatedStatistics::ETimeMode>(i)));
 
        for (unsigned char a = X; a <= E; ++a) {
            const float axis_max_acceleration = get_axis_max_acceleration(static_cast<PrintEstimatedStatistics::ETimeMode>(i), static_cast<Axis>(a));
            if (acceleration * std::abs(delta_pos[a]) * inv_distance > axis_max_acceleration)
                acceleration = axis_max_acceleration;
        }
 
        block.acceleration = acceleration;
 
        // calculates block exit feedrate
        curr.safe_feedrate = block.feedrate_profile.cruise;
 
        for (unsigned char a = X; a <= E; ++a) {
            const float axis_max_jerk = get_axis_max_jerk(static_cast<PrintEstimatedStatistics::ETimeMode>(i), static_cast<Axis>(a));
            if (curr.abs_axis_feedrate[a] > axis_max_jerk)
                curr.safe_feedrate = std::min(curr.safe_feedrate, axis_max_jerk);
        }
 
        block.feedrate_profile.exit = curr.safe_feedrate;
 
        static const float PREVIOUS_FEEDRATE_THRESHOLD = 0.0001f;
 
        // calculates block entry feedrate
        float vmax_junction = curr.safe_feedrate;
        if (!blocks.empty() && prev.feedrate > PREVIOUS_FEEDRATE_THRESHOLD) {
            const bool prev_speed_larger = prev.feedrate > block.feedrate_profile.cruise;
            const float smaller_speed_factor = prev_speed_larger ? (block.feedrate_profile.cruise / prev.feedrate) : (prev.feedrate / block.feedrate_profile.cruise);
            // Pick the smaller of the nominal speeds. Higher speed shall not be achieved at the junction during coasting.
            vmax_junction = prev_speed_larger ? block.feedrate_profile.cruise : prev.feedrate;
 
            float v_factor = 1.0f;
            bool limited = false;
 
            for (unsigned char a = X; a <= E; ++a) {
                // Limit an axis. We have to differentiate coasting from the reversal of an axis movement, or a full stop.
                float v_exit = prev.axis_feedrate[a];
                float v_entry = curr.axis_feedrate[a];
 
                if (prev_speed_larger)
                    v_exit *= smaller_speed_factor;
 
                if (limited) {
                    v_exit *= v_factor;
                    v_entry *= v_factor;
                }
 
                // Calculate the jerk depending on whether the axis is coasting in the same direction or reversing a direction.
                const float jerk =
                  (v_exit > v_entry) ?
                  ((v_entry > 0.0f || v_exit < 0.0f) ?
                    // coasting
                    (v_exit - v_entry) :
                    // axis reversal
                    std::max(v_exit, -v_entry)) :
                  // v_exit <= v_entry
                  ((v_entry < 0.0f || v_exit > 0.0f) ?
                    // coasting
                    (v_entry - v_exit) :
                    // axis reversal
                    std::max(-v_exit, v_entry));
 
                const float axis_max_jerk = get_axis_max_jerk(static_cast<PrintEstimatedStatistics::ETimeMode>(i), static_cast<Axis>(a));
                if (jerk > axis_max_jerk) {
                    v_factor *= axis_max_jerk / jerk;
                    limited = true;
                }
            }
 
            if (limited)
                vmax_junction *= v_factor;
 
            // Now the transition velocity is known, which maximizes the shared exit / entry velocity while
            // respecting the jerk factors, it may be possible, that applying separate safe exit / entry velocities will achieve faster prints.
            const float vmax_junction_threshold = vmax_junction * 0.99f;
 
            // Not coasting. The machine will stop and start the movements anyway, better to start the segment from start.
            if (prev.safe_feedrate > vmax_junction_threshold && curr.safe_feedrate > vmax_junction_threshold)
                vmax_junction = curr.safe_feedrate;
        }
 
        const float v_allowable = max_allowable_speed(-acceleration, curr.safe_feedrate, block.distance);
        block.feedrate_profile.entry = std::min(vmax_junction, v_allowable);
 
        block.max_entry_speed = vmax_junction;
        block.flags.nominal_length = (block.feedrate_profile.cruise <= v_allowable);
        block.flags.recalculate = true;
        block.safe_feedrate = curr.safe_feedrate;
 
        // calculates block trapezoid
        block.calculate_trapezoid();
 
        // updates previous
        prev = curr;
 
        blocks.push_back(block);
 
        if (blocks.size() > TimeProcessor::Planner::refresh_threshold)
            machine.calculate_time(TimeProcessor::Planner::queue_size);
    }
 
    if (m_seams_detector.is_active()) {
        // check for seam starting vertex
        if (type == EMoveType::Extrude && m_extrusion_role == GCodeExtrusionRole::ExternalPerimeter && !m_seams_detector.has_first_vertex())
            m_seams_detector.set_first_vertex(m_result.moves.back().position - m_extruder_offsets[m_extruder_id]);
        // check for seam ending vertex and store the resulting move
        else if ((type != EMoveType::Extrude || (m_extrusion_role != GCodeExtrusionRole::ExternalPerimeter && m_extrusion_role != GCodeExtrusionRole::OverhangPerimeter)) && m_seams_detector.has_first_vertex()) {
            auto set_end_position = [this](const Vec3f& pos) {
                m_end_position[X] = pos.x(); m_end_position[Y] = pos.y(); m_end_position[Z] = pos.z();
            };
 
            const Vec3f curr_pos(m_end_position[X], m_end_position[Y], m_end_position[Z]);
            const Vec3f new_pos = m_result.moves.back().position - m_extruder_offsets[m_extruder_id];
            const std::optional<Vec3f> first_vertex = m_seams_detector.get_first_vertex();
            // the threshold value = 0.0625f == 0.25 * 0.25 is arbitrary, we may find some smarter condition later
 
            if ((new_pos - *first_vertex).squaredNorm() < 0.0625f) {
                set_end_position(0.5f * (new_pos + *first_vertex) + m_z_offset * Vec3f::UnitZ());
                store_move_vertex(EMoveType::Seam);
                set_end_position(curr_pos);
            }
 
            m_seams_detector.activate(false);
        }
    }
    else if (type == EMoveType::Extrude && m_extrusion_role == GCodeExtrusionRole::ExternalPerimeter) {
        m_seams_detector.activate(true);
        m_seams_detector.set_first_vertex(m_result.moves.back().position - m_extruder_offsets[m_extruder_id]);
    }
 
    if (m_spiral_vase_active && !m_result.spiral_vase_layers.empty()) {
        if (m_result.spiral_vase_layers.back().first == FLT_MAX && delta_pos[Z] >= 0.0)
            // replace layer height placeholder with correct value
            m_result.spiral_vase_layers.back().first = static_cast<float>(m_end_position[Z]);
        if (!m_result.moves.empty())
            m_result.spiral_vase_layers.back().second.second = m_result.moves.size() - 1;
    }
 
    // store move
    store_move_vertex(type, cmt.has_value() && *cmt == INTERNAL_G2G3_TAG);
}

Here is the call graph for this function:

◆ process_G10()

void Slic3r::GCodeProcessor::process_G10 ( const GCodeReader::GCodeLine & line )

private

{
    if (m_flavor == gcfRepRapFirmware) {
        // similar to M104/M109
        float new_temp;
        if (line.has_value('S', new_temp)) {
            size_t id = m_extruder_id;
            float val;
            if (line.has_value('P', val)) {
                const size_t eid = static_cast<size_t>(val);
                if (eid < m_extruder_temps.size())
                    id = eid;
            }
 
            m_extruder_temps[id] = new_temp;
            return;
        }
    }
 
    // stores retract move
    store_move_vertex(EMoveType::Retract);
}

References Slic3r::gcfRepRapFirmware, Slic3r::GCodeReader::GCodeLine::has_value(), m_extruder_id, m_extruder_temps, m_flavor, Slic3r::Retract, and store_move_vertex().

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_G11()

void Slic3r::GCodeProcessor::process_G11 ( const GCodeReader::GCodeLine & line )

private

{
    // stores unretract move
    store_move_vertex(EMoveType::Unretract);
}

References store_move_vertex(), and Slic3r::Unretract.

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_G20()

void Slic3r::GCodeProcessor::process_G20 ( const GCodeReader::GCodeLine & line )

private

{
    m_units = EUnits::Inches;
}

References Inches, and m_units.

Referenced by process_gcode_line().

Here is the caller graph for this function:

◆ process_G21()

void Slic3r::GCodeProcessor::process_G21 ( const GCodeReader::GCodeLine & line )

private

{
    m_units = EUnits::Millimeters;
}

References m_units, and Millimeters.

Referenced by process_gcode_line().

Here is the caller graph for this function:

◆ process_G22()

void Slic3r::GCodeProcessor::process_G22 ( const GCodeReader::GCodeLine & line )

private

{
    // stores retract move
    store_move_vertex(EMoveType::Retract);
}

References Slic3r::Retract, and store_move_vertex().

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_G23()

void Slic3r::GCodeProcessor::process_G23 ( const GCodeReader::GCodeLine & line )

private

{
    // stores unretract move
    store_move_vertex(EMoveType::Unretract);
}

References store_move_vertex(), and Slic3r::Unretract.

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_G28()

void Slic3r::GCodeProcessor::process_G28 ( const GCodeReader::GCodeLine & line )

private

{
    std::string_view cmd = line.cmd();
    std::string new_line_raw = { cmd.data(), cmd.size() };
    bool found = false;
    if (line.has('X')) {
        new_line_raw += " X0";
        found = true;
    }
    if (line.has('Y')) {
        new_line_raw += " Y0";
        found = true;
    }
    if (line.has('Z')) {
        new_line_raw += " Z0";
        found = true;
    }
    if (!found)
        new_line_raw += " X0  Y0  Z0";
 
    GCodeReader::GCodeLine new_gline;
    GCodeReader reader;
    reader.parse_line(new_line_raw, [&](GCodeReader& reader, const GCodeReader::GCodeLine& gline) { new_gline = gline; });
    process_G1(new_gline);
}

References Slic3r::GCodeReader::GCodeLine::cmd(), cmd, Slic3r::GCodeReader::GCodeLine::has(), Slic3r::GCodeReader::parse_line(), and process_G1().

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_G2_G3()

void Slic3r::GCodeProcessor::process_G2_G3	(	const GCodeReader::GCodeLine &	line,
		bool	clockwise
	)

private

{
    if (!line.has('I') || !line.has('J'))
        return;
 
    // relative center
    Vec3f rel_center = Vec3f::Zero();
    if (!line.has_value('I', rel_center.x()) || !line.has_value('J', rel_center.y()))
        return;
 
    // scale center, if needed
    if (m_units == EUnits::Inches)
        rel_center *= INCHES_TO_MM;
 
    struct Arc
    {
        Vec3d start{ Vec3d::Zero() };
        Vec3d end{ Vec3d::Zero() };
        Vec3d center{ Vec3d::Zero() };
 
        double angle{ 0.0 };
        double delta_x() const { return end.x() - start.x(); }
        double delta_y() const { return end.y() - start.y(); }
        double delta_z() const { return end.z() - start.z(); }
 
        double length() const { return angle * start_radius(); }
        double travel_length() const { return std::sqrt(sqr(length()) + sqr(delta_z())); }
        double start_radius() const { return (start - center).norm(); }
        double end_radius() const { return (end - center).norm(); }
 
        Vec3d relative_start() const { return start - center; }
        Vec3d relative_end() const { return end - center; }
 
        bool is_full_circle() const { return std::abs(delta_x()) < EPSILON && std::abs(delta_y()) < EPSILON; }
    };
 
    Arc arc;
 
    // arc start endpoint
    arc.start = Vec3d(m_start_position[X], m_start_position[Y], m_start_position[Z]);
 
    // arc center
    arc.center = arc.start + rel_center.cast<double>();
 
    const float filament_diameter = (static_cast<size_t>(m_extruder_id) < m_result.filament_diameters.size()) ? m_result.filament_diameters[m_extruder_id] : m_result.filament_diameters.back();
    const float filament_radius = 0.5f * filament_diameter;
    const float area_filament_cross_section = static_cast<float>(M_PI) * sqr(filament_radius);
 
    AxisCoords end_position = m_start_position;
    for (unsigned char a = X; a <= E; ++a) {
        end_position[a] = extract_absolute_position_on_axis((Axis)a, line, double(area_filament_cross_section));
    }
 
    // arc end endpoint
    arc.end = Vec3d(end_position[X], end_position[Y], end_position[Z]);
 
    // radii
    if (std::abs(arc.end_radius() - arc.start_radius()) > EPSILON) {
        // what to do ???
    }
 
    // updates feedrate from line
    std::optional<float> feedrate;
    if (line.has_f())
        feedrate = m_feed_multiply.current * line.f() * MMMIN_TO_MMSEC;
 
    // updates extrusion from line
    std::optional<float> extrusion;
    if (line.has_e())
        extrusion = end_position[E] - m_start_position[E];
 
    // relative arc endpoints
    const Vec3d rel_arc_start = arc.relative_start();
    const Vec3d rel_arc_end   = arc.relative_end();
 
    // arc angle
    if (arc.is_full_circle())
        arc.angle = 2.0 * PI;
    else {
        arc.angle = std::atan2(rel_arc_start.x() * rel_arc_end.y() - rel_arc_start.y() * rel_arc_end.x(),
            rel_arc_start.x() * rel_arc_end.x() + rel_arc_start.y() * rel_arc_end.y());
        if (arc.angle < 0.0)
            arc.angle += 2.0 * PI;
        if (clockwise)
            arc.angle -= 2.0 * PI;
    }
 
    const double travel_length = arc.travel_length();
    if (travel_length < 0.001)
        return;
 
    auto adjust_target = [this, area_filament_cross_section](const AxisCoords& target, const AxisCoords& prev_position) {
        AxisCoords ret = target;
        if (m_global_positioning_type == EPositioningType::Relative) {
            for (unsigned char a = X; a <= E; ++a) {
                ret[a] -= prev_position[a];
            }
        }
        else if (m_e_local_positioning_type == EPositioningType::Relative)
            ret[E] -= prev_position[E];
 
        if (m_use_volumetric_e)
            ret[E] *= area_filament_cross_section;
 
        const double lengthsScaleFactor = (m_units == EUnits::Inches) ? double(INCHES_TO_MM) : 1.0;
        for (unsigned char a = X; a <= E; ++a) {
            ret[a] /= lengthsScaleFactor;
        }
        return ret;
    };
 
    auto internal_only_g1_line = [this](const AxisCoords& target, bool has_z, const std::optional<float>& feedrate, const std::optional<float>& extrusion) {
        std::array<std::optional<double>, 4> g1_axes = { target[X], target[Y], std::nullopt, std::nullopt };
        std::optional<double> g1_feedrate = std::nullopt;
        if (has_z)
            g1_axes[Z] = target[Z];
        if (feedrate.has_value())
            g1_feedrate = (double)*feedrate;
        if (extrusion.has_value())
            g1_axes[E] = target[E];
        std::optional<std::string> g1_cmt = INTERNAL_G2G3_TAG;
 
        process_G1(g1_axes, g1_feedrate, g1_cmt);
    };
 
    // calculate arc segments
    // reference:
    // Prusa-Firmware\Firmware\motion_control.cpp - mc_arc()
    // https://github.com/prusa3d/Prusa-Firmware/blob/MK3/Firmware/motion_control.cpp
 
    // segments count
    static const double MM_PER_ARC_SEGMENT = 1.0;
    const size_t segments = std::max<size_t>(std::floor(travel_length / MM_PER_ARC_SEGMENT), 1);
 
    const double inv_segment = 1.0 / double(segments);
    const double theta_per_segment = arc.angle  * inv_segment;
    const double z_per_segment = arc.delta_z() * inv_segment;
    const double extruder_per_segment = (extrusion.has_value()) ? *extrusion * inv_segment : 0.0;
 
    const double cos_T = 1.0 - 0.5 * sqr(theta_per_segment); // Small angle approximation
    const double sin_T = theta_per_segment;
 
    AxisCoords prev_target = m_start_position;
    AxisCoords arc_target;
 
    // Initialize the linear axis
    arc_target[Z] = m_start_position[Z];
 
    // Initialize the extruder axis
    arc_target[E] = m_start_position[E];
 
    static const size_t N_ARC_CORRECTION = 25;
    Vec3d curr_rel_arc_start = arc.relative_start();
    size_t count = 0;
 
    for (size_t i = 1; i < segments; ++i) {
        if (count < N_ARC_CORRECTION) {
            // Apply vector rotation matrix 
            const float r_axisi = curr_rel_arc_start.x() * sin_T + curr_rel_arc_start.y() * cos_T;
            curr_rel_arc_start.x() = curr_rel_arc_start.x() * cos_T - curr_rel_arc_start.y() * sin_T;
            curr_rel_arc_start.y() = r_axisi;
            ++count;
        }
        else {
            // Arc correction to radius vector. Computed only every N_ARC_CORRECTION increments.
            // Compute exact location by applying transformation matrix from initial radius vector(=-offset).
            const double cos_Ti = ::cos(i * theta_per_segment);
            const double sin_Ti = ::sin(i * theta_per_segment);
            curr_rel_arc_start.x() = -double(rel_center.x()) * cos_Ti + double(rel_center.y()) * sin_Ti;
            curr_rel_arc_start.y() = -double(rel_center.x()) * sin_Ti - double(rel_center.y()) * cos_Ti;
            count = 0;
        }
 
        // Update arc_target location
        arc_target[X] = arc.center.x() + curr_rel_arc_start.x();
        arc_target[Y] = arc.center.y() + curr_rel_arc_start.y();
        arc_target[Z] += z_per_segment;
        arc_target[E] += extruder_per_segment;
 
        m_start_position = m_end_position; // this is required because we are skipping the call to process_gcode_line()
        internal_only_g1_line(adjust_target(arc_target, prev_target), z_per_segment != 0.0, (i == 1) ? feedrate : std::nullopt, extrusion);
        prev_target = arc_target;
    }
 
    // Ensure last segment arrives at target location.
    m_start_position = m_end_position; // this is required because we are skipping the call to process_gcode_line()
    internal_only_g1_line(adjust_target(end_position, prev_target), arc.delta_z() != 0.0, (segments == 1) ? feedrate : std::nullopt, extrusion);
}

References Slic3r::angle(), cos(), Slic3r::GCodeProcessor::FeedMultiply::current, Slic3r::E, EPSILON, extract_absolute_position_on_axis(), Slic3r::GCodeReader::GCodeLine::f(), Slic3r::filament_diameter(), Slic3r::GCodeProcessorResult::filament_diameters, Slic3r::GCodeReader::GCodeLine::has(), Slic3r::GCodeReader::GCodeLine::has_e(), Slic3r::GCodeReader::GCodeLine::has_f(), Slic3r::GCodeReader::GCodeLine::has_value(), Inches, INCHES_TO_MM, INTERNAL_G2G3_TAG, m_e_local_positioning_type, m_end_position, m_extruder_id, m_feed_multiply, m_global_positioning_type, M_PI, m_result, m_start_position, m_units, m_use_volumetric_e, MMMIN_TO_MMSEC, PI, process_G1(), Relative, sin(), Slic3r::sqr(), Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_G60()

void Slic3r::GCodeProcessor::process_G60 ( const GCodeReader::GCodeLine & line )

private

{
    if (m_flavor == gcfMarlinLegacy || m_flavor == gcfMarlinFirmware)
        m_saved_position = m_end_position;
}

References Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, m_end_position, m_flavor, and m_saved_position.

Referenced by process_gcode_line().

Here is the caller graph for this function:

◆ process_G61()

void Slic3r::GCodeProcessor::process_G61 ( const GCodeReader::GCodeLine & line )

private

{
    if (m_flavor == gcfMarlinLegacy || m_flavor == gcfMarlinFirmware) {
        bool modified = false;
        if (line.has_x()) {
            m_end_position[X] = m_saved_position[X];
            modified = true;
        }
        if (line.has_y()) {
            m_end_position[Y] = m_saved_position[Y];
            modified = true;
        }
        if (line.has_z()) {
            m_end_position[Z] = m_saved_position[Z];
            modified = true;
        }
        if (line.has_e()) {
            m_end_position[E] = m_saved_position[E];
            modified = true;
        }
        if (line.has_f())
            m_feedrate = m_feed_multiply.current * line.f();
 
        if (!modified)
            m_end_position = m_saved_position;
 
 
        store_move_vertex(EMoveType::Travel);
    }
}

References Slic3r::GCodeProcessor::FeedMultiply::current, Slic3r::E, Slic3r::GCodeReader::GCodeLine::f(), Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::GCodeReader::GCodeLine::has_e(), Slic3r::GCodeReader::GCodeLine::has_f(), Slic3r::GCodeReader::GCodeLine::has_x(), Slic3r::GCodeReader::GCodeLine::has_y(), Slic3r::GCodeReader::GCodeLine::has_z(), m_end_position, m_feed_multiply, m_feedrate, m_flavor, m_saved_position, store_move_vertex(), Slic3r::Travel, Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_G90()

void Slic3r::GCodeProcessor::process_G90 ( const GCodeReader::GCodeLine & line )

private

{
    m_global_positioning_type = EPositioningType::Absolute;
}

References Absolute, and m_global_positioning_type.

Referenced by process_gcode_line().

Here is the caller graph for this function:

◆ process_G91()

void Slic3r::GCodeProcessor::process_G91 ( const GCodeReader::GCodeLine & line )

private

{
    m_global_positioning_type = EPositioningType::Relative;
}

References m_global_positioning_type, and Relative.

Referenced by process_gcode_line().

Here is the caller graph for this function:

◆ process_G92()

void Slic3r::GCodeProcessor::process_G92 ( const GCodeReader::GCodeLine & line )

private

{
    float lengths_scale_factor = (m_units == EUnits::Inches) ? INCHES_TO_MM : 1.0f;
    bool any_found = false;
 
    if (line.has_x()) {
        m_origin[X] = m_end_position[X] - line.x() * lengths_scale_factor;
        any_found = true;
    }
 
    if (line.has_y()) {
        m_origin[Y] = m_end_position[Y] - line.y() * lengths_scale_factor;
        any_found = true;
    }
 
    if (line.has_z()) {
        m_origin[Z] = m_end_position[Z] - line.z() * lengths_scale_factor;
        any_found = true;
    }
 
    if (line.has_e()) {
        // extruder coordinate can grow to the point where its float representation does not allow for proper addition with small increments,
        // we set the value taken from the G92 line as the new current position for it
        m_end_position[E] = line.e() * lengths_scale_factor;
        any_found = true;
    }
    else
        simulate_st_synchronize();
 
    if (!any_found && !line.has_unknown_axis()) {
        // The G92 may be called for axes that PrusaSlicer does not recognize, for example see GH issue #3510, 
        // where G92 A0 B0 is called although the extruder axis is till E.
        for (unsigned char a = X; a <= E; ++a) {
            m_origin[a] = m_end_position[a];
        }
    }
}

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_gcode_line()

void Slic3r::GCodeProcessor::process_gcode_line	(	const GCodeReader::GCodeLine &	line,
		bool	producers_enabled
	)

private

{
/* std::cout << line.raw() << std::endl; */
 
    ++m_line_id;
 
    // update start position
    m_start_position = m_end_position;
 
    const std::string_view cmd = line.cmd();
    if (cmd.length() > 1) {
        // process command lines
        switch (cmd[0])
        {
        case 'g':
        case 'G':
            switch (cmd.size()) {
            case 2:
                switch (cmd[1]) {
                case '0': { process_G0(line); break; }  // Move
                case '1': { process_G1(line); break; }  // Move
                case '2': { process_G2_G3(line, true); break; }   // CW Arc Move
                case '3': { process_G2_G3(line, false); break; }  // CCW Arc Move
                default: break;
                }
                break;
            case 3:
                switch (cmd[1]) {
                case '1':
                    switch (cmd[2]) {
                    case '0': { process_G10(line); break; } // Retract or Set tool temperature
                    case '1': { process_G11(line); break; } // Unretract
                    default: break;
                    }
                    break;
                case '2':
                    switch (cmd[2]) {
                    case '0': { process_G20(line); break; } // Set Units to Inches
                    case '1': { process_G21(line); break; } // Set Units to Millimeters
                    case '2': { process_G22(line); break; } // Firmware controlled retract
                    case '3': { process_G23(line); break; } // Firmware controlled unretract
                    case '8': { process_G28(line); break; } // Move to origin
                    default: break;
                    }
                    break;
                case '6':
                    switch (cmd[2]) {
                    case '0': { process_G60(line); break; } // Save Current Position
                    case '1': { process_G61(line); break; } // Return to Saved Position
                    default: break;
                    }
                    break;
                case '9':
                    switch (cmd[2]) {
                    case '0': { process_G90(line); break; } // Set to Absolute Positioning
                    case '1': { process_G91(line); break; } // Set to Relative Positioning
                    case '2': { process_G92(line); break; } // Set Position
                    default: break;
                    }
                    break;
                }
                break;
            default:
                break;
            }
            break;
        case 'm':
        case 'M':
            switch (cmd.size()) {
            case 2:
                switch (cmd[1]) {
                case '1': { process_M1(line); break; }   // Sleep or Conditional stop
                default: break;
                }
                break;
            case 3:
                switch (cmd[1]) {
                case '8':
                    switch (cmd[2]) {
                    case '2': { process_M82(line); break; }  // Set extruder to absolute mode
                    case '3': { process_M83(line); break; }  // Set extruder to relative mode
                    default: break;
                    }
                    break;
                default:
                    break;
                }
                break;
            case 4:
                switch (cmd[1]) {
                case '1':
                    switch (cmd[2]) {
                    case '0':
                        switch (cmd[3]) {
                        case '4': { process_M104(line); break; } // Set extruder temperature
                        case '6': { process_M106(line); break; } // Set fan speed
                        case '7': { process_M107(line); break; } // Disable fan
                        case '8': { process_M108(line); break; } // Set tool (Sailfish)
                        case '9': { process_M109(line); break; } // Set extruder temperature and wait
                        default: break;
                        }
                        break;
                    case '3':
                        switch (cmd[3]) {
                        case '2': { process_M132(line); break; } // Recall stored home offsets
                        case '5': { process_M135(line); break; } // Set tool (MakerWare)
                        default: break;
                        }
                        break;
                    default:
                        break;
                    }
                    break;
                case '2':
                    switch (cmd[2]) {
                    case '0':
                        switch (cmd[3]) {
                        case '1': { process_M201(line); break; } // Set max printing acceleration
                        case '3': { process_M203(line); break; } // Set maximum feedrate
                        case '4': { process_M204(line); break; } // Set default acceleration
                        case '5': { process_M205(line); break; } // Advanced settings
                        default: break;
                        }
                        break;
                    case '2':
                        switch (cmd[3]) {
                        case '0': { process_M220(line); break; } // Set Feedrate Percentage
                        case '1': { process_M221(line); break; } // Set extrude factor override percentage
                        default: break;
                        }
                        break;
                    default:
                        break;
                    }
                    break;
                case '4':
                    switch (cmd[2]) {
                    case '0':
                        switch (cmd[3]) {
                        case '1': { process_M401(line); break; } // Repetier: Store x, y and z position
                        case '2': { process_M402(line); break; } // Repetier: Go to stored position
                        default: break;
                        }
                        break;
                    default:
                        break;
                    }
                    break;
                case '5':
                    switch (cmd[2]) {
                    case '6':
                        switch (cmd[3]) {
                        case '6': { process_M566(line); break; } // Set allowable instantaneous speed change
                        default: break;
                        }
                        break;
                    default:
                        break;
                    }
                    break;
                case '7':
                    switch (cmd[2]) {
                    case '0':
                        switch (cmd[3]) {
                        case '2': { process_M702(line); break; } // Unload the current filament into the MK3 MMU2 unit at the end of print.
                        default: break;
                        }
                        break;
                    default:
                        break;
                    }
                    break;
                default:
                    break;
                }
                break;
            default:
                break;
            }
            break;
        case 't':
        case 'T':
            process_T(line); // Select Tool
            break;
        default:
            break;
        }
    }
    else {
        const std::string &comment = line.raw();
        if (comment.length() > 2 && comment.front() == ';')
            // Process tags embedded into comments. Tag comments always start at the start of a line
            // with a comment and continue with a tag without any whitespace separator.
            process_tags(comment.substr(1), producers_enabled);
    }
}

References Slic3r::GCodeReader::GCodeLine::cmd(), cmd, comment, m_end_position, m_line_id, m_start_position, process_G0(), process_G1(), process_G10(), process_G11(), process_G20(), process_G21(), process_G22(), process_G23(), process_G28(), process_G2_G3(), process_G60(), process_G61(), process_G90(), process_G91(), process_G92(), process_M1(), process_M104(), process_M106(), process_M107(), process_M108(), process_M109(), process_M132(), process_M135(), process_M201(), process_M203(), process_M204(), process_M205(), process_M220(), process_M221(), process_M401(), process_M402(), process_M566(), process_M702(), process_M82(), process_M83(), process_T(), process_tags(), and Slic3r::GCodeReader::GCodeLine::raw().

Referenced by process_buffer(), and process_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_ideamaker_tags()

bool Slic3r::GCodeProcessor::process_ideamaker_tags ( const std::string_view comment )

private

{
    // TYPE -> extrusion role
    std::string tag = "TYPE:";
    size_t pos = comment.find(tag);
    if (pos != comment.npos) {
        const std::string_view type = comment.substr(pos + tag.length());
        if (type == "RAFT")
            set_extrusion_role(GCodeExtrusionRole::Skirt);
        else if (type == "WALL-OUTER")
            set_extrusion_role(GCodeExtrusionRole::ExternalPerimeter);
        else if (type == "WALL-INNER")
            set_extrusion_role(GCodeExtrusionRole::Perimeter);
        else if (type == "SOLID-FILL")
            set_extrusion_role(GCodeExtrusionRole::SolidInfill);
        else if (type == "FILL")
            set_extrusion_role(GCodeExtrusionRole::InternalInfill);
        else if (type == "BRIDGE")
            set_extrusion_role(GCodeExtrusionRole::BridgeInfill);
        else if (type == "SUPPORT")
            set_extrusion_role(GCodeExtrusionRole::SupportMaterial);
        else {
            set_extrusion_role(GCodeExtrusionRole::None);
            BOOST_LOG_TRIVIAL(warning) << "GCodeProcessor found unknown extrusion role: " << type;
        }
 
        if (m_extrusion_role == GCodeExtrusionRole::ExternalPerimeter)
            m_seams_detector.activate(true);
 
        return true;
    }
 
    // geometry
    // width
    tag = "WIDTH:";
    pos = comment.find(tag);
    if (pos != comment.npos) {
        if (!parse_number(comment.substr(pos + tag.length()), m_forced_width))
            BOOST_LOG_TRIVIAL(error) << "GCodeProcessor encountered an invalid value for Width (" << comment << ").";
        return true;
    }
 
    // height
    tag = "HEIGHT:";
    pos = comment.find(tag);
    if (pos != comment.npos) {
        if (!parse_number(comment.substr(pos + tag.length()), m_forced_height))
            BOOST_LOG_TRIVIAL(error) << "GCodeProcessor encountered an invalid value for Height (" << comment << ").";
        return true;
    }
 
    // layer
    pos = comment.find("LAYER:");
    if (pos == 0) {
        ++m_layer_id;
        return true;
    }
 
    return false;
}

References Slic3r::GCodeProcessor::SeamsDetector::activate(), Slic3r::BridgeInfill, comment, error, Slic3r::ExternalPerimeter, Slic3r::InternalInfill, m_extrusion_role, m_forced_height, m_forced_width, m_layer_id, m_seams_detector, Slic3r::None, Slic3r::parse_number(), Slic3r::Perimeter, set_extrusion_role(), Slic3r::Skirt, Slic3r::SolidInfill, and Slic3r::SupportMaterial.

Referenced by process_producers_tags().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_kissslicer_tags()

bool Slic3r::GCodeProcessor::process_kissslicer_tags ( const std::string_view comment )

private

{
    // extrusion roles
 
    // ; 'Raft Path'
    size_t pos = comment.find(" 'Raft Path'");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::Skirt);
        return true;
    }
 
    // ; 'Support Interface Path'
    pos = comment.find(" 'Support Interface Path'");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::SupportMaterialInterface);
        return true;
    }
 
    // ; 'Travel/Ironing Path'
    pos = comment.find(" 'Travel/Ironing Path'");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::Ironing);
        return true;
    }
 
    // ; 'Support (may Stack) Path'
    pos = comment.find(" 'Support (may Stack) Path'");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::SupportMaterial);
        return true;
    }
 
    // ; 'Perimeter Path'
    pos = comment.find(" 'Perimeter Path'");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::ExternalPerimeter);
        m_seams_detector.activate(true);
        return true;
    }
 
    // ; 'Pillar Path'
    pos = comment.find(" 'Pillar Path'");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::None); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        return true;
    }
 
    // ; 'Destring/Wipe/Jump Path'
    pos = comment.find(" 'Destring/Wipe/Jump Path'");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::None); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        return true;
    }
 
    // ; 'Prime Pillar Path'
    pos = comment.find(" 'Prime Pillar Path'");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::None); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        return true;
    }
 
    // ; 'Loop Path'
    pos = comment.find(" 'Loop Path'");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::None); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        return true;
    }
 
    // ; 'Crown Path'
    pos = comment.find(" 'Crown Path'");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::None); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        return true;
    }
 
    // ; 'Solid Path'
    pos = comment.find(" 'Solid Path'");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::None);
        return true;
    }
 
    // ; 'Stacked Sparse Infill Path'
    pos = comment.find(" 'Stacked Sparse Infill Path'");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::InternalInfill);
        return true;
    }
 
    // ; 'Sparse Infill Path'
    pos = comment.find(" 'Sparse Infill Path'");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::SolidInfill);
        return true;
    }
 
    // geometry
 
    // layer
    pos = comment.find(" BEGIN_LAYER_");
    if (pos == 0) {
        ++m_layer_id;
        return true;
    }
 
    return false;
}

References Slic3r::GCodeProcessor::SeamsDetector::activate(), comment, Slic3r::ExternalPerimeter, Slic3r::InternalInfill, Slic3r::Ironing, m_layer_id, m_seams_detector, Slic3r::None, set_extrusion_role(), Slic3r::Skirt, Slic3r::SolidInfill, Slic3r::SupportMaterial, and Slic3r::SupportMaterialInterface.

Referenced by process_producers_tags().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_M1()

void Slic3r::GCodeProcessor::process_M1 ( const GCodeReader::GCodeLine & line )

private

{
    simulate_st_synchronize();
}

References simulate_st_synchronize().

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_M104()

void Slic3r::GCodeProcessor::process_M104 ( const GCodeReader::GCodeLine & line )

private

{
    float new_temp;
    if (line.has_value('S', new_temp)) {
        size_t id = m_extruder_id;
        float val;
        if (line.has_value('T', val)) {
            const size_t eid = static_cast<size_t>(val);
            if (eid < m_extruder_temps.size())
                id = eid;
        }
 
        m_extruder_temps[id] = new_temp;
    }
}

References Slic3r::GCodeReader::GCodeLine::has_value(), m_extruder_id, and m_extruder_temps.

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_M106()

void Slic3r::GCodeProcessor::process_M106 ( const GCodeReader::GCodeLine & line )

private

{
    if (!line.has('P')) {
        // The absence of P means the print cooling fan, so ignore anything else.
        float new_fan_speed;
        if (line.has_value('S', new_fan_speed))
            m_fan_speed = (100.0f / 255.0f) * new_fan_speed;
        else
            m_fan_speed = 100.0f;
    }
}

References Slic3r::GCodeReader::GCodeLine::has(), Slic3r::GCodeReader::GCodeLine::has_value(), and m_fan_speed.

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_M107()

void Slic3r::GCodeProcessor::process_M107 ( const GCodeReader::GCodeLine & line )

private

{
    m_fan_speed = 0.0f;
}

References m_fan_speed.

Referenced by process_gcode_line().

Here is the caller graph for this function:

◆ process_M108()

void Slic3r::GCodeProcessor::process_M108 ( const GCodeReader::GCodeLine & line )

private

{
    // These M-codes are used by Sailfish to change active tool.
    // They have to be processed otherwise toolchanges will be unrecognised
    // by the analyzer - see https://github.com/prusa3d/PrusaSlicer/issues/2566
 
    if (m_flavor != gcfSailfish)
        return;
 
    std::string cmd = line.raw();
    size_t pos = cmd.find("T");
    if (pos != std::string::npos)
        process_T(cmd.substr(pos));
}

References cmd, Slic3r::gcfSailfish, m_flavor, process_T(), and Slic3r::GCodeReader::GCodeLine::raw().

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_M109()

void Slic3r::GCodeProcessor::process_M109 ( const GCodeReader::GCodeLine & line )

private

{
    float new_temp;
    size_t id = (size_t)-1;
    if (line.has_value('R', new_temp)) {
        float val;
        if (line.has_value('T', val)) {
            const size_t eid = static_cast<size_t>(val);
            if (eid < m_extruder_temps.size())
                id = eid;
        }
        else
            id = m_extruder_id;
    }
    else if (line.has_value('S', new_temp))
        id = m_extruder_id;
 
    if (id != (size_t)-1)
        m_extruder_temps[id] = new_temp;
}

References Slic3r::GCodeReader::GCodeLine::has_value(), m_extruder_id, and m_extruder_temps.

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_M132()

void Slic3r::GCodeProcessor::process_M132 ( const GCodeReader::GCodeLine & line )

private

{
    // This command is used by Makerbot to load the current home position from EEPROM
    // see: https://github.com/makerbot/s3g/blob/master/doc/GCodeProtocol.md
    // Using this command to reset the axis origin to zero helps in fixing: https://github.com/prusa3d/PrusaSlicer/issues/3082
 
    if (line.has('X'))
        m_origin[X] = 0.0f;
 
    if (line.has('Y'))
        m_origin[Y] = 0.0f;
 
    if (line.has('Z'))
        m_origin[Z] = 0.0f;
 
    if (line.has('E'))
        m_origin[E] = 0.0f;
}

References Slic3r::E, Slic3r::GCodeReader::GCodeLine::has(), m_origin, Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_M135()

void Slic3r::GCodeProcessor::process_M135 ( const GCodeReader::GCodeLine & line )

private

{
    // These M-codes are used by MakerWare to change active tool.
    // They have to be processed otherwise toolchanges will be unrecognised
    // by the analyzer - see https://github.com/prusa3d/PrusaSlicer/issues/2566
 
    if (m_flavor != gcfMakerWare)
        return;
 
    std::string cmd = line.raw();
    size_t pos = cmd.find("T");
    if (pos != std::string::npos)
        process_T(cmd.substr(pos));
}

References cmd, Slic3r::gcfMakerWare, m_flavor, process_T(), and Slic3r::GCodeReader::GCodeLine::raw().

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_M201()

void Slic3r::GCodeProcessor::process_M201 ( const GCodeReader::GCodeLine & line )

private

{
    // see http://reprap.org/wiki/G-code#M201:_Set_max_printing_acceleration
    float factor = ((m_flavor != gcfRepRapSprinter && m_flavor != gcfRepRapFirmware) && m_units == EUnits::Inches) ? INCHES_TO_MM : 1.0f;
 
    for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
        if (static_cast<PrintEstimatedStatistics::ETimeMode>(i) == PrintEstimatedStatistics::ETimeMode::Normal ||
            m_time_processor.machine_envelope_processing_enabled) {
            if (line.has_x())
                set_option_value(m_time_processor.machine_limits.machine_max_acceleration_x, i, line.x() * factor);
 
            if (line.has_y())
                set_option_value(m_time_processor.machine_limits.machine_max_acceleration_y, i, line.y() * factor);
 
            if (line.has_z())
                set_option_value(m_time_processor.machine_limits.machine_max_acceleration_z, i, line.z() * factor);
 
            if (line.has_e())
                set_option_value(m_time_processor.machine_limits.machine_max_acceleration_e, i, line.e() * factor);
        }
    }
}

References Slic3r::PrintEstimatedStatistics::Count, Slic3r::GCodeReader::GCodeLine::e(), Slic3r::gcfRepRapFirmware, Slic3r::gcfRepRapSprinter, Slic3r::GCodeReader::GCodeLine::has_e(), Slic3r::GCodeReader::GCodeLine::has_x(), Slic3r::GCodeReader::GCodeLine::has_y(), Slic3r::GCodeReader::GCodeLine::has_z(), Inches, INCHES_TO_MM, m_flavor, m_time_processor, m_units, Slic3r::GCodeProcessor::TimeProcessor::machine_envelope_processing_enabled, Slic3r::GCodeProcessor::TimeProcessor::machine_limits, Slic3r::PrintEstimatedStatistics::Normal, Slic3r::set_option_value(), Slic3r::GCodeReader::GCodeLine::x(), Slic3r::GCodeReader::GCodeLine::y(), and Slic3r::GCodeReader::GCodeLine::z().

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_M203()

void Slic3r::GCodeProcessor::process_M203 ( const GCodeReader::GCodeLine & line )

private

{
    // see http://reprap.org/wiki/G-code#M203:_Set_maximum_feedrate
    if (m_flavor == gcfRepetier)
        return;
 
    // see http://reprap.org/wiki/G-code#M203:_Set_maximum_feedrate
    // http://smoothieware.org/supported-g-codes
    float factor = (m_flavor == gcfMarlinLegacy || m_flavor == gcfMarlinFirmware || m_flavor == gcfSmoothie) ? 1.0f : MMMIN_TO_MMSEC;
 
    for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
        if (static_cast<PrintEstimatedStatistics::ETimeMode>(i) == PrintEstimatedStatistics::ETimeMode::Normal ||
            m_time_processor.machine_envelope_processing_enabled) {
            if (line.has_x())
                set_option_value(m_time_processor.machine_limits.machine_max_feedrate_x, i, line.x() * factor);
 
            if (line.has_y())
                set_option_value(m_time_processor.machine_limits.machine_max_feedrate_y, i, line.y() * factor);
 
            if (line.has_z())
                set_option_value(m_time_processor.machine_limits.machine_max_feedrate_z, i, line.z() * factor);
 
            if (line.has_e())
                set_option_value(m_time_processor.machine_limits.machine_max_feedrate_e, i, line.e() * factor);
        }
    }
}

References Slic3r::PrintEstimatedStatistics::Count, Slic3r::GCodeReader::GCodeLine::e(), Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepetier, Slic3r::gcfSmoothie, Slic3r::GCodeReader::GCodeLine::has_e(), Slic3r::GCodeReader::GCodeLine::has_x(), Slic3r::GCodeReader::GCodeLine::has_y(), Slic3r::GCodeReader::GCodeLine::has_z(), m_flavor, m_time_processor, Slic3r::GCodeProcessor::TimeProcessor::machine_envelope_processing_enabled, Slic3r::GCodeProcessor::TimeProcessor::machine_limits, MMMIN_TO_MMSEC, Slic3r::PrintEstimatedStatistics::Normal, Slic3r::set_option_value(), Slic3r::GCodeReader::GCodeLine::x(), Slic3r::GCodeReader::GCodeLine::y(), and Slic3r::GCodeReader::GCodeLine::z().

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_M204()

void Slic3r::GCodeProcessor::process_M204 ( const GCodeReader::GCodeLine & line )

private

{
    float value;
    for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
        if (static_cast<PrintEstimatedStatistics::ETimeMode>(i) == PrintEstimatedStatistics::ETimeMode::Normal ||
            m_time_processor.machine_envelope_processing_enabled) {
            if (line.has_value('S', value)) {
                // Legacy acceleration format. This format is used by the legacy Marlin, MK2 or MK3 firmware
                // It is also generated by PrusaSlicer to control acceleration per extrusion type
                // (perimeters, first layer etc) when 'Marlin (legacy)' flavor is used.
                set_acceleration(static_cast<PrintEstimatedStatistics::ETimeMode>(i), value);
                set_travel_acceleration(static_cast<PrintEstimatedStatistics::ETimeMode>(i), value);
                if (line.has_value('T', value))
                    set_retract_acceleration(static_cast<PrintEstimatedStatistics::ETimeMode>(i), value);
            }
            else {
                // New acceleration format, compatible with the upstream Marlin.
                if (line.has_value('P', value))
                    set_acceleration(static_cast<PrintEstimatedStatistics::ETimeMode>(i), value);
                if (line.has_value('R', value))
                    set_retract_acceleration(static_cast<PrintEstimatedStatistics::ETimeMode>(i), value);
                if (line.has_value('T', value))
                    // Interpret the T value as the travel acceleration in the new Marlin format.
                    set_travel_acceleration(static_cast<PrintEstimatedStatistics::ETimeMode>(i), value);
            }
        }
    }
}

References Slic3r::PrintEstimatedStatistics::Count, Slic3r::GCodeReader::GCodeLine::has_value(), m_time_processor, Slic3r::GCodeProcessor::TimeProcessor::machine_envelope_processing_enabled, Slic3r::PrintEstimatedStatistics::Normal, set_acceleration(), set_retract_acceleration(), and set_travel_acceleration().

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_M205()

void Slic3r::GCodeProcessor::process_M205 ( const GCodeReader::GCodeLine & line )

private

{
    for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
        if (static_cast<PrintEstimatedStatistics::ETimeMode>(i) == PrintEstimatedStatistics::ETimeMode::Normal ||
            m_time_processor.machine_envelope_processing_enabled) {
            if (line.has_x()) {
                float max_jerk = line.x();
                set_option_value(m_time_processor.machine_limits.machine_max_jerk_x, i, max_jerk);
                set_option_value(m_time_processor.machine_limits.machine_max_jerk_y, i, max_jerk);
            }
 
            if (line.has_y())
                set_option_value(m_time_processor.machine_limits.machine_max_jerk_y, i, line.y());
 
            if (line.has_z())
                set_option_value(m_time_processor.machine_limits.machine_max_jerk_z, i, line.z());
 
            if (line.has_e())
                set_option_value(m_time_processor.machine_limits.machine_max_jerk_e, i, line.e());
 
            float value;
            if (line.has_value('S', value))
                set_option_value(m_time_processor.machine_limits.machine_min_extruding_rate, i, value);
 
            if (line.has_value('T', value))
                set_option_value(m_time_processor.machine_limits.machine_min_travel_rate, i, value);
        }
    }
}

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_M220()

void Slic3r::GCodeProcessor::process_M220 ( const GCodeReader::GCodeLine & line )

private

{
    if (m_flavor != gcfMarlinLegacy && m_flavor != gcfMarlinFirmware && m_flavor != gcfKlipper)
        return;
 
    if (line.has('B'))
        m_feed_multiply.saved = m_feed_multiply.current;
    float value;
    if (line.has_value('S', value))
        m_feed_multiply.current = value * 0.01f;
    if (line.has('R'))
        m_feed_multiply.current = m_feed_multiply.saved;
}

References Slic3r::GCodeProcessor::FeedMultiply::current, Slic3r::gcfKlipper, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::GCodeReader::GCodeLine::has(), Slic3r::GCodeReader::GCodeLine::has_value(), m_feed_multiply, m_flavor, and Slic3r::GCodeProcessor::FeedMultiply::saved.

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_M221()

void Slic3r::GCodeProcessor::process_M221 ( const GCodeReader::GCodeLine & line )

private

{
    float value_s;
    float value_t;
    if (line.has_value('S', value_s) && !line.has_value('T', value_t)) {
        value_s *= 0.01f;
        for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
            m_time_processor.machines[i].extrude_factor_override_percentage = value_s;
        }
    }
}

References Slic3r::PrintEstimatedStatistics::Count, Slic3r::GCodeReader::GCodeLine::has_value(), m_time_processor, and Slic3r::GCodeProcessor::TimeProcessor::machines.

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_M401()

void Slic3r::GCodeProcessor::process_M401 ( const GCodeReader::GCodeLine & line )

private

{
    if (m_flavor != gcfRepetier)
        return;
 
    for (unsigned char a = 0; a <= 3; ++a) {
        m_cached_position.position[a] = m_start_position[a];
    }
    m_cached_position.feedrate = m_feedrate;
}

References Slic3r::GCodeProcessor::CachedPosition::feedrate, Slic3r::gcfRepetier, m_cached_position, m_feedrate, m_flavor, m_start_position, and Slic3r::GCodeProcessor::CachedPosition::position.

Referenced by process_gcode_line().

Here is the caller graph for this function:

◆ process_M402()

void Slic3r::GCodeProcessor::process_M402 ( const GCodeReader::GCodeLine & line )

private

{
    if (m_flavor != gcfRepetier)
        return;
 
    // see for reference:
    // https://github.com/repetier/Repetier-Firmware/blob/master/src/ArduinoAVR/Repetier/Printer.cpp
    // void Printer::GoToMemoryPosition(bool x, bool y, bool z, bool e, float feed)
 
    bool has_xyz = !(line.has('X') || line.has('Y') || line.has('Z'));
 
    float p = FLT_MAX;
    for (unsigned char a = X; a <= Z; ++a) {
        if (has_xyz || line.has(a)) {
            p = m_cached_position.position[a];
            if (p != FLT_MAX)
                m_start_position[a] = p;
        }
    }
 
    p = m_cached_position.position[E];
    if (p != FLT_MAX)
        m_start_position[E] = p;
 
    p = FLT_MAX;
    if (!line.has_value(4, p))
        p = m_cached_position.feedrate;
 
    if (p != FLT_MAX)
        m_feedrate = p;
}

References Slic3r::E, Slic3r::GCodeProcessor::CachedPosition::feedrate, Slic3r::gcfRepetier, Slic3r::GCodeReader::GCodeLine::has(), Slic3r::GCodeReader::GCodeLine::has_value(), m_cached_position, m_feedrate, m_flavor, m_start_position, Slic3r::GCodeProcessor::CachedPosition::position, Slic3r::X, and Slic3r::Z.

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_M566()

void Slic3r::GCodeProcessor::process_M566 ( const GCodeReader::GCodeLine & line )

private

{
    for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
        if (line.has_x())
            set_option_value(m_time_processor.machine_limits.machine_max_jerk_x, i, line.x() * MMMIN_TO_MMSEC);
 
        if (line.has_y())
            set_option_value(m_time_processor.machine_limits.machine_max_jerk_y, i, line.y() * MMMIN_TO_MMSEC);
 
        if (line.has_z())
            set_option_value(m_time_processor.machine_limits.machine_max_jerk_z, i, line.z() * MMMIN_TO_MMSEC);
 
        if (line.has_e())
            set_option_value(m_time_processor.machine_limits.machine_max_jerk_e, i, line.e() * MMMIN_TO_MMSEC);
    }
}

References Slic3r::PrintEstimatedStatistics::Count, Slic3r::GCodeReader::GCodeLine::e(), Slic3r::GCodeReader::GCodeLine::has_e(), Slic3r::GCodeReader::GCodeLine::has_x(), Slic3r::GCodeReader::GCodeLine::has_y(), Slic3r::GCodeReader::GCodeLine::has_z(), m_time_processor, Slic3r::GCodeProcessor::TimeProcessor::machine_limits, MMMIN_TO_MMSEC, Slic3r::set_option_value(), Slic3r::GCodeReader::GCodeLine::x(), Slic3r::GCodeReader::GCodeLine::y(), and Slic3r::GCodeReader::GCodeLine::z().

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_M702()

void Slic3r::GCodeProcessor::process_M702 ( const GCodeReader::GCodeLine & line )

private

{
    if (line.has('C')) {
        // MK3 MMU2 specific M code:
        // M702 C is expected to be sent by the custom end G-code when finalizing a print.
        // The MK3 unit shall unload and park the active filament into the MMU2 unit.
        m_time_processor.extruder_unloaded = true;
        simulate_st_synchronize(get_filament_unload_time(m_extruder_id));
    }
}

References Slic3r::GCodeProcessor::TimeProcessor::extruder_unloaded, get_filament_unload_time(), Slic3r::GCodeReader::GCodeLine::has(), m_extruder_id, m_time_processor, and simulate_st_synchronize().

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_M82()

void Slic3r::GCodeProcessor::process_M82 ( const GCodeReader::GCodeLine & line )

private

{
    m_e_local_positioning_type = EPositioningType::Absolute;
}

References Absolute, and m_e_local_positioning_type.

Referenced by process_gcode_line().

Here is the caller graph for this function:

◆ process_M83()

void Slic3r::GCodeProcessor::process_M83 ( const GCodeReader::GCodeLine & line )

private

{
    m_e_local_positioning_type = EPositioningType::Relative;
}

References m_e_local_positioning_type, and Relative.

Referenced by process_gcode_line().

Here is the caller graph for this function:

◆ process_producers_tags()

bool Slic3r::GCodeProcessor::process_producers_tags ( const std::string_view comment )

private

{
    switch (m_producer)
    {
    case EProducer::Slic3rPE:
    case EProducer::Slic3r: 
    case EProducer::SuperSlicer:
    case EProducer::PrusaSlicer: { return process_prusaslicer_tags(comment); }
    case EProducer::Cura:        { return process_cura_tags(comment); }
    case EProducer::Simplify3D:  { return process_simplify3d_tags(comment); }
    case EProducer::CraftWare:   { return process_craftware_tags(comment); }
    case EProducer::ideaMaker:   { return process_ideamaker_tags(comment); }
    case EProducer::KissSlicer:  { return process_kissslicer_tags(comment); }
    case EProducer::BambuStudio: { return process_bambustudio_tags(comment); }
    default:                     { return false; }
    }
}

References BambuStudio, comment, CraftWare, Cura, ideaMaker, KissSlicer, m_producer, process_bambustudio_tags(), process_craftware_tags(), process_cura_tags(), process_ideamaker_tags(), process_kissslicer_tags(), process_prusaslicer_tags(), process_simplify3d_tags(), PrusaSlicer, Simplify3D, Slic3r, Slic3rPE, and SuperSlicer.

Referenced by process_tags().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_prusaslicer_tags()

bool Slic3r::GCodeProcessor::process_prusaslicer_tags ( const std::string_view comment )

private

{
    return false;
}

Referenced by process_producers_tags().

Here is the caller graph for this function:

◆ process_simplify3d_tags()

bool Slic3r::GCodeProcessor::process_simplify3d_tags ( const std::string_view comment )

private

{
    // extrusion roles
 
    // in older versions the comments did not contain the key 'feature'
    std::string_view cmt = comment;
    size_t pos = cmt.find(" feature");
    if (pos == 0)
        cmt.remove_prefix(8);
 
    // ; skirt
    pos = cmt.find(" skirt");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::Skirt);
        return true;
    }
    
    // ; outer perimeter
    pos = cmt.find(" outer perimeter");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::ExternalPerimeter);
        m_seams_detector.activate(true);
        return true;
    }
 
    // ; inner perimeter
    pos = cmt.find(" inner perimeter");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::Perimeter);
        return true;
    }
 
    // ; gap fill
    pos = cmt.find(" gap fill");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::GapFill);
        return true;
    }
 
    // ; infill
    pos = cmt.find(" infill");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::InternalInfill);
        return true;
    }
 
    // ; solid layer
    pos = cmt.find(" solid layer");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::SolidInfill);
        return true;
    }
 
    // ; bridge
    pos = cmt.find(" bridge");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::BridgeInfill);
        return true;
    }
 
    // ; support
    pos = cmt.find(" support");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::SupportMaterial);
        return true;
    }
 
    // ; dense support
    pos = cmt.find(" dense support");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::SupportMaterialInterface);
        return true;
    }
 
    // ; prime pillar
    pos = cmt.find(" prime pillar");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::WipeTower);
        return true;
    }
 
    // ; ooze shield
    pos = cmt.find(" ooze shield");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::None); // Missing mapping
        return true;
    }
 
    // ; raft
    pos = cmt.find(" raft");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::SupportMaterial);
        return true;
    }
 
    // ; internal single extrusion
    pos = cmt.find(" internal single extrusion");
    if (pos == 0) {
        set_extrusion_role(GCodeExtrusionRole::None); // Missing mapping
        return true;
    }
 
    // geometry
    // ; tool
    std::string tag = " tool";
    pos = cmt.find(tag);
    if (pos == 0) {
        const std::string_view data = cmt.substr(pos + tag.length());
        std::string h_tag = "H";
        size_t h_start = data.find(h_tag);
        size_t h_end = data.find_first_of(' ', h_start);
        std::string w_tag = "W";
        size_t w_start = data.find(w_tag);
        size_t w_end = data.find_first_of(' ', w_start);
        if (h_start != data.npos) {
            if (!parse_number(data.substr(h_start + 1, (h_end != data.npos) ? h_end - h_start - 1 : h_end), m_forced_height))
                BOOST_LOG_TRIVIAL(error) << "GCodeProcessor encountered an invalid value for Height (" << comment << ").";
        }
        if (w_start != data.npos) {
            if (!parse_number(data.substr(w_start + 1, (w_end != data.npos) ? w_end - w_start - 1 : w_end), m_forced_width))
                BOOST_LOG_TRIVIAL(error) << "GCodeProcessor encountered an invalid value for Width (" << comment << ").";
        }
 
        return true;
    }
 
    // ; layer | ;layer
    tag = "layer";
    pos = cmt.find(tag);
    if (pos == 0 || pos == 1) {
        // skip lines "; layer end"
        const std::string_view data = cmt.substr(pos + tag.length());
        size_t end_start = data.find("end");
        if (end_start == data.npos)
            ++m_layer_id;
 
        return true;
    }
 
    return false;
}

References Slic3r::GCodeProcessor::SeamsDetector::activate(), Slic3r::BridgeInfill, comment, error, Slic3r::ExternalPerimeter, Slic3r::GapFill, Slic3r::InternalInfill, m_forced_height, m_forced_width, m_layer_id, m_seams_detector, Slic3r::None, Slic3r::parse_number(), Slic3r::Perimeter, set_extrusion_role(), Slic3r::Skirt, Slic3r::SolidInfill, Slic3r::SupportMaterial, Slic3r::SupportMaterialInterface, and Slic3r::WipeTower.

Referenced by process_producers_tags().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_T() [1/2]

void Slic3r::GCodeProcessor::process_T ( const GCodeReader::GCodeLine & line )

private

{
    process_T(line.cmd());
}

References Slic3r::GCodeReader::GCodeLine::cmd(), and process_T().

Referenced by process_gcode_line(), process_M108(), process_M135(), and process_T().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_T() [2/2]

void Slic3r::GCodeProcessor::process_T ( const std::string_view command )

private

{
    if (command.length() > 1) {
        int eid = 0;
        if (! parse_number(command.substr(1), eid) || eid < 0 || eid > 255) {
            // Specific to the MMU2 V2 (see https://www.help.prusa3d.com/en/article/prusa-specific-g-codes_112173):
            if ((m_flavor == gcfMarlinLegacy || m_flavor == gcfMarlinFirmware) && (command == "Tx" || command == "Tc" || command == "T?"))
                return;
 
            // T-1 is a valid gcode line for RepRap Firmwares (used to deselects all tools) see https://github.com/prusa3d/PrusaSlicer/issues/5677
            if ((m_flavor != gcfRepRapFirmware && m_flavor != gcfRepRapSprinter) || eid != -1)
                BOOST_LOG_TRIVIAL(error) << "GCodeProcessor encountered an invalid toolchange (" << command << ").";
        }
        else {
            unsigned char id = static_cast<unsigned char>(eid);
            if (m_extruder_id != id) {
                if (((m_producer == EProducer::PrusaSlicer || m_producer == EProducer::Slic3rPE || m_producer == EProducer::Slic3r) && id >= m_result.extruders_count) ||
                    ((m_producer != EProducer::PrusaSlicer && m_producer != EProducer::Slic3rPE && m_producer != EProducer::Slic3r) && id >= m_result.extruder_colors.size()))
                    BOOST_LOG_TRIVIAL(error) << "GCodeProcessor encountered an invalid toolchange, maybe from a custom gcode (" << command << ").";
                else {
                    unsigned char old_extruder_id = m_extruder_id;
                    process_filaments(CustomGCode::ToolChange);
                    m_extruder_id = id;
                    m_cp_color.current = m_extruder_colors[id];
                    // Specific to the MK3 MMU2:
                    // The initial value of extruder_unloaded is set to true indicating
                    // that the filament is parked in the MMU2 unit and there is nothing to be unloaded yet.
                    float extra_time = get_filament_unload_time(static_cast<size_t>(old_extruder_id));
                    m_time_processor.extruder_unloaded = false;
                    extra_time += get_filament_load_time(static_cast<size_t>(m_extruder_id));
                    if (m_producer == EProducer::KissSlicer && m_flavor == gcfMarlinLegacy)
                        extra_time += m_kissslicer_toolchange_time_correction;
                    simulate_st_synchronize(extra_time);
 
                    // specific to single extruder multi material, set the new extruder temperature
                    // to match the old one
                    if (m_single_extruder_multi_material)
                        m_extruder_temps[m_extruder_id] = m_extruder_temps[old_extruder_id];
 
                    m_result.extruders_count = std::max<size_t>(m_result.extruders_count, m_extruder_id + 1);
                }
 
                // store tool change move
                store_move_vertex(EMoveType::Tool_change);
            }
        }
    }
}

References Slic3r::GCodeProcessor::CpColor::current, error, Slic3r::GCodeProcessorResult::extruder_colors, Slic3r::GCodeProcessor::TimeProcessor::extruder_unloaded, Slic3r::GCodeProcessorResult::extruders_count, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepRapFirmware, Slic3r::gcfRepRapSprinter, get_filament_load_time(), get_filament_unload_time(), KissSlicer, m_cp_color, m_extruder_colors, m_extruder_id, m_extruder_temps, m_flavor, m_kissslicer_toolchange_time_correction, m_producer, m_result, m_single_extruder_multi_material, m_time_processor, Slic3r::parse_number(), process_filaments(), PrusaSlicer, simulate_st_synchronize(), Slic3r, Slic3rPE, store_move_vertex(), Slic3r::Tool_change, and Slic3r::CustomGCode::ToolChange.

Here is the call graph for this function:

◆ process_tags()

void Slic3r::GCodeProcessor::process_tags	(	const std::string_view	comment,
		bool	producers_enabled
	)

private

{
    // producers tags
    if (producers_enabled && process_producers_tags(comment))
        return;
 
    // extrusion role tag
    if (boost::starts_with(comment, reserved_tag(ETags::Role))) {
        set_extrusion_role(string_to_gcode_extrusion_role(comment.substr(reserved_tag(ETags::Role).length())));
        if (m_extrusion_role == GCodeExtrusionRole::ExternalPerimeter)
            m_seams_detector.activate(true);
        return;
    }
 
    // wipe start tag
    if (boost::starts_with(comment, reserved_tag(ETags::Wipe_Start))) {
        m_wiping = true;
        return;
    }
 
    // wipe end tag
    if (boost::starts_with(comment, reserved_tag(ETags::Wipe_End))) {
        m_wiping = false;
        return;
    }
 
    if (!producers_enabled || m_producer == EProducer::PrusaSlicer) {
        // height tag
        if (boost::starts_with(comment, reserved_tag(ETags::Height))) {
            if (!parse_number(comment.substr(reserved_tag(ETags::Height).size()), m_forced_height))
                BOOST_LOG_TRIVIAL(error) << "GCodeProcessor encountered an invalid value for Height (" << comment << ").";
            return;
        }
        // width tag
        if (boost::starts_with(comment, reserved_tag(ETags::Width))) {
            if (!parse_number(comment.substr(reserved_tag(ETags::Width).size()), m_forced_width))
                BOOST_LOG_TRIVIAL(error) << "GCodeProcessor encountered an invalid value for Width (" << comment << ").";
            return;
        }
    }
 
    // color change tag
    if (boost::starts_with(comment, reserved_tag(ETags::Color_Change))) {
        unsigned char extruder_id = 0;
        static std::vector<std::string> Default_Colors = {
            "#0B2C7A", // { 0.043f, 0.173f, 0.478f }, // bluish
            "#1C8891", // { 0.110f, 0.533f, 0.569f },
            "#AAF200", // { 0.667f, 0.949f, 0.000f },
            "#F5CE0A", // { 0.961f, 0.808f, 0.039f },
            "#D16830", // { 0.820f, 0.408f, 0.188f },
            "#942616", // { 0.581f, 0.149f, 0.087f }  // reddish
        };
 
        std::string color = Default_Colors[0];
        auto is_valid_color = [](const std::string& color) {
            auto is_hex_digit = [](char c) {
                return ((c >= '0' && c <= '9') ||
                        (c >= 'A' && c <= 'F') ||
                        (c >= 'a' && c <= 'f'));
            };
 
            if (color[0] != '#' || color.length() != 7)
                return false;
            for (int i = 1; i <= 6; ++i) {
                if (!is_hex_digit(color[i]))
                    return false;
            }
            return true;
        };
 
        std::vector<std::string> tokens;
        boost::split(tokens, comment, boost::is_any_of(","), boost::token_compress_on);
        if (tokens.size() > 1) {
            if (tokens[1][0] == 'T') {
                int eid;
                if (!parse_number(tokens[1].substr(1), eid) || eid < 0 || eid > 255) {
                    BOOST_LOG_TRIVIAL(error) << "GCodeProcessor encountered an invalid value for Color_Change (" << comment << ").";
                    return;
                }
                extruder_id = static_cast<unsigned char>(eid);
            }
        }
        if (tokens.size() > 2) {
            if (is_valid_color(tokens[2]))
                color = tokens[2];
        }
        else {
            color = Default_Colors[m_last_default_color_id];
            ++m_last_default_color_id;
            if (m_last_default_color_id == Default_Colors.size())
                m_last_default_color_id = 0;
        }
 
        if (extruder_id < m_extruder_colors.size())
            m_extruder_colors[extruder_id] = static_cast<unsigned char>(m_extruder_offsets.size()) + m_cp_color.counter; // color_change position in list of color for preview
        ++m_cp_color.counter;
        if (m_cp_color.counter == UCHAR_MAX)
            m_cp_color.counter = 0;
 
        if (m_extruder_id == extruder_id) {
            m_cp_color.current = m_extruder_colors[extruder_id];
            store_move_vertex(EMoveType::Color_change);
            CustomGCode::Item item = { static_cast<double>(m_end_position[2]), CustomGCode::ColorChange, extruder_id + 1, color, "" };
            m_result.custom_gcode_per_print_z.emplace_back(item);
            m_options_z_corrector.set();
            process_custom_gcode_time(CustomGCode::ColorChange);
            process_filaments(CustomGCode::ColorChange);
        }
 
        return;
    }
 
    // pause print tag
    if (comment == reserved_tag(ETags::Pause_Print)) {
        store_move_vertex(EMoveType::Pause_Print);
        CustomGCode::Item item = { static_cast<double>(m_end_position[2]), CustomGCode::PausePrint, m_extruder_id + 1, "", "" };
        m_result.custom_gcode_per_print_z.emplace_back(item);
        m_options_z_corrector.set();
        process_custom_gcode_time(CustomGCode::PausePrint);
        return;
    }
 
    // custom code tag
    if (comment == reserved_tag(ETags::Custom_Code)) {
        store_move_vertex(EMoveType::Custom_GCode);
        CustomGCode::Item item = { static_cast<double>(m_end_position[2]), CustomGCode::Custom, m_extruder_id + 1, "", "" };
        m_result.custom_gcode_per_print_z.emplace_back(item);
        m_options_z_corrector.set();
        return;
    }
 
    // layer change tag
    if (comment == reserved_tag(ETags::Layer_Change)) {
        ++m_layer_id;
        if (m_spiral_vase_active) {
            if (m_result.moves.empty() || m_result.spiral_vase_layers.empty())
                // add a placeholder for layer height. the actual value will be set inside process_G1() method
                m_result.spiral_vase_layers.push_back({ FLT_MAX, { 0, 0 } });
            else {
                const size_t move_id = m_result.moves.size() - 1;
                if (!m_result.spiral_vase_layers.empty())
                    m_result.spiral_vase_layers.back().second.second = move_id;
                // add a placeholder for layer height. the actual value will be set inside process_G1() method
                m_result.spiral_vase_layers.push_back({ FLT_MAX, { move_id, move_id } });
            }
        }
        return;
    }
 
#if ENABLE_GCODE_VIEWER_DATA_CHECKING
    // mm3_per_mm print tag
    if (boost::starts_with(comment, Mm3_Per_Mm_Tag)) {
        if (! parse_number(comment.substr(Mm3_Per_Mm_Tag.size()), m_mm3_per_mm_compare.last_tag_value))
            BOOST_LOG_TRIVIAL(error) << "GCodeProcessor encountered an invalid value for Mm3_Per_Mm (" << comment << ").";
        return;
    }
#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
}

References Slic3r::GCodeProcessor::SeamsDetector::activate(), Slic3r::Color_change, Color_Change, Slic3r::CustomGCode::ColorChange, comment, Slic3r::GCodeProcessor::CpColor::counter, Slic3r::GCodeProcessor::CpColor::current, Slic3r::CustomGCode::Custom, Custom_Code, Slic3r::Custom_GCode, Slic3r::GCodeProcessorResult::custom_gcode_per_print_z, error, Slic3r::ExternalPerimeter, Height, Layer_Change, Slic3r::length(), m_cp_color, m_end_position, m_extruder_colors, m_extruder_id, m_extruder_offsets, m_extrusion_role, m_forced_height, m_forced_width, m_last_default_color_id, m_layer_id, m_options_z_corrector, m_producer, m_result, m_seams_detector, m_spiral_vase_active, m_wiping, Slic3r::GCodeProcessorResult::moves, Slic3r::parse_number(), Slic3r::Pause_Print, Pause_Print, Slic3r::CustomGCode::PausePrint, process_custom_gcode_time(), process_filaments(), process_producers_tags(), PrusaSlicer, reserved_tag(), Role, Slic3r::GCodeProcessor::OptionsZCorrector::set(), set_extrusion_role(), Slic3r::GCodeProcessorResult::spiral_vase_layers, store_move_vertex(), Slic3r::string_to_gcode_extrusion_role(), Width, Wipe_End, and Wipe_Start.

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reserved_tag()

static const std::string & Slic3r::GCodeProcessor::reserved_tag ( ETags tag )

inlinestatic

186{ return Reserved_Tags[static_cast<unsigned char>(tag)]; }

Slic3r::GCodeProcessor::Reserved_Tags

static const std::vector< std::string > Reserved_Tags

Definition GCodeProcessor.hpp:167

References Reserved_Tags.

Referenced by Slic3r::WipeTowerWriter::WipeTowerWriter(), Slic3r::GCode::_do_export(), Slic3r::GCode::_extrude(), Slic3r::WipeTowerWriter::change_analyzer_line_width(), Slic3r::ProcessLayer::emit_custom_gcode_per_print_z(), post_process(), Slic3r::GCode::process_layer(), process_tags(), and Slic3r::Wipe::wipe().

Here is the caller graph for this function:

◆ reset()

void Slic3r::GCodeProcessor::reset ( )

{
    m_units = EUnits::Millimeters;
    m_global_positioning_type = EPositioningType::Absolute;
    m_e_local_positioning_type = EPositioningType::Absolute;
    m_extruder_offsets = std::vector<Vec3f>(MIN_EXTRUDERS_COUNT, Vec3f::Zero());
    m_flavor = gcfRepRapSprinter;
 
    m_start_position = { 0.0f, 0.0f, 0.0f, 0.0f };
    m_end_position = { 0.0f, 0.0f, 0.0f, 0.0f };
    m_saved_position = { 0.0f, 0.0f, 0.0f, 0.0f };
    m_origin = { 0.0f, 0.0f, 0.0f, 0.0f };
    m_cached_position.reset();
    m_wiping = false;
 
    m_line_id = 0;
    m_last_line_id = 0;
    m_feedrate = 0.0f;
    m_feed_multiply.reset();
    m_width = 0.0f;
    m_height = 0.0f;
    m_forced_width = 0.0f;
    m_forced_height = 0.0f;
    m_mm3_per_mm = 0.0f;
    m_fan_speed = 0.0f;
    m_z_offset = 0.0f;
 
    m_extrusion_role = GCodeExtrusionRole::None;
    m_extruder_id = 0;
    m_extruder_colors.resize(MIN_EXTRUDERS_COUNT);
    for (size_t i = 0; i < MIN_EXTRUDERS_COUNT; ++i) {
        m_extruder_colors[i] = static_cast<unsigned char>(i);
    }
    m_extruder_temps.resize(MIN_EXTRUDERS_COUNT);
    for (size_t i = 0; i < MIN_EXTRUDERS_COUNT; ++i) {
        m_extruder_temps[i] = 0.0f;
    }
 
    m_parking_position = 0.f;
    m_extra_loading_move = 0.f;
    m_extruded_last_z = 0.0f;
    m_first_layer_height = 0.0f;
    m_g1_line_id = 0;
    m_layer_id = 0;
    m_cp_color.reset();
 
    m_producer = EProducer::Unknown;
 
    m_time_processor.reset();
    m_used_filaments.reset();
 
    m_result.reset();
    m_result.id = ++s_result_id;
 
    m_use_volumetric_e = false;
    m_last_default_color_id = 0;
 
    m_options_z_corrector.reset();
 
    m_spiral_vase_active = false;
    m_kissslicer_toolchange_time_correction = 0.0f;
 
    m_single_extruder_multi_material = false;
 
#if ENABLE_GCODE_VIEWER_DATA_CHECKING
    m_mm3_per_mm_compare.reset();
    m_height_compare.reset();
    m_width_compare.reset();
#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
}

References Absolute, Slic3r::gcfRepRapSprinter, Slic3r::GCodeProcessorResult::id, m_cached_position, m_cp_color, m_e_local_positioning_type, m_end_position, m_extra_loading_move, m_extruded_last_z, m_extruder_colors, m_extruder_id, m_extruder_offsets, m_extruder_temps, m_extrusion_role, m_fan_speed, m_feed_multiply, m_feedrate, m_first_layer_height, m_flavor, m_forced_height, m_forced_width, m_g1_line_id, m_global_positioning_type, m_height, m_kissslicer_toolchange_time_correction, m_last_default_color_id, m_last_line_id, m_layer_id, m_line_id, m_mm3_per_mm, m_options_z_corrector, m_origin, m_parking_position, m_producer, m_result, m_saved_position, m_single_extruder_multi_material, m_spiral_vase_active, m_start_position, m_time_processor, m_units, m_use_volumetric_e, m_used_filaments, m_width, m_wiping, m_z_offset, Millimeters, MIN_EXTRUDERS_COUNT, Slic3r::None, Slic3r::GCodeProcessorResult::reset(), Slic3r::GCodeProcessor::CachedPosition::reset(), Slic3r::GCodeProcessor::CpColor::reset(), Slic3r::GCodeProcessor::TimeProcessor::reset(), Slic3r::GCodeProcessor::UsedFilaments::reset(), Slic3r::GCodeProcessor::OptionsZCorrector::reset(), Slic3r::GCodeProcessor::FeedMultiply::reset(), s_result_id, and Unknown.

Referenced by GCodeProcessor(), Slic3r::DoExport::init_gcode_processor(), and update_estimated_times_stats().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_acceleration()

void Slic3r::GCodeProcessor::set_acceleration	(	PrintEstimatedStatistics::ETimeMode	mode,
		float	value
	)

private

{
    size_t id = static_cast<size_t>(mode);
    if (id < m_time_processor.machines.size()) {
        m_time_processor.machines[id].acceleration = (m_time_processor.machines[id].max_acceleration == 0.0f) ? value :
            // Clamp the acceleration with the maximum.
            std::min(value, m_time_processor.machines[id].max_acceleration);
    }
}

References m_time_processor, and Slic3r::GCodeProcessor::TimeProcessor::machines.

Referenced by process_M204().

Here is the caller graph for this function:

◆ set_extrusion_role()

void Slic3r::GCodeProcessor::set_extrusion_role ( GCodeExtrusionRole role )

private

{
    m_used_filaments.process_role_cache(this);
    m_extrusion_role = role;
}

References m_extrusion_role, m_used_filaments, and Slic3r::GCodeProcessor::UsedFilaments::process_role_cache().

Referenced by process_bambustudio_tags(), process_craftware_tags(), process_cura_tags(), process_ideamaker_tags(), process_kissslicer_tags(), process_simplify3d_tags(), and process_tags().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_print()

void Slic3r::GCodeProcessor::set_print ( Print * print )

inline

624{ m_print = print; }

References m_print.

Referenced by Slic3r::GCode::do_export().

Here is the caller graph for this function:

◆ set_retract_acceleration()

void Slic3r::GCodeProcessor::set_retract_acceleration	(	PrintEstimatedStatistics::ETimeMode	mode,
		float	value
	)

private

{
    size_t id = static_cast<size_t>(mode);
    if (id < m_time_processor.machines.size()) {
        m_time_processor.machines[id].retract_acceleration = (m_time_processor.machines[id].max_retract_acceleration == 0.0f) ? value :
            // Clamp the acceleration with the maximum.
            std::min(value, m_time_processor.machines[id].max_retract_acceleration);
    }
}

References m_time_processor, and Slic3r::GCodeProcessor::TimeProcessor::machines.

Referenced by process_M204().

Here is the caller graph for this function:

◆ set_travel_acceleration()

void Slic3r::GCodeProcessor::set_travel_acceleration	(	PrintEstimatedStatistics::ETimeMode	mode,
		float	value
	)

private

{
    size_t id = static_cast<size_t>(mode);
    if (id < m_time_processor.machines.size()) {
        m_time_processor.machines[id].travel_acceleration = (m_time_processor.machines[id].max_travel_acceleration == 0.0f) ? value :
            // Clamp the acceleration with the maximum.
            std::min(value, m_time_processor.machines[id].max_travel_acceleration);
    }
}

References m_time_processor, and Slic3r::GCodeProcessor::TimeProcessor::machines.

Referenced by process_M204().

Here is the caller graph for this function:

◆ simulate_st_synchronize()

void Slic3r::GCodeProcessor::simulate_st_synchronize ( float additional_time = 0.0f )

private

{
    for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
        m_time_processor.machines[i].simulate_st_synchronize(additional_time);
    }
}

References Slic3r::PrintEstimatedStatistics::Count, m_time_processor, and Slic3r::GCodeProcessor::TimeProcessor::machines.

Referenced by process_G92(), process_M1(), process_M702(), and process_T().

Here is the caller graph for this function:

◆ store_move_vertex()

void Slic3r::GCodeProcessor::store_move_vertex	(	EMoveType	type,
		bool	internal_only = `false`
	)

private

{
    m_last_line_id = (type == EMoveType::Color_change || type == EMoveType::Pause_Print || type == EMoveType::Custom_GCode) ?
        m_line_id + 1 :
        ((type == EMoveType::Seam) ? m_last_line_id : m_line_id);
 
    m_result.moves.push_back({
        m_last_line_id,
        type,
        m_extrusion_role,
        m_extruder_id,
        m_cp_color.current,
        Vec3f(m_end_position[X], m_end_position[Y], m_end_position[Z] - m_z_offset) + m_extruder_offsets[m_extruder_id],
        static_cast<float>(m_end_position[E] - m_start_position[E]),
        m_feedrate,
        m_width,
        m_height,
        m_mm3_per_mm,
        m_fan_speed,
        m_extruder_temps[m_extruder_id],
        static_cast<float>(m_result.moves.size()),
        internal_only
    });
 
    // stores stop time placeholders for later use
    if (type == EMoveType::Color_change || type == EMoveType::Pause_Print) {
        for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
            TimeMachine& machine = m_time_processor.machines[i];
            if (!machine.enabled)
                continue;
 
            machine.stop_times.push_back({ m_g1_line_id, 0.0f });
        }
    }
}

References Slic3r::Color_change, Slic3r::PrintEstimatedStatistics::Count, Slic3r::GCodeProcessor::CpColor::current, Slic3r::Custom_GCode, Slic3r::E, Slic3r::GCodeProcessor::TimeMachine::enabled, m_cp_color, m_end_position, m_extruder_id, m_extruder_offsets, m_extruder_temps, m_extrusion_role, m_fan_speed, m_feedrate, m_g1_line_id, m_height, m_last_line_id, m_line_id, m_mm3_per_mm, m_result, m_start_position, m_time_processor, m_width, m_z_offset, Slic3r::GCodeProcessor::TimeProcessor::machines, Slic3r::GCodeProcessorResult::moves, Slic3r::Pause_Print, Slic3r::Seam, Slic3r::GCodeProcessor::TimeMachine::stop_times, Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by process_G1(), process_G10(), process_G11(), process_G22(), process_G23(), process_G61(), process_T(), and process_tags().

Here is the caller graph for this function:

◆ update_estimated_times_stats()

void Slic3r::GCodeProcessor::update_estimated_times_stats ( )

private

{
    auto update_mode = [this](PrintEstimatedStatistics::ETimeMode mode) {
        PrintEstimatedStatistics::Mode& data = m_result.print_statistics.modes[static_cast<size_t>(mode)];
        data.time = get_time(mode);
        data.travel_time = get_travel_time(mode);
        data.custom_gcode_times = get_custom_gcode_times(mode, true);
        data.moves_times = get_moves_time(mode);
        data.roles_times = get_roles_time(mode);
        data.layers_times = get_layers_time(mode);
    };
 
    update_mode(PrintEstimatedStatistics::ETimeMode::Normal);
    if (m_time_processor.machines[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Stealth)].enabled)
        update_mode(PrintEstimatedStatistics::ETimeMode::Stealth);
    else
        m_result.print_statistics.modes[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Stealth)].reset();
 
    m_result.print_statistics.volumes_per_color_change  = m_used_filaments.volumes_per_color_change;
    m_result.print_statistics.volumes_per_extruder      = m_used_filaments.volumes_per_extruder;
    m_result.print_statistics.used_filaments_per_role   = m_used_filaments.filaments_per_role;
}

References Slic3r::GCodeProcessor::UsedFilaments::filaments_per_role, get_custom_gcode_times(), get_layers_time(), get_moves_time(), get_roles_time(), get_time(), get_travel_time(), m_result, m_time_processor, m_used_filaments, Slic3r::GCodeProcessor::TimeProcessor::machines, Slic3r::PrintEstimatedStatistics::modes, Slic3r::PrintEstimatedStatistics::Normal, Slic3r::GCodeProcessorResult::print_statistics, reset(), Slic3r::PrintEstimatedStatistics::Stealth, Slic3r::PrintEstimatedStatistics::used_filaments_per_role, Slic3r::PrintEstimatedStatistics::volumes_per_color_change, Slic3r::GCodeProcessor::UsedFilaments::volumes_per_color_change, Slic3r::PrintEstimatedStatistics::volumes_per_extruder, and Slic3r::GCodeProcessor::UsedFilaments::volumes_per_extruder.

Referenced by finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ m_cached_position

CachedPosition Slic3r::GCodeProcessor::m_cached_position

private

Referenced by process_M401(), process_M402(), and reset().

◆ m_cp_color

CpColor Slic3r::GCodeProcessor::m_cp_color

private

Referenced by process_T(), process_tags(), reset(), and store_move_vertex().

◆ m_e_local_positioning_type

EPositioningType Slic3r::GCodeProcessor::m_e_local_positioning_type

private

Referenced by extract_absolute_position_on_axis(), process_G1(), process_G2_G3(), process_M82(), process_M83(), and reset().

◆ m_end_position

AxisCoords Slic3r::GCodeProcessor::m_end_position

private

Referenced by process_G1(), process_G2_G3(), process_G60(), process_G61(), process_G92(), process_gcode_line(), process_tags(), reset(), and store_move_vertex().

◆ m_extra_loading_move

float Slic3r::GCodeProcessor::m_extra_loading_move

private

Referenced by apply_config(), apply_config(), process_G1(), and reset().

◆ m_extruded_last_z

float Slic3r::GCodeProcessor::m_extruded_last_z

private

Referenced by process_G1(), and reset().

◆ m_extruder_colors

ExtruderColors Slic3r::GCodeProcessor::m_extruder_colors

private

Referenced by apply_config(), apply_config(), process_T(), process_tags(), and reset().

◆ m_extruder_id

unsigned char Slic3r::GCodeProcessor::m_extruder_id

private

Referenced by Slic3r::GCodeProcessor::UsedFilaments::process_caches(), process_filaments(), process_G1(), process_G10(), process_G2_G3(), process_M104(), process_M109(), process_M702(), Slic3r::GCodeProcessor::UsedFilaments::process_role_cache(), process_T(), process_tags(), reset(), and store_move_vertex().

◆ m_extruder_offsets

std::vector<Vec3f> Slic3r::GCodeProcessor::m_extruder_offsets

private

Referenced by apply_config(), apply_config(), process_G1(), process_tags(), reset(), and store_move_vertex().

◆ m_extruder_temps

ExtruderTemps Slic3r::GCodeProcessor::m_extruder_temps

private

Referenced by apply_config(), apply_config(), process_G10(), process_M104(), process_M109(), process_T(), reset(), and store_move_vertex().

◆ m_extruder_temps_config

ExtruderTemps Slic3r::GCodeProcessor::m_extruder_temps_config

private

Referenced by apply_config(), and post_process().

◆ m_extruder_temps_first_layer_config

ExtruderTemps Slic3r::GCodeProcessor::m_extruder_temps_first_layer_config

private

Referenced by apply_config(), and post_process().

◆ m_extrusion_role

GCodeExtrusionRole Slic3r::GCodeProcessor::m_extrusion_role

private

Referenced by process_bambustudio_tags(), process_craftware_tags(), process_cura_tags(), process_G1(), process_ideamaker_tags(), Slic3r::GCodeProcessor::UsedFilaments::process_role_cache(), process_tags(), reset(), set_extrusion_role(), and store_move_vertex().

◆ m_fan_speed

float Slic3r::GCodeProcessor::m_fan_speed

private

Referenced by process_M106(), process_M107(), reset(), and store_move_vertex().

◆ m_feed_multiply

FeedMultiply Slic3r::GCodeProcessor::m_feed_multiply

private

Referenced by process_G1(), process_G2_G3(), process_G61(), process_M220(), and reset().

◆ m_feedrate

float Slic3r::GCodeProcessor::m_feedrate

private

Referenced by process_G1(), process_G61(), process_M401(), process_M402(), reset(), and store_move_vertex().

◆ m_first_layer_height

float Slic3r::GCodeProcessor::m_first_layer_height

private

Referenced by apply_config(), apply_config(), process_G1(), and reset().

◆ m_flavor

GCodeFlavor Slic3r::GCodeProcessor::m_flavor

private

Referenced by apply_config(), apply_config(), apply_config_kissslicer(), process_cura_tags(), process_G10(), process_G60(), process_G61(), process_M108(), process_M135(), process_M201(), process_M203(), process_M220(), process_M401(), process_M402(), process_T(), and reset().

◆ m_forced_height

float Slic3r::GCodeProcessor::m_forced_height

private

Referenced by process_G1(), process_ideamaker_tags(), process_simplify3d_tags(), process_tags(), and reset().

◆ m_forced_width

float Slic3r::GCodeProcessor::m_forced_width

private

Referenced by process_G1(), process_ideamaker_tags(), process_simplify3d_tags(), process_tags(), and reset().

◆ m_g1_line_id

unsigned int Slic3r::GCodeProcessor::m_g1_line_id

private

Referenced by process_G1(), reset(), and store_move_vertex().

◆ m_global_positioning_type

EPositioningType Slic3r::GCodeProcessor::m_global_positioning_type

private

Referenced by extract_absolute_position_on_axis(), process_G1(), process_G2_G3(), process_G90(), process_G91(), and reset().

◆ m_height

float Slic3r::GCodeProcessor::m_height

private

Referenced by process_G1(), reset(), and store_move_vertex().

◆ m_is_XL_printer

bool Slic3r::GCodeProcessor::m_is_XL_printer = false

private

Referenced by apply_config(), get_filament_load_time(), get_filament_unload_time(), and post_process().

◆ m_kissslicer_toolchange_time_correction

float Slic3r::GCodeProcessor::m_kissslicer_toolchange_time_correction

private

Referenced by apply_config_kissslicer(), process_T(), and reset().

◆ m_last_default_color_id

size_t Slic3r::GCodeProcessor::m_last_default_color_id

private

Referenced by process_tags(), and reset().

◆ m_last_line_id

unsigned int Slic3r::GCodeProcessor::m_last_line_id

private

Referenced by reset(), and store_move_vertex().

◆ m_layer_id

unsigned int Slic3r::GCodeProcessor::m_layer_id

private

Referenced by post_process(), process_craftware_tags(), process_cura_tags(), process_G1(), process_ideamaker_tags(), process_kissslicer_tags(), process_simplify3d_tags(), process_tags(), and reset().

◆ m_line_id

unsigned int Slic3r::GCodeProcessor::m_line_id

private

Referenced by process_gcode_line(), reset(), and store_move_vertex().

◆ m_mm3_per_mm

float Slic3r::GCodeProcessor::m_mm3_per_mm

private

Referenced by process_G1(), reset(), and store_move_vertex().

◆ m_options_z_corrector

OptionsZCorrector Slic3r::GCodeProcessor::m_options_z_corrector

private

Referenced by process_G1(), process_tags(), and reset().

◆ m_origin

AxisCoords Slic3r::GCodeProcessor::m_origin

private

Referenced by extract_absolute_position_on_axis(), process_G1(), process_G92(), process_M132(), and reset().

◆ m_parking_position

float Slic3r::GCodeProcessor::m_parking_position

private

Referenced by apply_config(), apply_config(), process_G1(), and reset().

◆ m_parser

GCodeReader Slic3r::GCodeProcessor::m_parser

private

Referenced by apply_config(), apply_config(), apply_config_kissslicer(), apply_config_simplify3d(), process_buffer(), and process_file().

◆ m_print

Print* Slic3r::GCodeProcessor::m_print { nullptr }

private

Referenced by post_process(), and set_print().

◆ m_producer

EProducer Slic3r::GCodeProcessor::m_producer

private

Referenced by apply_config(), detect_producer(), process_file(), process_producers_tags(), process_T(), process_tags(), and reset().

◆ m_result

GCodeProcessorResult Slic3r::GCodeProcessor::m_result

private

Referenced by apply_config(), apply_config(), apply_config_simplify3d(), extract_result(), finalize(), get_result(), initialize(), initialize_result_moves(), post_process(), process_file(), process_G1(), process_G2_G3(), Slic3r::GCodeProcessor::UsedFilaments::process_role_cache(), process_T(), process_tags(), reset(), store_move_vertex(), and update_estimated_times_stats().

◆ m_saved_position

AxisCoords Slic3r::GCodeProcessor::m_saved_position

private

Referenced by process_G60(), process_G61(), and reset().

◆ m_seams_detector

SeamsDetector Slic3r::GCodeProcessor::m_seams_detector

private

Referenced by process_bambustudio_tags(), process_craftware_tags(), process_cura_tags(), process_G1(), process_ideamaker_tags(), process_kissslicer_tags(), process_simplify3d_tags(), and process_tags().

◆ m_single_extruder_multi_material

bool Slic3r::GCodeProcessor::m_single_extruder_multi_material

private

Referenced by apply_config(), apply_config(), process_T(), and reset().

◆ m_spiral_vase_active

bool Slic3r::GCodeProcessor::m_spiral_vase_active

private

Referenced by apply_config(), apply_config(), process_G1(), process_tags(), and reset().

◆ m_start_position

AxisCoords Slic3r::GCodeProcessor::m_start_position

private

Referenced by extract_absolute_position_on_axis(), process_G1(), process_G2_G3(), process_gcode_line(), process_M401(), process_M402(), reset(), and store_move_vertex().

◆ m_time_processor

TimeProcessor Slic3r::GCodeProcessor::m_time_processor

private

Referenced by GCodeProcessor(), apply_config(), apply_config(), enable_machine_envelope_processing(), enable_stealth_time_estimator(), finalize(), get_acceleration(), get_axis_max_acceleration(), get_axis_max_feedrate(), get_axis_max_jerk(), get_custom_gcode_times(), get_filament_load_time(), get_filament_unload_time(), get_layers_time(), get_moves_time(), get_retract_acceleration(), get_roles_time(), get_time(), get_time_dhm(), get_travel_acceleration(), get_travel_time(), get_travel_time_dhm(), is_stealth_time_estimator_enabled(), minimum_feedrate(), minimum_travel_feedrate(), post_process(), process_custom_gcode_time(), process_G1(), process_M201(), process_M203(), process_M204(), process_M205(), process_M221(), process_M566(), process_M702(), process_T(), reset(), set_acceleration(), set_retract_acceleration(), set_travel_acceleration(), simulate_st_synchronize(), store_move_vertex(), and update_estimated_times_stats().

◆ m_units

EUnits Slic3r::GCodeProcessor::m_units

private

Referenced by extract_absolute_position_on_axis(), process_G1(), process_G20(), process_G21(), process_G2_G3(), process_G92(), process_M201(), and reset().

◆ m_use_volumetric_e

bool Slic3r::GCodeProcessor::m_use_volumetric_e

private

Referenced by apply_config(), apply_config(), extract_absolute_position_on_axis(), process_G1(), process_G2_G3(), and reset().

◆ m_used_filaments

UsedFilaments Slic3r::GCodeProcessor::m_used_filaments

private

Referenced by finalize(), process_filaments(), process_G1(), reset(), set_extrusion_role(), and update_estimated_times_stats().

◆ m_width

float Slic3r::GCodeProcessor::m_width

private

Referenced by process_G1(), reset(), and store_move_vertex().

◆ m_wiping

bool Slic3r::GCodeProcessor::m_wiping

private

Referenced by process_G1(), process_tags(), and reset().

◆ m_z_offset

float Slic3r::GCodeProcessor::m_z_offset

private

Referenced by apply_config(), apply_config(), process_G1(), reset(), and store_move_vertex().

◆ Producers

const std::vector< std::pair< GCodeProcessor::EProducer, std::string > > Slic3r::GCodeProcessor::Producers

staticprivate

Initial value:

= {
    { EProducer::PrusaSlicer, "generated by PrusaSlicer" },
    { EProducer::Slic3rPE,    "generated by Slic3r Prusa Edition" },
    { EProducer::Slic3r,      "generated by Slic3r" },
    { EProducer::SuperSlicer, "generated by SuperSlicer" },
    { EProducer::Cura,        "Cura_SteamEngine" },
    { EProducer::Simplify3D,  "generated by Simplify3D(R)" },
    { EProducer::CraftWare,   "CraftWare" },
    { EProducer::ideaMaker,   "ideaMaker" },
    { EProducer::KissSlicer,  "KISSlicer" },
    { EProducer::BambuStudio, "BambuStudio" }
}

Referenced by detect_producer().

◆ Reserved_Tags

const std::vector< std::string > Slic3r::GCodeProcessor::Reserved_Tags

staticprivate

Initial value:

= {
    "TYPE:",
    "WIPE_START",
    "WIPE_END",
    "HEIGHT:",
    "WIDTH:",
    "LAYER_CHANGE",
    "COLOR_CHANGE",
    "PAUSE_PRINT",
    "CUSTOM_GCODE",
    "_GP_FIRST_LINE_M73_PLACEHOLDER",
    "_GP_LAST_LINE_M73_PLACEHOLDER",
    "_GP_ESTIMATED_PRINTING_TIME_PLACEHOLDER"
}

Referenced by reserved_tag().

◆ s_result_id

unsigned int Slic3r::GCodeProcessor::s_result_id = 0

staticprivate

Referenced by initialize(), process_file(), and reset().

◆ Wipe_Height

const float Slic3r::GCodeProcessor::Wipe_Height = 0.05f

static

Referenced by finalize(), and Slic3r::GUI::GCodeViewer::load_toolpaths().

◆ Wipe_Width

const float Slic3r::GCodeProcessor::Wipe_Width = 0.05f

static

Referenced by finalize().

The documentation for this class was generated from the following files:

src/libslic3r/GCode/GCodeProcessor.hpp
src/libslic3r/GCode/GCodeProcessor.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Class Documentation

◆ Slic3r::GCodeProcessor::FeedrateProfile

Member Typedef Documentation

◆ AxisCoords

◆ ExtruderColors

◆ ExtruderTemps

Member Enumeration Documentation

◆ EPositioningType

◆ EProducer

◆ ETags

◆ EUnits

Constructor & Destructor Documentation

◆ GCodeProcessor()

Member Function Documentation

◆ apply_config() [1/2]

◆ apply_config() [2/2]

◆ apply_config_kissslicer()

◆ apply_config_simplify3d()

◆ apply_config_superslicer()

◆ contains_reserved_tag()

◆ contains_reserved_tags()

◆ detect_producer()

◆ enable_machine_envelope_processing()

◆ enable_stealth_time_estimator()

◆ extract_absolute_position_on_axis()

◆ extract_result()

◆ finalize()

◆ get_acceleration()

◆ get_axis_max_acceleration()

◆ get_axis_max_feedrate()

◆ get_axis_max_jerk()

◆ get_custom_gcode_times()

◆ get_filament_load_time()

◆ get_filament_unload_time()

◆ get_layers_time()

◆ get_moves_time()

◆ get_result()

◆ get_retract_acceleration()

◆ get_roles_time()

◆ get_time()

◆ get_time_dhm()

◆ get_travel_acceleration()

◆ get_travel_time()

◆ get_travel_time_dhm()

◆ initialize()

◆ initialize_result_moves()

◆ is_stealth_time_estimator_enabled()

◆ minimum_feedrate()

◆ minimum_travel_feedrate()

◆ post_process()

◆ process_bambustudio_tags()

◆ process_buffer()

◆ process_craftware_tags()

◆ process_cura_tags()

◆ process_custom_gcode_time()

◆ process_filaments()

◆ process_file()

◆ process_G0()

◆ process_G1() [1/2]

◆ process_G1() [2/2]

◆ process_G10()

◆ process_G11()

◆ process_G20()

◆ process_G21()

◆ process_G22()

◆ process_G23()

◆ process_G28()

◆ process_G2_G3()

◆ process_G60()

◆ process_G61()