Slic3r::GCodeProcessor Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/GCodeProcessor.hpp>

Collaboration diagram for Slic3r::GCodeProcessor:

Classes
struct	CachedPosition
struct	CpColor
struct	FeedrateProfile
struct	Trapezoid
struct	TimeBlock
struct	TimeMachine
struct	UsedFilaments
struct	TimeProcessor
class	PreCoolingInjector
class	SeamsDetector
class	OptionsZCorrector
struct	MassLocation
struct	PositionState

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 ,   Total_Layer_Number_Placeholder , Manual_Tool_Change , During_Print_Exhaust_Fan , Wipe_Tower_Start ,   Wipe_Tower_End , PA_Change , Print_Time_Total_Sec_Placeholder , Print_Time_Day_Placeholder ,   Print_Time_Hour_Placeholder , Print_Time_Minute_Placeholder , Print_Time_Sec_Placeholder , Used_Filament_Length_Placeholder ,   Normal_Print_Time_Placeholder , Silent_Print_Time_Placeholder , Total_Weight_Placeholder , Total_Cost_Placeholder ,   Total_Wipe_Tower_Cost_Placeholder , Total_Wipe_Tower_Filament_Placeholder }
using	MassLocator = std::function<MassLocation(const Vec3d &point, bool support)>

Public Member Functions
	GCodeProcessor ()
void	init_filament_maps_and_nozzle_type_when_import_only_gcode ()
void	ensure_nozzle_group_result (int min_filament_count)
bool	check_multi_extruder_gcode_valid (const int extruder_size, const Pointfs plate_printable_area, const double plate_printable_height, const Pointfs wrapping_exclude_area, const std::vector< Polygons > &unprintable_areas, const std::vector< double > &printable_heights, const std::vector< int > &filament_map, const std::vector< std::set< int > > &unprintable_filament_types)
void	apply_config (const PrintConfig &config)
void	configure_exclusion_volume_path_check (const PrintConfig &config)
void	set_print (Print *print)
void	set_mass_locator (MassLocator locator, std::vector< GCodeProcessorResult::ObjectMass > objects)
void	initialize_from_context (const std::shared_ptr< MultiNozzleUtils::NozzleGroupResultBase > &nozzle_group_result)
DynamicConfig	export_config_for_render () const
bool	is_stealth_time_estimator_enabled () const
void	enable_machine_envelope_processing (bool enabled)
void	reset ()
const GCodeProcessorResult &	get_result () const
GCodeProcessorResult &	result ()
GCodeProcessorResult &&	extract_result ()
PositionState	get_current_position () const
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)
double	get_time (PrintEstimatedStatistics::ETimeMode mode) const
float	get_prepare_time (PrintEstimatedStatistics::ETimeMode mode) const
std::string	get_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
float	get_first_layer_time (PrintEstimatedStatistics::ETimeMode mode) const
void	set_xy_offset (double x, double y)
void	detect_layer_based_on_tag (bool enabled)

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, bool is_bbl_printer)
static int	get_gcode_last_filament (const std::string &gcode_str)
static bool	get_last_z_from_gcode (const std::string &gcode_str, double &z)
static bool	get_last_position_from_gcode (const std::string &gcode_str, Vec3f &pos)

Static Public Attributes
static constexpr size_t	Output_Block_Size = 65536
static const std::string	Skippable_Start_Tag = " SKIPPABLE_START"
static const std::string	Skippable_End_Tag = " SKIPPABLE_END"
static const std::string	Skippable_Type_Tag = " SKIPTYPE: "
static const std::string	Machine_Start_GCode_End_Tag = " MACHINE_START_GCODE_END"
static const std::string	Machine_End_GCode_Start_Tag = " MACHINE_END_GCODE_START"
static const std::string	Nozzle_Change_Start_Tag = " NOZZLE_CHANGE_START"
static const std::string	Nozzle_Change_End_Tag = " NOZZLE_CHANGE_END"
static const std::string	Toolchange_Wipe_Tag = " CP_TOOLCHANGE_WIPE"
static const float	Wipe_Width = 0.05f
static const float	Wipe_Height = 0.05f
static bool	s_IsBBLPrinter = true

Private Types
enum class	EUnits : unsigned char { Millimeters , Inches }
enum class	EPositioningType : unsigned char { Absolute , Relative }
enum class	EProducer {   Unknown , OrcaSlicer , Slic3rPE , Slic3r ,   SuperSlicer , Cura , Simplify3D , CraftWare ,   ideaMaker , KissSlicer }
enum class	G1DiscretizationOrigin { G1 , G2G3 }
using	AxisCoords = std::array<double, 4>
using	ExtruderColors = std::vector<unsigned char>
using	ExtruderTemps = std::vector<float>

Private Member Functions
void	register_commands ()
void	apply_config (const DynamicPrintConfig &config)
void	apply_config_simplify3d (const std::string &filename)
void	apply_config_superslicer (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_bambuslicer_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	detect_producer (const std::string_view comment)
void	process_G0 (const GCodeReader::GCodeLine &line)
void	process_G1 (const GCodeReader::GCodeLine &line, const std::optional< unsigned int > &remaining_internal_g1_lines=std::nullopt)
void	process_G1 (const std::array< std::optional< double >, 4 > &axes={ std::nullopt, std::nullopt, std::nullopt, std::nullopt }, const std::optional< double > &feedrate=std::nullopt, G1DiscretizationOrigin origin=G1DiscretizationOrigin::G1, const std::optional< unsigned int > &remaining_internal_g1_lines=std::nullopt)
void	update_position_known_from_move (const std::array< std::optional< double >, 4 > &axes, G1DiscretizationOrigin origin)
void	update_position_known_from_move (const GCodeReader::GCodeLine &line)
void	update_exclusion_volume_path_check_result ()
void	process_G2_G3 (const GCodeReader::GCodeLine &line, bool clockwise)
void	process_VG1 (const GCodeReader::GCodeLine &line)
void	process_G4 (const GCodeReader::GCodeLine &line)
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_G29 (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_VM104 (const GCodeReader::GCodeLine &line)
void	process_VM109 (const GCodeReader::GCodeLine &line)
void	process_M106 (const GCodeReader::GCodeLine &line)
void	process_M107 (const GCodeReader::GCodeLine &line)
void	process_M900 (const GCodeReader::GCodeLine &line)
void	process_M572 (const GCodeReader::GCodeLine &line)
void	process_SET_PRESSURE_ADVANCE (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_M140 (const GCodeReader::GCodeLine &line)
void	process_M190 (const GCodeReader::GCodeLine &line)
void	process_M191 (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_SET_VELOCITY_LIMIT (const GCodeReader::GCodeLine &line)
void	process_M221 (const GCodeReader::GCodeLine &line)
void	process_M400 (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_M6211 (const GCodeReader::GCodeLine &line)
void	process_elegoo_M6211 (const GCodeReader::GCodeLine &line)
void	process_SYNC (const GCodeReader::GCodeLine &line)
void	process_T (const GCodeReader::GCodeLine &line)
void	process_T (const std::string_view command)
void	process_T (const std::string_view command, int nozzle_id)
void	process_M1020 (const GCodeReader::GCodeLine &line)
void	process_M622 (const GCodeReader::GCodeLine &line)
void	process_M623 (const GCodeReader::GCodeLine &line)
void	process_filament_change (int id)
void	process_filament_change (int id, int nozzle_id)
std::optional< MultiNozzleUtils::NozzleInfo >	resolve_target_nozzle (const MultiNozzleUtils::NozzleGroupResultBase &group, int id, int nozzle_id) const
int	get_machine_config_idx () const
bool	use_multi_nozzle_change_time_model () const
void	run_post_process ()
void	run_second_pass_injection ()
void	handle_offsets_of_second_process (const TimeProcessor::InsertedLinesMap &inserted_operation_lines)
void	store_move_vertex (EMoveType type, EMovePathType path_type=EMovePathType::Noop_move, bool internal_only=false)
void	add_object_mass (int filament_id, float volume)
void	finalize_object_masses ()
void	set_extrusion_role (ExtrusionRole role)
void	set_skippable_type (const std::string_view type)
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_feedrate (PrintEstimatedStatistics::ETimeMode mode, Axis axis, int machine_idx) const
float	get_axis_max_acceleration (PrintEstimatedStatistics::ETimeMode mode, Axis axis) const
float	get_axis_max_acceleration (PrintEstimatedStatistics::ETimeMode mode, Axis axis, int machine_idx) const
float	get_axis_max_jerk_with_jd (PrintEstimatedStatistics::ETimeMode mode, Axis axis, float acceleration) const
float	get_axis_max_jerk_with_jd (PrintEstimatedStatistics::ETimeMode mode, Axis axis) const
float	get_junction_deviation (PrintEstimatedStatistics::ETimeMode mode, float acceleration) const
float	calc_junction_acceleration (const TimeBlock &block, const Vec4f &junction_unit_vec, PrintEstimatedStatistics::ETimeMode mode) const
float	calc_vmax_junction_deviation (const TimeBlock &block, const TimeMachine::State &prev, const TimeMachine::State &curr, bool has_prev_move, PrintEstimatedStatistics::ETimeMode mode) const
float	get_axis_max_jerk (PrintEstimatedStatistics::ETimeMode mode, Axis axis) const
Vec3f	get_xyz_max_jerk (PrintEstimatedStatistics::ETimeMode mode) 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)
float	get_extruder_change_time (size_t extruder_id)
int	get_filament_vitrification_temperature (size_t extrude_id)
void	process_custom_gcode_time (CustomGCode::Type code)
void	process_filaments (CustomGCode::Type code)
void	calculate_time (GCodeProcessorResult &result, size_t keep_last_n_blocks=0, float additional_time=0.0f, EMoveType target_move_type=EMoveType::Noop, bool is_final=false)
void	simulate_st_synchronize (float additional_time=0.0f, EMoveType target_move_type=EMoveType::Noop)
void	update_estimated_times_stats ()
double	extract_absolute_position_on_axis (Axis axis, const GCodeReader::GCodeLine &line, double area_filament_cross_section)
void	update_slice_warnings ()
int	get_filament_id (bool force_initialize=true) const
int	get_last_filament_id (bool force_initialize=true) const
int	get_extruder_id (bool force_initialize=true) const

Private Attributes
CommandProcessor	m_command_processor
GCodeReader	m_parser
DynamicConfig	m_belt_render_config
EUnits	m_units
EPositioningType	m_global_positioning_type
EPositioningType	m_e_local_positioning_type
std::vector< Vec3f >	m_extruder_offsets
GCodeFlavor	m_flavor
std::vector< float >	m_nozzle_volume
AxisCoords	m_start_position
AxisCoords	m_end_position
AxisCoords	m_origin
std::array< bool, 3 >	m_axis_position_known { false, false, false }
std::array< bool, 3 >	m_axis_origin_known { true, true, true }
bool	m_processing_homing_move { false }
ExclusionVolumePathChecker	m_exclusion_volume_path_checker
CachedPosition	m_cached_position
bool	m_wiping
bool	m_flushing
bool	m_virtual_flushing
bool	m_wipe_tower
bool	m_skippable {false}
SkipType	m_skippable_type {SkipType::stNone}
int	m_object_label_id {-1}
MassLocator	m_mass_locator
float	m_print_z {0.0f}
std::vector< float >	m_remaining_volume
ExtruderTemps	m_filament_nozzle_temp
ExtruderTemps	m_filament_nozzle_temp_first_layer
std::vector< int >	m_physical_extruder_map
std::vector< int >	m_extruder_max_nozzle_count {1}
std::vector< std::string >	m_filament_types
std::vector< double >	m_nozzle_diameter
std::vector< double >	m_hotend_cooling_rate { 2.f }
std::vector< double >	m_hotend_heating_rate { 2.f }
std::vector< int >	m_filament_pre_cooling_temp { 0 }
std::vector< double >	m_filament_preheat_temperature_delta
bool	m_enable_pre_heating { false }
bool	m_handle_hotend_as_extruder { false }
bool	m_has_filament_switcher { false }
std::vector< std::pair< unsigned int, unsigned int > >	m_skippable_blocks
std::vector< ExtruderPreHeating::FilamentUsageBlock >	m_filament_blocks
std::vector< ExtruderPreHeating::ExtruderUsageBlcok >	m_extruder_blocks
unsigned int	m_machine_start_gcode_end_line_id { (unsigned int) (-1) }
unsigned int	m_machine_end_gcode_start_line_id { (unsigned int) (-1) }
bool	m_skip_end_gcode_delays { false }
MultiNozzleUtils::NozzleStatusRecorder	m_nozzle_status_recorder
std::shared_ptr< MultiNozzleUtils::NozzleGroupResultBase >	m_nozzle_group_result
bool	m_manual_filament_change { false }
double	m_x_offset { 0 }
double	m_y_offset { 0 }
MachineFrameTransform	m_machine_frame_transform
bool	m_belt_printer { false }
unsigned int	m_line_id
unsigned int	m_last_line_id
float	m_feedrate
float	m_width
float	m_height
float	m_forced_width
float	m_forced_height
float	m_mm3_per_mm
float	m_travel_dist
float	m_fan_speed
float	m_z_offset
float	m_pressure_advance
ExtrusionRole	m_extrusion_role
std::vector< int >	m_filament_maps
std::vector< unsigned char >	m_last_filament_id
std::vector< unsigned char >	m_filament_id
unsigned char	m_extruder_id
int	m_machine_config_idx {0}
ExtruderColors	m_extruder_colors
ExtruderTemps	m_extruder_temps
bool	m_is_XL_printer = false
int	m_highest_bed_temp
float	m_extruded_last_z
float	m_first_layer_height
float	m_zero_layer_height
bool	m_processing_start_custom_gcode
bool	m_in_config_block
unsigned int	m_g1_line_id
unsigned int	m_layer_id
CpColor	m_cp_color
SeamsDetector	m_seams_detector
OptionsZCorrector	m_options_z_corrector
size_t	m_last_default_color_id
bool	m_detect_layer_based_on_tag {false}
int	m_seams_count
bool	m_measure_g29_time {false}
bool	m_g29_time_added {false}
bool	m_single_extruder_multi_material
float	m_preheat_time
int	m_preheat_steps
bool	m_disable_m73
std::string	m_printer_model
EProducer	m_producer
TimeProcessor	m_time_processor
std::vector< std::pair< unsigned int, unsigned int > >	m_actual_speed_id_map
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::string >	Reserved_Tags_compatible
static const std::string	Flush_Start_Tag = " FLUSH_START"
static const std::string	Flush_End_Tag = " FLUSH_END"
static const std::string	VFlush_Start_Tag = " VFLUSH_START"
static const std::string	VFlush_End_Tag = " VFLUSH_END"
static const std::string	External_Purge_Tag = " EXTERNAL_PURGE"
static const std::vector< std::pair< GCodeProcessor::EProducer, std::string > >	Producers
static unsigned int	s_result_id = 0

Friends
class	ExportLines

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 }

Slic3r::GCodeProcessor::MassLocation

struct Slic3r::GCodeProcessor::MassLocation

Class Members
int	body { -1 }
int	object { -1 }

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

MassLocator

using Slic3r::GCodeProcessor::MassLocator = std::function<MassLocation(const Vec3d &point, bool support)>

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
OrcaSlicer
Slic3rPE
Slic3r
SuperSlicer
Cura
Simplify3D
CraftWare
ideaMaker
KissSlicer

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

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
Total_Layer_Number_Placeholder
Manual_Tool_Change
During_Print_Exhaust_Fan
Wipe_Tower_Start
Wipe_Tower_End
PA_Change
Print_Time_Total_Sec_Placeholder
Print_Time_Day_Placeholder
Print_Time_Hour_Placeholder
Print_Time_Minute_Placeholder
Print_Time_Sec_Placeholder
Used_Filament_Length_Placeholder
Normal_Print_Time_Placeholder
Silent_Print_Time_Placeholder
Total_Weight_Placeholder
Total_Cost_Placeholder
Total_Wipe_Tower_Cost_Placeholder
Total_Wipe_Tower_Filament_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,
            Total_Layer_Number_Placeholder,
            Manual_Tool_Change,
            During_Print_Exhaust_Fan,
            Wipe_Tower_Start,
            Wipe_Tower_End,
            PA_Change,
            Print_Time_Total_Sec_Placeholder,
            Print_Time_Day_Placeholder,
            Print_Time_Hour_Placeholder,
            Print_Time_Minute_Placeholder,
            Print_Time_Sec_Placeholder,
            Used_Filament_Length_Placeholder,
            Normal_Print_Time_Placeholder,
            Silent_Print_Time_Placeholder,
            Total_Weight_Placeholder,
            Total_Cost_Placeholder,
            Total_Wipe_Tower_Cost_Placeholder,
            Total_Wipe_Tower_Filament_Placeholder,
        };

EUnits

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

strongprivate

Enumerator
Millimeters
Inches

        {
            Millimeters,
            Inches
        };

G1DiscretizationOrigin

enum class Slic3r::GCodeProcessor::G1DiscretizationOrigin

strongprivate

Enumerator
G1
G2G3

                                          {
            G1,
            G2G3,
        };

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";
 
    register_commands();
}

References m_options_z_corrector, m_result, m_time_processor, Slic3r::PrintEstimatedStatistics::Normal, register_commands(), reset(), and Slic3r::PrintEstimatedStatistics::Stealth.

Here is the call graph for this function:

Member Function Documentation

add_object_mass()

void Slic3r::GCodeProcessor::add_object_mass ( int filament_id, float volume )

private

{
    // Skirt, prime tower and custom G-code belong to no object.
    const ExtrusionRole role = m_extrusion_role;
    if (volume <= 0.f || role == erNone || role == erSkirt || role == erWipeTower || role == erCustom || role == erMixed)
        return;
 
    const bool   has_density = size_t(filament_id) < m_result.filament_densities.size() && m_result.filament_densities[filament_id] > 0.f;
    const double mass        = double(volume) * (has_density ? m_result.filament_densities[filament_id] : DEFAULT_FILAMENT_DENSITY);
    // In the frame of the stored moves, the bead's center half its height below the nozzle, from the move's start to its end.
    const Vec3d half_height = 0.5 * double(m_height) * Vec3d::UnitZ();
    const Vec3d offset      = Vec3d(m_x_offset, m_y_offset, -m_z_offset) - half_height + m_extruder_offsets[filament_id].cast<double>();
    const Vec3d start       = Vec3d(m_start_position[X], m_start_position[Y], m_start_position[Z]) + offset;
    const Vec3d end         = Vec3d(m_end_position[X], m_end_position[Y], m_end_position[Z]) + offset;
    // The second moments of a uniform segment.
    const GCodeProcessorResult::ObjectMass::Sum sum{ mass, double(volume), 0.5 * mass * (start + end),
                                                     mass / 3. * (start.cwiseProduct(start) + start.cwiseProduct(end) + end.cwiseProduct(end)) };
    // Of the bead's center line and its height, as its width is only estimated. Merged, as a wall along an axis is flat.
    BoundingBoxf3 extent;
    extent.merge(start.cwiseMin(end) - half_height);
    extent.merge(start.cwiseMax(end) + half_height);
    const bool   part  = role != erBrim && !is_support(role);
    const size_t layer = std::max<unsigned int>(1, m_layer_id) - 1;
 
    m_result.plate_mass.add(sum, extent, layer);
    // The brim belongs to the plate alone.
    if (role == erBrim || !m_mass_locator)
        return;
    const auto add = [&sum, &extent, layer](std::vector<GCodeProcessorResult::ObjectMass> &masses, int index) {
        if (index < 0)
            return;
        if (masses.size() <= size_t(index))
            masses.resize(index + 1);
        masses[index].add(sum, extent, layer);
    };
    // At the nozzle's height, which the layers print at.
    const MassLocation location = m_mass_locator(0.5 * (start + end) + half_height, !part);
    if (part) {
        add(m_result.object_masses, location.object);
        add(m_result.body_masses, location.body);
    } else
        add(m_result.support_masses, location.object);
}

References Slic3r::GCodeProcessor::MassLocation::body, Slic3r::DEFAULT_FILAMENT_DENSITY, Slic3r::erBrim, Slic3r::erCustom, Slic3r::erMixed, Slic3r::erNone, Slic3r::erSkirt, Slic3r::erWipeTower, Slic3r::is_support(), m_end_position, m_extruder_offsets, m_extrusion_role, m_height, m_layer_id, m_mass_locator, m_result, m_start_position, m_x_offset, m_y_offset, m_z_offset, Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::GCodeProcessor::MassLocation::object, Slic3r::offset(), 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:

apply_config() [1/2]

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

private

{
    m_parser.apply_config(config);
 
    // Belt printer: remember the file's belt keys for export_config_for_render(). The
    // config block lists belt_printer for every printer, so a non-belt file loaded while
    // a belt printer is selected switches the preview's belt view off, and a belt file
    // loaded on another printer brings its own tilt, remaps and bed along.
    m_belt_render_config.clear();
    {
        const auto *belt = config.option<ConfigOptionBool>("belt_printer");
        if (belt != nullptr) {
            static const char *belt_keys[] = {
                "belt_printer", "belt_slice_rotation", "belt_slice_rotation_angle",
                "gcode_remap_x", "gcode_remap_y", "gcode_remap_z",
                "belt_frame_tilt_decouple", "belt_frame_tilt_angle",
            };
            for (const char *key : belt_keys)
                if (const ConfigOption *opt = config.option(key); opt != nullptr)
                    m_belt_render_config.set_key_value(key, opt->clone());
            // The Rev remaps mirror inside the build volume, so the designed view needs
            // the bed the file was sliced for. Only a belt file may override it.
            static const char *bed_keys[] = { "printable_area", "printable_height" };
            if (belt->value)
                for (const char *key : bed_keys)
                    if (const ConfigOption *opt = config.option(key); opt != nullptr)
                        m_belt_render_config.set_key_value(key, opt->clone());
        }
    }
 
    //BBS
    const ConfigOptionFloatsNullable* nozzle_volume = config.option<ConfigOptionFloatsNullable>("nozzle_volume");
    if (nozzle_volume != nullptr) {
        m_nozzle_volume.resize(nozzle_volume->size(), 0);
        for (size_t idx = 0; idx < nozzle_volume->size(); ++idx)
            m_nozzle_volume[idx] = nozzle_volume->values[idx];
    }
 
    const ConfigOptionInt *nozzle_HRC = config.option<ConfigOptionInt>("nozzle_hrc");
    if (nozzle_HRC != nullptr) m_result.nozzle_hrc = nozzle_HRC->value;
 
    const ConfigOptionInts* physical_extruder_map = config.option<ConfigOptionInts>("physical_extruder_map");
    if (physical_extruder_map != nullptr) {
        m_physical_extruder_map = physical_extruder_map->values;
    }
 
    // Multi-nozzle context state, consumed by the multi-nozzle time model and pre-heat injector.
    const ConfigOptionIntsNullable* extruder_max_nozzle_count = config.option<ConfigOptionIntsNullable>("extruder_max_nozzle_count");
    if (extruder_max_nozzle_count != nullptr) {
        m_extruder_max_nozzle_count = extruder_max_nozzle_count->values;
    }
 
    // Pre-heat / pre-cool injector estimator inputs. Gated on enable_pre_heating; consumed later by the
    // injector side-pass. handle_hotend_as_extruder is read only in this overload; nozzle_diameter uses
    // the non-nullable ConfigOptionFloats type.
    const ConfigOptionFloatsNullable* hotend_cooling_rate = config.option<ConfigOptionFloatsNullable>("hotend_cooling_rate");
    if (hotend_cooling_rate != nullptr)
        m_hotend_cooling_rate = hotend_cooling_rate->values;
 
    const ConfigOptionFloatsNullable* hotend_heating_rate = config.option<ConfigOptionFloatsNullable>("hotend_heating_rate");
    if (hotend_heating_rate != nullptr)
        m_hotend_heating_rate = hotend_heating_rate->values;
 
    const ConfigOptionIntsNullable* filament_pre_cooling_temperature = config.option<ConfigOptionIntsNullable>("filament_pre_cooling_temperature");
    if (filament_pre_cooling_temperature != nullptr)
        m_filament_pre_cooling_temp = filament_pre_cooling_temperature->values;
 
    const ConfigOptionFloatsNullable* filament_preheat_temperature_delta = config.option<ConfigOptionFloatsNullable>("filament_preheat_temperature_delta");
    if (filament_preheat_temperature_delta != nullptr)
        m_filament_preheat_temperature_delta = filament_preheat_temperature_delta->values;
 
    const ConfigOptionBool* enable_pre_heating = config.option<ConfigOptionBool>("enable_pre_heating");
    if (enable_pre_heating != nullptr)
        m_enable_pre_heating = enable_pre_heating->value;
 
    const ConfigOptionBool* handle_hotend_as_extruder = config.option<ConfigOptionBool>("handle_hotend_as_extruder");
    if (handle_hotend_as_extruder != nullptr)
        m_handle_hotend_as_extruder = handle_hotend_as_extruder->value;
 
    const ConfigOptionBool* has_filament_switcher = config.option<ConfigOptionBool>("has_filament_switcher");
    if (has_filament_switcher != nullptr)
        m_has_filament_switcher = has_filament_switcher->value;
 
    const ConfigOptionFloats* nozzle_diameter = config.option<ConfigOptionFloats>("nozzle_diameter");
    if (nozzle_diameter != nullptr)
        m_nozzle_diameter = nozzle_diameter->values;
 
    const ConfigOptionStrings* filament_type = config.option<ConfigOptionStrings>("filament_type");
    if (filament_type != nullptr) {
        m_filament_types.resize(filament_type->size());
        for (size_t idx = 0; idx < filament_type->size(); ++idx)
            m_filament_types[idx] = filament_type->get_at(idx);
    }
 
    const ConfigOptionEnumsGeneric* extruder_type = config.option<ConfigOptionEnumsGeneric>("extruder_type");
    if (extruder_type != nullptr) {
        m_result.extruder_types.resize(extruder_type->values.size());
        for (size_t idx = 0; idx < extruder_type->values.size(); ++idx)
            m_result.extruder_types[idx] = static_cast<ExtruderType>(extruder_type->values[idx]);
    }
 
    if (const ConfigOptionStrings* pe_variant = config.option<ConfigOptionStrings>("printer_extruder_variant"))
        m_result.printer_extruder_variant = pe_variant->values;
    if (const ConfigOptionInts* pe_id = config.option<ConfigOptionInts>("printer_extruder_id"))
        m_result.printer_extruder_id = pe_id->values;
 
    const ConfigOptionEnumsGenericNullable* nozzle_type = config.option<ConfigOptionEnumsGenericNullable>("nozzle_type");
    if (nozzle_type != nullptr) {
        m_result.nozzle_type.resize(nozzle_type->size());
        for (size_t idx = 0; idx < nozzle_type->values.size(); ++idx) {
            m_result.nozzle_type[idx] = NozzleType(nozzle_type->values[idx]);
        }
    }
 
    const ConfigOptionEnum<GCodeFlavor>* gcode_flavor = config.option<ConfigOptionEnum<GCodeFlavor>>("gcode_flavor");
    if (gcode_flavor != nullptr)
        m_flavor = gcode_flavor->value;
 
    const ConfigOptionPoints* printable_area = config.option<ConfigOptionPoints>("printable_area");
    if (printable_area != nullptr)
        m_result.printable_area = make_counter_clockwise(printable_area->values);
 
    //BBS: add bed_exclude_area
    const ConfigOptionPoints* bed_exclude_area = config.option<ConfigOptionPoints>("bed_exclude_area");
    if (bed_exclude_area != nullptr)
        m_result.bed_exclude_area = bed_exclude_area->values;
 
    const ConfigOptionPoints* wrapping_exclude_area = config.option<ConfigOptionPoints>("wrapping_exclude_area");
    if (wrapping_exclude_area != nullptr)
        m_result.wrapping_exclude_area = wrapping_exclude_area->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;
 
    const ConfigOptionString* printer_model = config.option<ConfigOptionString>("printer_model");
    if (printer_model != nullptr)
        m_printer_model = printer_model->value;
 
    // BBS
    m_result.filaments_count = config.option<ConfigOptionFloats>("filament_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.filaments_count) {
        for (size_t i = m_result.filament_diameters.size(); i < m_result.filaments_count; ++i) {
            m_result.filament_diameters.emplace_back(DEFAULT_FILAMENT_DIAMETER);
        }
    }
 
    const ConfigOptionInts *filament_HRC = config.option<ConfigOptionInts>("required_nozzle_HRC");
    if (filament_HRC != nullptr) {
        m_result.required_nozzle_HRC.clear();
        m_result.required_nozzle_HRC.resize(filament_HRC->values.size());
        for (size_t i = 0; i < filament_HRC->values.size(); ++i) { m_result.required_nozzle_HRC[i] = static_cast<float>(filament_HRC->values[i]); }
    }
 
    if (m_result.required_nozzle_HRC.size() < m_result.filaments_count) {
        for (size_t i = m_result.required_nozzle_HRC.size(); i < m_result.filaments_count; ++i) { m_result.required_nozzle_HRC.emplace_back(DEFAULT_FILAMENT_HRC);
        }
    }
 
    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.filaments_count) {
        for (size_t i = m_result.filament_densities.size(); i < m_result.filaments_count; ++i) {
            m_result.filament_densities.emplace_back(DEFAULT_FILAMENT_DENSITY);
        }
    }
 
    auto filament_maps = config.option<ConfigOptionInts>("filament_map");
    if (filament_maps != nullptr) {
        m_filament_maps = filament_maps->values;
        std::transform(m_filament_maps.begin(), m_filament_maps.end(), m_filament_maps.begin(), [](int value) {return value - 1; });
    }
 
    //BBS
    const ConfigOptionFloats* filament_costs = config.option<ConfigOptionFloats>("filament_cost");
    if (filament_costs != nullptr) {
        m_result.filament_costs.clear();
        m_result.filament_costs.resize(filament_costs->values.size());
        for (size_t i = 0; i < filament_costs->values.size(); ++i)
            m_result.filament_costs[i]=static_cast<float>(filament_costs->values[i]);
    }
    for (size_t i = m_result.filament_costs.size(); i < m_result.filaments_count; ++i) {
        m_result.filament_costs.emplace_back(DEFAULT_FILAMENT_COST);
    }
 
    //BBS
    const ConfigOptionInts* filament_vitrification_temperature = config.option<ConfigOptionInts>("temperature_vitrification");
    if (filament_vitrification_temperature != nullptr) {
        m_result.filament_vitrification_temperature.clear();
        m_result.filament_vitrification_temperature.resize(filament_vitrification_temperature->values.size());
        for (size_t i = 0; i < filament_vitrification_temperature->values.size(); ++i) {
            m_result.filament_vitrification_temperature[i] = static_cast<int>(filament_vitrification_temperature->values[i]);
        }
    }
    if (m_result.filament_vitrification_temperature.size() < m_result.filaments_count) {
        for (size_t i = m_result.filament_vitrification_temperature.size(); i < m_result.filaments_count; ++i) {
            m_result.filament_vitrification_temperature.emplace_back(DEFAULT_FILAMENT_VITRIFICATION_TEMPERATURE);
        }
    }
 
    const ConfigOptionPoints* extruder_offset = config.option<ConfigOptionPoints>("extruder_offset");
    const ConfigOptionBool* single_extruder_multi_material = config.option<ConfigOptionBool>("single_extruder_multi_material");
    if (extruder_offset != nullptr) {
        //BBS: for single extruder multi material, only use the offset of first extruder
        if (single_extruder_multi_material != nullptr && single_extruder_multi_material->getBool()) {
            Vec2f offset = extruder_offset->values[0].cast<float>();
            m_extruder_offsets.resize(m_result.filaments_count);
            for (size_t i = 0; i < m_result.filaments_count; ++i) {
                m_extruder_offsets[i] = { offset(0), offset(1), 0.0f };
            }
        }
        else {
            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.filaments_count) {
        for (size_t i = m_extruder_offsets.size(); i < m_result.filaments_count; ++i) {
            m_extruder_offsets.emplace_back(DEFAULT_EXTRUDER_OFFSET);
        }
    }
 
    // BBS
    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.filaments_count) {
        for (size_t i = m_result.extruder_colors.size(); i < m_result.filaments_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.filaments_count);
 
    const ConfigOptionFloat* machine_load_filament_time = config.option<ConfigOptionFloat>("machine_load_filament_time");
    if (machine_load_filament_time != nullptr)
        m_time_processor.filament_load_times = static_cast<float>(machine_load_filament_time->value);
 
    const ConfigOptionFloat* machine_unload_filament_time = config.option<ConfigOptionFloat>("machine_unload_filament_time");
    if (machine_unload_filament_time != nullptr)
        m_time_processor.filament_unload_times = static_cast<float>(machine_unload_filament_time->value);
 
    const ConfigOptionFloat* machine_tool_change_time = config.option<ConfigOptionFloat>("machine_tool_change_time");
    if (machine_tool_change_time != nullptr)
        m_time_processor.machine_tool_change_time = static_cast<float>(machine_tool_change_time->value);
 
    if (m_flavor == gcfMarlinLegacy || m_flavor == gcfMarlinFirmware || 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_speed_x = config.option<ConfigOptionFloats>("machine_max_speed_x");
        if (machine_max_speed_x != nullptr)
            m_time_processor.machine_limits.machine_max_speed_x.values = machine_max_speed_x->values;
 
        const ConfigOptionFloats* machine_max_speed_y = config.option<ConfigOptionFloats>("machine_max_speed_y");
        if (machine_max_speed_y != nullptr)
            m_time_processor.machine_limits.machine_max_speed_y.values = machine_max_speed_y->values;
 
        const ConfigOptionFloats* machine_max_speed_z = config.option<ConfigOptionFloats>("machine_max_speed_z");
        if (machine_max_speed_z != nullptr)
            m_time_processor.machine_limits.machine_max_speed_z.values = machine_max_speed_z->values;
 
        const ConfigOptionFloats* machine_max_speed_e = config.option<ConfigOptionFloats>("machine_max_speed_e");
        if (machine_max_speed_e != nullptr)
            m_time_processor.machine_limits.machine_max_speed_e.values = machine_max_speed_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_jerk_z");
        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_junction_deviation = config.option<ConfigOptionFloats>("machine_max_junction_deviation");
        if (machine_max_junction_deviation != nullptr)
              m_time_processor.machine_limits.machine_max_junction_deviation.values = machine_max_junction_deviation->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 does not have separate travel acceleration, it uses 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;
 
        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;
    }
 
    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;
    }
 
    const ConfigOptionFloat* initial_layer_print_height = config.option<ConfigOptionFloat>("initial_layer_print_height");
    if (initial_layer_print_height != nullptr)
        m_first_layer_height = std::abs(initial_layer_print_height->value);
 
    const ConfigOptionFloat* printable_height = config.option<ConfigOptionFloat>("printable_height");
    if (printable_height != nullptr)
        m_result.printable_height = printable_height->value;
 
    const ConfigOptionBool* spiral_vase = config.option<ConfigOptionBool>("spiral_mode");
    if (spiral_vase != nullptr) {
        m_detect_layer_based_on_tag = spiral_vase->value;
        m_result.spiral_vase_mode = spiral_vase->value;
    }
 
    const ConfigOptionBool* has_scarf_joint_seam = config.option<ConfigOptionBool>("has_scarf_joint_seam");
    if (has_scarf_joint_seam != nullptr)
        m_detect_layer_based_on_tag = m_detect_layer_based_on_tag || has_scarf_joint_seam->value;
 
    const ConfigOptionBool* manual_filament_change = config.option<ConfigOptionBool>("manual_filament_change");
    if (manual_filament_change != nullptr)
        m_manual_filament_change = manual_filament_change->value;
 
    const ConfigOptionEnumGeneric *bed_type = config.option<ConfigOptionEnumGeneric>("curr_bed_type");
    if (bed_type != nullptr)
        m_result.bed_type = (BedType)bed_type->value;
 
 
    const ConfigOptionFloat* z_offset = config.option<ConfigOptionFloat>("z_offset");
    if (z_offset != nullptr)
        m_z_offset = z_offset->value;
 
    // Reprocessing an existing g-code (from-previous reload / imported g-code) reaches apply_config
    // through this DynamicPrintConfig overload; rebuild the per-filament nozzle grouping onto the
    // result so the multi-nozzle device GUI can map filaments to physical nozzles. The normal
    // streaming export uses the PrintConfig overload and hands the live grouping over separately, so
    // it is intentionally not touched here.
    ensure_nozzle_group_result(static_cast<int>(m_result.filaments_count));
}

References Slic3r::PrintEstimatedStatistics::Count, DEFAULT_ACCELERATION, DEFAULT_EXTRUDER_OFFSET, DEFAULT_FILAMENT_COST, Slic3r::DEFAULT_FILAMENT_DENSITY, DEFAULT_FILAMENT_DIAMETER, DEFAULT_FILAMENT_HRC, DEFAULT_FILAMENT_VITRIFICATION_TEMPERATURE, DEFAULT_RETRACT_ACCELERATION, DEFAULT_TRAVEL_ACCELERATION, ensure_nozzle_group_result(), Slic3r::extruder_max_nozzle_count(), Slic3r::extruder_offset(), Slic3r::filament_pre_cooling_temperature(), Slic3r::filament_type(), Slic3r::gcfKlipper, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcode_flavor(), Slic3r::get_option_value(), Slic3r::has_scarf_joint_seam(), Slic3r::hotend_cooling_rate(), Slic3r::initial_layer_print_height(), m_belt_render_config, m_detect_layer_based_on_tag, m_enable_pre_heating, m_extruder_colors, m_extruder_max_nozzle_count, m_extruder_offsets, m_extruder_temps, m_filament_maps, m_filament_pre_cooling_temp, m_filament_preheat_temperature_delta, m_filament_types, m_first_layer_height, m_flavor, m_handle_hotend_as_extruder, m_has_filament_switcher, m_hotend_cooling_rate, m_hotend_heating_rate, m_manual_filament_change, m_nozzle_diameter, m_nozzle_volume, m_parser, m_physical_extruder_map, m_printer_model, m_result, m_time_processor, m_z_offset, Slic3r::machine_load_filament_time(), Slic3r::machine_unload_filament_time(), Slic3r::make_counter_clockwise(), Slic3r::nozzle_diameter(), Slic3r::nozzle_type(), Slic3r::offset(), Slic3r::ConfigBase::option(), Slic3r::physical_extruder_map(), Slic3r::printable_area(), Slic3r::printable_height(), Slic3r::single_extruder_multi_material(), Slic3r::ConfigOptionVector< double >::size(), Slic3r::ConfigOptionSingle< T >::value, Slic3r::ConfigOptionVector< T >::values, Slic3r::ConfigOptionVector< double >::values, and Slic3r::ConfigOptionVector< int >::values.

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_flavor = config.gcode_flavor;
    m_printer_model = config.printer_model.value;
 
    m_single_extruder_multi_material = config.single_extruder_multi_material;
 
    size_t filament_count = config.filament_diameter.values.size();
    m_result.filaments_count = filament_count;
 
    // Orca:
    m_is_XL_printer = is_XL_printer(config);
    m_preheat_time = config.preheat_time;
    m_preheat_steps = config.preheat_steps;
    // sanity check
    if(m_preheat_steps < 1)
        m_preheat_steps = 1;
    m_result.backtrace_enabled = config.ooze_prevention && m_preheat_time > 0 && (m_is_XL_printer || (!m_single_extruder_multi_material && filament_count > 1));
 
    assert(config.nozzle_volume.size() == config.nozzle_diameter.size());
    m_nozzle_volume.resize(config.nozzle_volume.size());
    for (size_t idx = 0; idx < config.nozzle_volume.size(); ++idx)
        m_nozzle_volume[idx] = config.nozzle_volume.values[idx];
 
    m_physical_extruder_map = config.physical_extruder_map.values;
    // Multi-nozzle context state, consumed by the multi-nozzle time model and pre-heat injector.
    m_extruder_max_nozzle_count = config.extruder_max_nozzle_count.values;
 
    // Pre-heat / pre-cool injector estimator inputs. Gated on enable_pre_heating; the injector
    // side-pass that consumes them runs later in run_second_pass_injection. has_filament_switcher is
    // read defensively because it is registered as a ConfigDef only, not a static PrintConfig member.
    m_filament_types.resize(filament_count);
    for (size_t idx = 0; idx < filament_count; ++idx)
        m_filament_types[idx] = config.filament_type.get_at(idx);
    m_nozzle_diameter                    = config.nozzle_diameter.values;
    m_hotend_cooling_rate                = config.hotend_cooling_rate.values;
    m_hotend_heating_rate                = config.hotend_heating_rate.values;
    m_filament_pre_cooling_temp          = config.filament_pre_cooling_temperature.values;
    m_filament_preheat_temperature_delta = config.filament_preheat_temperature_delta.values;
    m_enable_pre_heating                 = config.enable_pre_heating.value;
    if (const ConfigOptionBool* has_switcher = config.option<ConfigOptionBool>("has_filament_switcher"))
        m_has_filament_switcher = has_switcher->value;
    m_result.extruder_types.resize(config.extruder_type.values.size());
    for (size_t idx = 0; idx < config.extruder_type.values.size(); ++idx)
        m_result.extruder_types[idx] = static_cast<ExtruderType>(config.extruder_type.values[idx]);
    m_result.printer_extruder_variant = config.printer_extruder_variant.values;
    m_result.printer_extruder_id      = config.printer_extruder_id.values;
 
    m_extruder_offsets.resize(filament_count);
    m_extruder_colors.resize(filament_count);
    m_result.filament_diameters.resize(filament_count);
    m_result.required_nozzle_HRC.resize(filament_count);
    m_result.filament_densities.resize(filament_count);
    m_result.filament_vitrification_temperature.resize(filament_count);
    m_result.filament_costs.resize(filament_count);
    m_extruder_temps.resize(filament_count);
    m_filament_nozzle_temp.resize(filament_count);
    m_filament_nozzle_temp_first_layer.resize(filament_count);
    m_result.nozzle_hrc = static_cast<int>(config.nozzle_hrc.getInt());
    std::vector<NozzleType>(config.nozzle_type.size()).swap(m_result.nozzle_type);
    for (size_t idx = 0; idx < m_result.nozzle_type.size(); ++idx) {
        m_result.nozzle_type[idx] = NozzleType(config.nozzle_type.values[idx]);
    }
 
    std::vector<int> filament_map = config.filament_map.values; // 1 based idxs
    // if filament map has wrong length, set filament to master extruder_id
    filament_map.resize(filament_count, config.master_extruder_id.value);
 
    for (size_t i = 0; i < filament_count; ++ i) {
        m_extruder_offsets[i] = to_3d(config.extruder_offset.get_at(filament_map[i] - 1).cast<float>().eval(), 0.f);
        m_extruder_colors[i]            = static_cast<unsigned char>(i);
        // Orca: pre-heat bookkeeping reads the filament's first per-variant column by design;
        // it feeds estimation-side heat-up modelling only, never the emitted commands.
        m_filament_nozzle_temp_first_layer[i] = static_cast<int>(config.nozzle_temperature_initial_layer.get_at(i));
        m_filament_nozzle_temp[i]      = static_cast<int>(config.nozzle_temperature.get_at(i));
        if (m_filament_nozzle_temp[i] == 0) {
            // This means the value should be ignored and first layer temp should be used.
            m_filament_nozzle_temp[i] = m_filament_nozzle_temp_first_layer[i];
        }
        m_result.filament_diameters[i]  = static_cast<float>(config.filament_diameter.get_at(i));
        m_result.required_nozzle_HRC[i] = static_cast<int>(config.required_nozzle_HRC.get_at(i));
        m_result.filament_densities[i]  = static_cast<float>(config.filament_density.get_at(i));
        m_result.filament_vitrification_temperature[i] = static_cast<float>(config.temperature_vitrification.get_at(i));
        m_result.filament_costs[i]      = static_cast<float>(config.filament_cost.get_at(i));
    }
 
    if (m_flavor == gcfMarlinLegacy || m_flavor == gcfMarlinFirmware || m_flavor == gcfKlipper || m_flavor == gcfRepRapFirmware) {
        m_time_processor.machine_limits = reinterpret_cast<const MachineEnvelopeConfig&>(config);
        if (m_flavor == gcfMarlinLegacy || m_flavor == gcfKlipper) {
            // Legacy Marlin does not have separate travel acceleration, it uses 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 = static_cast<float>(config.machine_load_filament_time.value);
    m_time_processor.filament_unload_times = static_cast<float>(config.machine_unload_filament_time.value);
    m_time_processor.machine_tool_change_time = static_cast<float>(config.machine_tool_change_time.value);
 
    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)){
            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_disable_m73 = config.disable_m73;
 
    const ConfigOptionFloat* initial_layer_print_height = config.option<ConfigOptionFloat>("initial_layer_print_height");
    if (initial_layer_print_height != nullptr)
        m_first_layer_height = std::abs(initial_layer_print_height->value);
 
    m_result.printable_height = config.printable_height;
 
    // Belt printer: cache the post-gcode machine-frame transform so the
    // multi-extruder validator can undo it and compare against build-volume
    // bounds rather than machine-frame positions.
    m_machine_frame_transform.init_from_config(config);
    m_result.machine_frame_transform_active = m_machine_frame_transform.is_active();
    m_belt_printer = config.belt_printer.value;
 
    auto filament_maps = config.option<ConfigOptionInts>("filament_map");
    if (filament_maps != nullptr) {
        m_filament_maps = filament_maps->values;
        std::transform(m_filament_maps.begin(), m_filament_maps.end(), m_filament_maps.begin(), [](int value) {return value - 1; });
    }
 
    const ConfigOptionBool* spiral_vase = config.option<ConfigOptionBool>("spiral_mode");
    if (spiral_vase != nullptr) {
        m_detect_layer_based_on_tag = spiral_vase->value;
        m_result.spiral_vase_mode = spiral_vase->value;
    }
 
    const ConfigOptionBool* has_scarf_joint_seam = config.option<ConfigOptionBool>("has_scarf_joint_seam");
    if (has_scarf_joint_seam != nullptr)
        m_detect_layer_based_on_tag = m_detect_layer_based_on_tag || has_scarf_joint_seam->value;
 
    const ConfigOptionBool* manual_filament_change = config.option<ConfigOptionBool>("manual_filament_change");
    if (manual_filament_change != nullptr)
        m_manual_filament_change = manual_filament_change->value;
 
    const ConfigOptionFloat* z_offset = config.option<ConfigOptionFloat>("z_offset");
    if (z_offset != nullptr)
        m_z_offset = z_offset->value;
 
}

References Slic3r::PrintEstimatedStatistics::Count, DEFAULT_ACCELERATION, DEFAULT_RETRACT_ACCELERATION, DEFAULT_TRAVEL_ACCELERATION, Slic3r::filament_map(), Slic3r::gcfKlipper, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepRapFirmware, Slic3r::get_option_value(), Slic3r::has_scarf_joint_seam(), Slic3r::initial_layer_print_height(), Slic3r::is_XL_printer(), m_belt_printer, m_detect_layer_based_on_tag, m_disable_m73, m_enable_pre_heating, m_extruder_colors, m_extruder_max_nozzle_count, m_extruder_offsets, m_extruder_temps, m_filament_maps, m_filament_nozzle_temp, m_filament_nozzle_temp_first_layer, m_filament_pre_cooling_temp, m_filament_preheat_temperature_delta, m_filament_types, m_first_layer_height, m_flavor, m_has_filament_switcher, m_hotend_cooling_rate, m_hotend_heating_rate, m_is_XL_printer, m_machine_frame_transform, m_manual_filament_change, m_nozzle_diameter, m_nozzle_volume, m_parser, m_physical_extruder_map, m_preheat_steps, m_preheat_time, m_printer_model, m_result, m_single_extruder_multi_material, m_time_processor, m_z_offset, Slic3r::MachineEnvelopeConfig, Slic3r::GCodeWriter::supports_separate_travel_acceleration(), Slic3r::to_3d(), and Slic3r::ConfigOptionSingle< T >::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_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("extruderDiameter") != comment.npos) {
                            std::vector<float> extruder_diameters;
                            extract_floats(comment, "extruderDiameter", extruder_diameters);
                            m_result.filaments_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.filaments_count == 0)
        m_result.filaments_count = std::max<size_t>(1, std::min(m_result.filament_diameters.size(), m_result.filament_densities.size()));
 
    if (bed_size.is_defined()) {
        m_result.printable_area = {
            { 0.0, 0.0 },
            { bed_size.x, 0.0 },
            { bed_size.x, bed_size.y },
            { 0.0, bed_size.y }
        };
    }
}

References m_parser, m_result, 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:

calc_junction_acceleration()

float Slic3r::GCodeProcessor::calc_junction_acceleration ( const TimeBlock & block, const Vec4f & junction_unit_vec, PrintEstimatedStatistics::ETimeMode mode ) const

private

{
    float junction_acceleration = block.acceleration;
    for (unsigned char a = X; a <= E; ++a) {
        if (junction_unit_vec[a] == 0.0f)
            continue;
        const float axis_max_acceleration = get_axis_max_acceleration(mode, static_cast<Axis>(a), m_machine_config_idx);
        if (axis_max_acceleration > 0.0f)
            junction_acceleration = std::min(junction_acceleration, std::abs(axis_max_acceleration / junction_unit_vec[a]));
    }
    return junction_acceleration;
}

References Slic3r::GCodeProcessor::TimeBlock::acceleration, Slic3r::E, get_axis_max_acceleration(), m_machine_config_idx, and Slic3r::X.

Referenced by calc_vmax_junction_deviation().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_vmax_junction_deviation()

float Slic3r::GCodeProcessor::calc_vmax_junction_deviation ( const TimeBlock & block, const TimeMachine::State & prev, const TimeMachine::State & curr, bool has_prev_move, PrintEstimatedStatistics::ETimeMode mode ) const

private

{
    if (m_flavor == gcfKlipper) {
        if (!has_prev_move || curr.enter_direction.isZero() || prev.exit_direction.isZero())
            return 0.0f;
        const TimeBlock& previous = m_time_processor.machines[static_cast<size_t>(mode)].blocks.back();
        double limit = std::min(sqr(double(block.feedrate_profile.cruise)), sqr(double(prev.feedrate)));
        const double extrude_ratio_change = std::abs(curr.axis_feedrate[E] / curr.feedrate -
                                                   prev.axis_feedrate[E] / prev.feedrate);
        // Klipper's instantaneous_corner_velocity defaults to 1 mm/s.
        // It is independent of machine_max_jerk_e; custom firmware values
        // cannot be inferred from the slicer's jerk setting.
        if (extrude_ratio_change > 0.0f)
            limit = std::min(limit, sqr(1.0 / extrude_ratio_change));
        // Recover directions from the double-precision axis velocities: float
        // unit vectors lose the angle between nearly collinear short segments.
        const Vec3d prev_direction = Vec3d(prev.axis_feedrate[X], prev.axis_feedrate[Y], prev.axis_feedrate[Z]).normalized();
        const Vec3d curr_direction = Vec3d(curr.axis_feedrate[X], curr.axis_feedrate[Y], curr.axis_feedrate[Z]).normalized();
        const double cosine = std::clamp(-prev_direction.dot(curr_direction), -1.0, 1.0);
        const double sin_half = std::sqrt(0.5 * (1.0 - cosine));
        const double cos_half = std::sqrt(0.5 * (1.0 + cosine));
        if (sin_half < 1.0 && cos_half > 0.0) {
            const double radius = sin_half / (1.0 - sin_half);
            const double half_tan = 0.5 * sin_half / cos_half;
            limit = std::min({limit,
                radius * block.junction_deviation * block.acceleration,
                radius * previous.junction_deviation * previous.acceleration,
                half_tan * block.distance * block.acceleration,
                half_tan * previous.distance * previous.acceleration});
        }
        return std::sqrt(limit);
    }
    const float junction_deviation = get_junction_deviation(mode, block.acceleration);
    if (junction_deviation <= 0.0f)
        return -1.0f; // classic jerk machine, the caller keeps its own computation
    if (!has_prev_move)
        return 0.0f;  // starts from rest, the planner raises this on the reverse pass
 
    // Unit vectors over XYZE keep this a cosine. Scaling by 1 / XYZ distance
    // leaves an E term that makes extruding corners appear straighter.
    // Marlin normalizes over XYZE; the Klipper branch above uses XYZ only.
    float junction_cos_theta = (-prev.jd_unit_vec).dot(curr.jd_unit_vec);
    if (junction_cos_theta > 0.999999f)
        return 0.0f; // the path doubles back, the machine has to stop
    junction_cos_theta = std::max(junction_cos_theta, -0.999999f); // guards the division below
 
    const float sin_theta_d2 = std::sqrt(0.5f * (1.0f - junction_cos_theta)); // always positive
    const Vec4f junction_vec = curr.jd_unit_vec - prev.jd_unit_vec;
    const float junction_vec_norm = junction_vec.norm();
    const Vec4f junction_unit_vec = (junction_vec_norm > 0.0f) ? Vec4f(junction_vec / junction_vec_norm)
                                                               : Vec4f(0.0f, 0.0f, 0.0f, 0.0f);
    const float junction_acceleration = calc_junction_acceleration(block, junction_unit_vec, mode);
 
    float vmax_junction_sqr = (junction_acceleration * junction_deviation * sin_theta_d2) / (1.0f - sin_theta_d2);
 
    // Marlin's JD_HANDLE_SMALL_SEGMENTS: a short move through a shallow corner is treated as an arc and
    // capped by the centripetal acceleration it needs.
    if (block.distance < 1.0f && junction_cos_theta < -0.7071067812f) {
        // Fast acos(-t), max. error +-0.033rad. MinMax polynomial by W. Randolph Franklin:
        // https://wrf.ecse.rpi.edu/Research/Short_Notes/arcsin/onlyelem.html
        const float neg = junction_cos_theta < 0.0f ? -1.0f : 1.0f;
        const float t = neg * junction_cos_theta;
        const float asinx = 0.032843707f + t * (-1.451838349f + t * (29.66153956f + t * (-131.1123477f +
                            t * (262.8130562f + t * (-242.7199627f + t * (84.31466202f))))));
        const float junction_theta = float(0.5 * M_PI) + neg * asinx; // acos(-t), bottoms out at 0.033
        vmax_junction_sqr = std::min(vmax_junction_sqr, (block.distance * junction_acceleration) / junction_theta);
    }
 
    // Never faster than either of the two moves the junction joins.
    vmax_junction_sqr = std::min(vmax_junction_sqr, std::min(sqr(block.feedrate_profile.cruise), sqr(prev.feedrate)));
    return std::sqrt(vmax_junction_sqr);
}

References Slic3r::GCodeProcessor::TimeBlock::acceleration, Slic3r::GCodeProcessor::TimeMachine::State::axis_feedrate, calc_junction_acceleration(), Slic3r::GCodeProcessor::FeedrateProfile::cruise, Slic3r::GCodeProcessor::TimeBlock::distance, Slic3r::dot(), Slic3r::E, Slic3r::GCodeProcessor::TimeMachine::State::enter_direction, Slic3r::GCodeProcessor::TimeMachine::State::exit_direction, Slic3r::GCodeProcessor::TimeMachine::State::feedrate, Slic3r::GCodeProcessor::TimeBlock::feedrate_profile, Slic3r::gcfKlipper, get_junction_deviation(), Slic3r::GCodeProcessor::TimeMachine::State::jd_unit_vec, Slic3r::GCodeProcessor::TimeBlock::junction_deviation, m_flavor, M_PI, m_time_processor, Slic3r::sqr(), Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by process_G1(), and process_VG1().

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_time()

void Slic3r::GCodeProcessor::calculate_time ( GCodeProcessorResult & result, size_t keep_last_n_blocks = 0, float additional_time = 0.0f, EMoveType target_move_type = EMoveType::Noop, bool is_final = false )

private

{
    // calculate times
    std::vector<TimeMachine::ActualSpeedMove> actual_speed_moves;
    for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
        TimeMachine& machine = m_time_processor.machines[i];
        machine.klipper = m_flavor == gcfKlipper;
        machine.calculate_time(m_result, static_cast<PrintEstimatedStatistics::ETimeMode>(i), keep_last_n_blocks, additional_time, target_move_type, is_final);
        if (static_cast<PrintEstimatedStatistics::ETimeMode>(i) == PrintEstimatedStatistics::ETimeMode::Normal)
            actual_speed_moves = std::move(machine.actual_speed_moves);
    }
 
    // actual_speed_moves holds, per block in move order, the moves to insert before the block's move and then an
    // entry without a position for that move; positioned entries after the last such entry are dropped.
    std::vector<GCodeProcessorResult::MoveVertex>& moves = result.moves;
    size_t inserted_actual_speed_moves_count = 0;
    size_t kept                              = 0;
    size_t group_start                       = 0;
    for (size_t i = 0; i < actual_speed_moves.size(); ++i) {
        if (actual_speed_moves[i].position.has_value())
            continue;
        const unsigned int move_id = actual_speed_moves[i].move_id;
        // A VG1 block has no move of its own, so its id can fall behind the previous block's or point past the list.
        if (move_id < moves.size() && (kept == 0 || move_id > actual_speed_moves[kept - 1].move_id)) {
            inserted_actual_speed_moves_count += i - group_start;
            moves[move_id].actual_feedrate = actual_speed_moves[i].actual_feedrate;
            // A seam vertex right after a block's move shares its actual speed.
            if (move_id + 1 < moves.size() && moves[move_id + 1].type == EMoveType::Seam)
                moves[move_id + 1].actual_feedrate = actual_speed_moves[i].actual_feedrate;
            for (size_t j = group_start; j <= i; ++j, ++kept)
                if (kept != j)
                    actual_speed_moves[kept] = std::move(actual_speed_moves[j]);
        }
        group_start = i + 1;
    }
    actual_speed_moves.erase(actual_speed_moves.begin() + kept, actual_speed_moves.end());
 
    // Walks the blocks back to front, so each shifted move is moved once, into its final slot.
    size_t read  = moves.size(); // one past the last move not yet placed
    moves.resize(moves.size() + inserted_actual_speed_moves_count);
    size_t write = moves.size(); // one past the last free slot
    m_actual_speed_id_map.clear();
    size_t entry = actual_speed_moves.size();
    while (entry > 0) {
        const unsigned int block_id = actual_speed_moves[--entry].move_id;
        assert(block_id < read);
        while (read > block_id + 1)
            moves[--write] = moves[--read];
        const GCodeProcessorResult::MoveVertex block_move = moves[--read];
        moves[--write] = block_move;
        m_actual_speed_id_map.emplace_back(block_id, (unsigned int)write);
        for (; entry > 0 && actual_speed_moves[entry - 1].position.has_value(); --entry) {
            const TimeMachine::ActualSpeedMove& it = actual_speed_moves[entry - 1];
            GCodeProcessorResult::MoveVertex new_move = block_move;
            new_move.time = { 0.0f, 0.0f };
            new_move.position = *it.position;
            new_move.actual_feedrate = it.actual_feedrate;
            new_move.delta_extruder = *it.delta_extruder;
            new_move.feedrate = *it.feedrate;
            new_move.width = *it.width;
            new_move.height = *it.height;
            new_move.mm3_per_mm = *it.mm3_per_mm;
            new_move.fan_speed = *it.fan_speed;
            new_move.temperature = *it.temperature;
            new_move.internal_only = true;
            moves[--write] = new_move;
        }
    }
    assert(read == write);
 
    // synchronize blocks' move_ids with after moves for actual speed insertion
    std::reverse(m_actual_speed_id_map.begin(), m_actual_speed_id_map.end());
    for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
        for (GCodeProcessor::TimeBlock& block : m_time_processor.machines[i].blocks) {
            auto it = std::lower_bound(m_actual_speed_id_map.begin(), m_actual_speed_id_map.end(), block.move_id,
                                       [](const std::pair<unsigned int, unsigned int>& entry, unsigned int id) { return entry.first < id; });
            block.move_id = (it != m_actual_speed_id_map.end() && it->first == block.move_id) ?
                                it->second : block.move_id + (unsigned int)inserted_actual_speed_moves_count;
        }
    }
    m_options_z_corrector.on_moves_inserted(m_actual_speed_id_map);
}

References Slic3r::GCodeProcessor::TimeMachine::ActualSpeedMove::actual_feedrate, Slic3r::GCodeProcessorResult::MoveVertex::actual_feedrate, Slic3r::GCodeProcessor::TimeMachine::actual_speed_moves, Slic3r::GCodeProcessor::TimeMachine::calculate_time(), Slic3r::PrintEstimatedStatistics::Count, Slic3r::GCodeProcessor::TimeMachine::ActualSpeedMove::delta_extruder, Slic3r::GCodeProcessorResult::MoveVertex::delta_extruder, Slic3r::GCodeProcessor::TimeMachine::ActualSpeedMove::fan_speed, Slic3r::GCodeProcessorResult::MoveVertex::fan_speed, Slic3r::GCodeProcessor::TimeMachine::ActualSpeedMove::feedrate, Slic3r::GCodeProcessorResult::MoveVertex::feedrate, Slic3r::gcfKlipper, Slic3r::GCodeProcessor::TimeMachine::ActualSpeedMove::height, Slic3r::GCodeProcessorResult::MoveVertex::height, Slic3r::GCodeProcessorResult::MoveVertex::internal_only, Slic3r::GCodeProcessor::TimeMachine::klipper, m_actual_speed_id_map, m_flavor, m_options_z_corrector, m_result, m_time_processor, Slic3r::GCodeProcessor::TimeMachine::ActualSpeedMove::mm3_per_mm, Slic3r::GCodeProcessorResult::MoveVertex::mm3_per_mm, Slic3r::GCodeProcessorResult::moves, Slic3r::PrintEstimatedStatistics::Normal, Slic3r::GCodeProcessor::TimeMachine::ActualSpeedMove::position, Slic3r::GCodeProcessorResult::MoveVertex::position, result(), Slic3r::Seam, Slic3r::GCodeProcessor::TimeMachine::ActualSpeedMove::temperature, Slic3r::GCodeProcessorResult::MoveVertex::temperature, Slic3r::GCodeProcessorResult::MoveVertex::time, Slic3r::GCodeProcessor::TimeMachine::ActualSpeedMove::width, and Slic3r::GCodeProcessorResult::MoveVertex::width.

Referenced by finalize(), process_G1(), and simulate_st_synchronize().

Here is the call graph for this function:

Here is the caller graph for this function:

check_multi_extruder_gcode_valid()

bool Slic3r::GCodeProcessor::check_multi_extruder_gcode_valid	(	const int	extruder_size,
		const Pointfs	plate_printable_area,
		const double	plate_printable_height,
		const Pointfs	wrapping_exclude_area,
		const std::vector< Polygons > &	unprintable_areas,
		const std::vector< double > &	printable_heights,
		const std::vector< int > &	filament_map,
		const std::vector< std::set< int > > &	unprintable_filament_types )

{
    m_result.limit_filament_maps.clear();
    m_result.gcode_check_result.reset();// including both single extruder machine printable area check result and multi extruder result
    Polygon plate_printable_poly = Polygon::new_scale(plate_printable_area);
    Polygon wrapping_exclude_poly = Polygon::new_scale(wrapping_exclude_area);
 
    m_result.limit_filament_maps.resize(filament_map.size(), 0);
 
    auto to_2d = [](const Vec3d &pos) -> Point {
        Point ps(scale_(pos.x()), scale_(pos.y()));
        return ps;
    };
 
    // Belt-printer post-gcode shear/scale/post_remap is applied as the final
    // step of BeltKinematics::to_machine, so MoveVertex.position is
    // in the printer's machine frame.  Undo it here so the XY area check
    // operates in the build-volume frame that printable_area is defined in
    // (the height checks below are skipped on belt printers).  For non-belt printers
    // (is_active() == false) apply_inverse is identity and behaviour is
    // unchanged from before.
    const bool machine_frame_active = m_machine_frame_transform.is_active();
    auto compare_pos = [&](const GCodeProcessorResult::MoveVertex &move) -> Vec3d {
        Vec3d pos = move.position.cast<double>();
        if (!machine_frame_active)
            return pos;
        Vec3d extruder_off = Vec3d::Zero();
        if (size_t(move.extruder_id) < m_extruder_offsets.size())
            extruder_off = m_extruder_offsets[move.extruder_id].cast<double>();
        // Strip plate + extruder offsets to recover the raw machine-frame
        // coordinate that was emitted into the G-code (see store_move_vertex).
        Vec3d machine(pos.x() - m_x_offset - extruder_off.x(),
                      pos.y() - m_y_offset - extruder_off.y(),
                      pos.z() - extruder_off.z() + m_z_offset);
        Vec3d build = m_machine_frame_transform.apply_inverse(machine);
        // Re-apply plate offset so the result matches plate_printable_poly,
        // which is translated by plate_offset below.
        return Vec3d(build.x() + m_x_offset, build.y() + m_y_offset, build.z());
    };
 
    struct GCodePosInfo
    {
        Points pos;
        Points pos_custom;
        float  max_print_z;
        float  max_print_z_custom;
    };
    std::map<int, std::map<int, GCodePosInfo>> gcode_path_pos; // object_id, filament_id, pos
    for (const GCodeProcessorResult::MoveVertex &move : m_result.moves) {
        // sometimes, the start line extrude was outside the edge of plate a little, this is allowed, so do not include into the gcode_path_pos
        if (move.type == EMoveType::Extrude /* && move.extrusion_role != ExtrusionRole::erFlush || move.type == EMoveType::Travel*/) {
            const Vec3d cp = compare_pos(move);
            // For belt printers we read Z from the inverse-transformed position
            // (post-origin-snap, pre-machine-frame).  Otherwise keep the
            // original print_z source (the slicer's layer-Z comment) so
            // non-belt behaviour is bit-for-bit unchanged.
            const float z_for_height = machine_frame_active ? float(cp.z()) : move.print_z;
            if (move.extrusion_role == ExtrusionRole::erCustom) {
                gcode_path_pos[move.object_label_id][int(move.extruder_id)].pos_custom.emplace_back(to_2d(cp));
                gcode_path_pos[move.object_label_id][int(move.extruder_id)].max_print_z_custom =
                    std::max(gcode_path_pos[move.object_label_id][int(move.extruder_id)].max_print_z_custom, z_for_height);
            } else {
                gcode_path_pos[move.object_label_id][int(move.extruder_id)].pos.emplace_back(to_2d(cp));
                gcode_path_pos[move.object_label_id][int(move.extruder_id)].max_print_z = std::max(gcode_path_pos[move.object_label_id][int(move.extruder_id)].max_print_z,
                                                                                                   z_for_height);
            }
        }
    }
 
    bool valid = true;
    Point plate_offset = Point(scale_(m_x_offset), scale_(m_y_offset));
    plate_printable_poly.translate(plate_offset);
    //wrapping_exclude_poly.translate(plate_offset);
    BoundingBox plate_printable_bbox = plate_printable_poly.bounding_box();
    if (plate_printable_poly.is_valid()) {
        plate_printable_bbox.offset(scale_(2.0)); // Expand the range to provide a tolerance
    } else
        plate_printable_bbox.defined = false; //when this is used, the printable area config was missing, something wrong
 
    for (auto obj_iter = gcode_path_pos.begin(); obj_iter != gcode_path_pos.end(); ++obj_iter) {
        int                                object_label_id = obj_iter->first;
        const std::map<int, GCodePosInfo> &path_pos        = obj_iter->second;
        for (auto iter = path_pos.begin(); iter != path_pos.end(); ++iter) {
            int extruder_id = filament_map[iter->first] - 1;
            Points iter_points;//temp points
            iter_points.insert(iter_points.end(), iter->second.pos.begin(), iter->second.pos.end());// put object/wipetower extrude position in
            Polygon     path_poly(iter_points);
            if (path_poly.empty()) continue;
            BoundingBox bbox = path_poly.bounding_box();
            if (plate_printable_bbox.defined) {
                if (!plate_printable_bbox.contains(bbox)) { // out of the bed area
                    m_result.gcode_check_result.error_code |= (1<<2);
                    std::pair<int, int> filament_to_object_id;
                    filament_to_object_id.first  = iter->first;
                    filament_to_object_id.second = object_label_id;
                    m_result.gcode_check_result.print_area_error_infos[extruder_id].push_back(filament_to_object_id);
                    valid = false;
                }
            }
            // Belt printers: the Z recorded here grows with belt travel (machine Z with the
            // frame transform, the slicing-frame Z without it), while printable_height is the
            // clearance above the belt; the two are not comparable, so the over-height check
            // is skipped, as the preview's ToolHeightOutside warning already is.
            // Print::validate() checks the object's height against the clearance.
            if ( !m_belt_printer && iter->second.max_print_z > plate_printable_height ) { //over height
                m_result.gcode_check_result.error_code |= (1 << 3);
                std::pair<int, int> filament_to_object_id;
                filament_to_object_id.first  = iter->first;
                filament_to_object_id.second = object_label_id;
                m_result.gcode_check_result.print_height_error_infos[extruder_id].push_back(filament_to_object_id);
                valid = false;
            }
            // if (wrapping_exclude_poly.is_valid()) {
            //     if (wrapping_exclude_poly.bounding_box().overlap(bbox)) { // get into the wrapping area
            //         m_result.gcode_check_result.error_code |= (1 << 4);
            //         std::pair<int, int> filament_to_object_id;
            //         filament_to_object_id.first  = iter->first;
            //         filament_to_object_id.second = object_label_id;
            //         m_result.gcode_check_result.print_area_error_infos[extruder_id].push_back(filament_to_object_id);
            //         valid = false;
            //     }
            // }
 
            if (extruder_size > 1) {// in multi extruder condition
                /*//iter_points.insert(iter_points.end(), iter->second.pos_custom.begin(), iter->second.pos_custom.end()); // put custom extrude position in
                //Polygon     path_poly_custom(iter_points);
                //BoundingBox bbox_custom = path_poly_custom.bounding_box();
                //bbox_custom.offset(-scale_(1.0)); // Narrow the range to provide a tolerance for the custom gcode
                //bbox.merge(bbox_custom);          // merge the custom gcode pos with other pos*/
                // check printable area
                // Simplified use bounding_box, Accurate calculation is not efficient
                if ((extruder_id < unprintable_areas.size()) && !unprintable_areas[extruder_id].empty())
                    for (Polygon poly : unprintable_areas[extruder_id]) {
                        poly.translate(plate_offset);
                        if (poly.bounding_box().overlap(bbox)) {
                            m_result.gcode_check_result.error_code |= 1;
                            std::pair<int, int>         filament_to_object_id;
                            filament_to_object_id.first = iter->first;
                            filament_to_object_id.second = object_label_id;
                            m_result.gcode_check_result.print_area_error_infos[extruder_id].push_back(filament_to_object_id);
                            valid = false;
                        }
                    }
 
                // check printable height
                if (!m_belt_printer && (extruder_id < printable_heights.size()) && (iter->second.max_print_z > printable_heights[extruder_id])) {
                    m_result.gcode_check_result.error_code |= (1 << 1);
                    std::pair<int, int> filament_to_object_id;
                    filament_to_object_id.first  = iter->first;
                    filament_to_object_id.second = object_label_id;
                    m_result.gcode_check_result.print_height_error_infos[extruder_id].push_back(filament_to_object_id);
                    m_result.limit_filament_maps[iter->first] |= (1 << extruder_id);
                    valid = false;
                }
 
                for (int i = 0; i < unprintable_areas.size(); ++i) {
                    for (Polygon poly : unprintable_areas[i]) {
                        poly.translate(plate_offset);
                        if (!poly.bounding_box().overlap(bbox)) continue;
 
                        m_result.limit_filament_maps[iter->first] |= (1 << i);
                    }
                }
            }
        }
    }
 
    // apply unprintable filament type result
    for (int extruder_id = 0; extruder_id < unprintable_filament_types.size(); ++extruder_id) {
        const std::set<int> &filament_ids = unprintable_filament_types[extruder_id];
        for (int filament_id : filament_ids) {
            m_result.limit_filament_maps[filament_id] |= (1 << extruder_id);
        }
    };
 
    return valid;
}

References Slic3r::MultiPoint::bounding_box(), Slic3r::BoundingBoxBase< PointType, APointsType >::contains(), Slic3r::BoundingBoxBase< PointType, APointsType >::defined, Slic3r::MultiPoint::empty(), Slic3r::erCustom, Slic3r::Extrude, Slic3r::GCodeProcessorResult::MoveVertex::extruder_id, Slic3r::GCodeProcessorResult::MoveVertex::extrusion_role, Slic3r::filament_ids(), Slic3r::filament_map(), Slic3r::Polygon::is_valid(), m_belt_printer, m_extruder_offsets, m_machine_frame_transform, m_result, m_x_offset, m_y_offset, m_z_offset, Slic3r::Polygon::new_scale(), Slic3r::GCodeProcessorResult::MoveVertex::object_label_id, Slic3r::BoundingBoxBase< PointType, APointsType >::offset(), Slic3r::GCodeProcessorResult::MoveVertex::print_z, scale_, Slic3r::to_2d(), Slic3r::MultiPoint::translate(), and Slic3r::GCodeProcessorResult::MoveVertex::type.

Here is the call graph for this function:

configure_exclusion_volume_path_check()

void Slic3r::GCodeProcessor::configure_exclusion_volume_path_check

(

const PrintConfig &

config

)

{
    m_exclusion_volume_path_checker.configure(config);
}

References m_exclusion_volume_path_checker.

Referenced by Slic3r::Print::export_gcode_from_previous_file(), and Slic3r::DoExport::init_gcode_processor().

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;
    auto& _tags = s_IsBBLPrinter ? Reserved_Tags : Reserved_Tags_compatible;
    parser.parse_buffer(gcode, [&ret, &found_tag, _tags](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 : _tags) {
                if (boost::starts_with(comment, s)) {
                    ret = true;
                    found_tag = comment;
                    parser.quit_parsing();
                    return;
                }
            }
        }
        });
 
    return ret;
}

References Slic3r::GCodeReader::parse_buffer(), Slic3r::GCodeReader::quit_parsing(), Slic3r::GCodeReader::GCodeLine::raw(), Reserved_Tags, Reserved_Tags_compatible, and s_IsBBLPrinter.

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, bool is_bbl_printer )

static

{
    max_count = std::max(max_count, 1U);
 
    bool ret = false;
 
    CNumericLocalesSetter locales_setter;
 
    GCodeReader parser;
    auto& _tags = is_bbl_printer ? Reserved_Tags : Reserved_Tags_compatible;
    parser.parse_buffer(gcode, [&ret, &found_tag, max_count, _tags](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 : _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 Slic3r::GCodeReader::parse_buffer(), Slic3r::GCodeReader::quit_parsing(), Slic3r::GCodeReader::GCodeLine::raw(), Reserved_Tags, and Reserved_Tags_compatible.

Referenced by Slic3r::DoExport::validate_custom_gcode(), and Slic3r::GUI::Tab::validate_custom_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

detect_layer_based_on_tag()

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

inline

{ m_detect_layer_based_on_tag = enabled; }

References m_detect_layer_based_on_tag.

detect_producer()

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

private

{
    for (const auto& [id, search_string] : Producers) {
        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 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

{ m_time_processor.machine_envelope_processing_enabled = enabled; }

References m_time_processor.

ensure_nozzle_group_result()

void Slic3r::GCodeProcessor::ensure_nozzle_group_result

(

int

min_filament_count

)

{
    if (m_nozzle_group_result) {
        // A grouping was already seeded from the reloaded result (initialize_from_context). Publish it
        // onto m_result so extract_result() carries it. (The reference relies on the streaming-export
        // handover for this and returns early here; the reprocess path has no such handover.)
        m_result.nozzle_group_result = m_nozzle_group_result;
        return;
    }
 
    int filament_count = std::max(1, min_filament_count);
    filament_count = std::max(filament_count, static_cast<int>(m_filament_maps.size()));
 
    std::vector<int> filament_map = m_filament_maps;
    if (filament_map.empty()) {
        filament_map.assign(filament_count, 0);
    } else if (static_cast<int>(filament_map.size()) < filament_count) {
        filament_map.resize(filament_count, filament_map.front());
    }
 
    int min_value = *std::min_element(filament_map.begin(), filament_map.end());
    if (min_value >= 1) {
        for (int &value : filament_map) {
            value -= 1;
        }
    }
 
    for (int &value : filament_map) {
        value = std::max(0, value);
    }
 
    int max_extruder_id = *std::max_element(filament_map.begin(), filament_map.end());
    max_extruder_id = std::max(0, max_extruder_id);
 
    std::string nozzle_diameter = format_diameter_to_str(DEFAULT_TOOLPATH_WIDTH);
    std::vector<MultiNozzleUtils::NozzleInfo> nozzle_list;
    nozzle_list.reserve(static_cast<size_t>(max_extruder_id + 1));
    for (int extruder_id = 0; extruder_id <= max_extruder_id; ++extruder_id) {
        MultiNozzleUtils::NozzleInfo info;
        info.diameter    = nozzle_diameter;
        info.volume_type = NozzleVolumeType::nvtStandard;
        info.extruder_id = extruder_id;
        info.group_id    = extruder_id;
        nozzle_list.emplace_back(std::move(info));
    }
 
    std::vector<int> filament_nozzle_map(filament_count, 0);
    for (int i = 0; i < filament_count; ++i) {
        filament_nozzle_map[i] = filament_map[i];
    }
 
    std::vector<unsigned int> used_filaments;
    used_filaments.reserve(filament_count);
    for (int i = 0; i < filament_count; ++i) {
        used_filaments.push_back(static_cast<unsigned int>(i));
    }
 
    auto result = MultiNozzleUtils::LayeredNozzleGroupResult::create(filament_nozzle_map, nozzle_list, used_filaments);
    if (result) {
        m_nozzle_group_result        = std::make_shared<MultiNozzleUtils::LayeredNozzleGroupResult>(*result);
        m_result.nozzle_group_result = m_nozzle_group_result;
    }
}

References Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::create(), DEFAULT_TOOLPATH_WIDTH, Slic3r::MultiNozzleUtils::NozzleInfo::diameter, Slic3r::MultiNozzleUtils::NozzleInfo::extruder_id, Slic3r::filament_map(), Slic3r::filament_nozzle_map(), Slic3r::format_diameter_to_str(), Slic3r::MultiNozzleUtils::NozzleInfo::group_id, m_filament_maps, m_nozzle_group_result, m_result, Slic3r::nozzle_diameter(), Slic3r::nvtStandard, result(), and Slic3r::MultiNozzleUtils::NozzleInfo::volume_type.

Referenced by apply_config().

Here is the call graph for this function:

Here is the caller graph for this function:

export_config_for_render()

DynamicConfig Slic3r::GCodeProcessor::export_config_for_render

(

)

const

{
    DynamicConfig config;
    config.set_key_value("filament_colour", new ConfigOptionStrings(m_parser.get_config().filament_colour.values));
    config.set_key_value("filament_is_support", new ConfigOptionBools(m_parser.get_config().filament_is_support.values));
    config.set_key_value("filament_type", new ConfigOptionStrings(m_parser.get_config().filament_type.values));
    config.set_key_value("filament_map", new ConfigOptionInts(m_parser.get_config().filament_map.values));
    // The tool position readout shows coordinates with the precision the file was exported with.
    config.set_key_value("high_precision_gcode", new ConfigOptionBool(m_parser.get_config().high_precision_gcode.value));
    // += clones the options; apply() would need a definition this config does not have.
    config += m_belt_render_config;
    return config;
}

References m_belt_render_config, m_parser, and Slic3r::DynamicConfig::set_key_value().

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

Here is the call graph for this function:

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.precise_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, Slic3r::GCodeReader::GCodeLine::precise_value(), and Relative.

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

{ return std::move(m_result); }

References m_result.

Referenced by Slic3r::Print::export_gcode_from_previous_file(), and Slic3r::GUI::Plater::load_gcode().

Here is the caller graph for this function:

finalize()

void Slic3r::GCodeProcessor::finalize

(

bool

post_process

)

{
    m_result.z_offset = m_z_offset;
    finalize_object_masses();
 
    // 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;
        }
    }
 
    // Orca: final pass -- also drains any filament-change delay still buffered because
    // calculate_time early-returns with fewer than two queued blocks (see calculate_time).
    calculate_time(m_result, 0, 0.0f, EMoveType::Noop, /*is_final=*/true);
 
    // 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;
        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();
 
    m_result.initial_layer_time = get_first_layer_time(PrintEstimatedStatistics::ETimeMode::Normal);
 
    if (post_process){
        run_post_process();
        // Additive pre-heat/pre-cool injection second pass. Gated on m_enable_pre_heating so the
        // byte-frozen fleet (X1/P1/A1/H2S) never enters it. When the injector produces no lines the
        // InsertedLinesMap is empty, so this is a byte-for-byte identity rewrite; it exercises the
        // merge/offset machinery on the multi-nozzle fleet (H2D/X2D/H2D-Pro/H2C).
        if (m_enable_pre_heating)
            run_second_pass_injection();
    }
    update_exclusion_volume_path_check_result();
    //BBS: update slice warning
    update_slice_warnings();
}

References Slic3r::GCodeProcessor::TimeMachine::CustomGCodeTime::cache, calculate_time(), Slic3r::CustomGCode::ColorChange, Slic3r::PrintEstimatedStatistics::Count, finalize_object_masses(), Slic3r::GCodeProcessor::TimeMachine::gcode_time, get_first_layer_time(), Slic3r::GCodeProcessorResult::MoveVertex::height, m_enable_pre_heating, m_result, m_time_processor, m_used_filaments, m_z_offset, Slic3r::GCodeProcessor::TimeMachine::CustomGCodeTime::needed, Slic3r::Noop, Slic3r::PrintEstimatedStatistics::Normal, Slic3r::post_process(), run_post_process(), run_second_pass_injection(), Slic3r::GCodeProcessor::TimeMachine::CustomGCodeTime::times, Slic3r::GCodeProcessorResult::MoveVertex::type, update_estimated_times_stats(), update_exclusion_volume_path_check_result(), update_slice_warnings(), Slic3r::GCodeProcessorResult::MoveVertex::width, Slic3r::Wipe, Wipe_Height, and Wipe_Width.

Referenced by process_file().

Here is the call graph for this function:

Here is the caller graph for this function:

finalize_object_masses()

void Slic3r::GCodeProcessor::finalize_object_masses ( )

private

{
    const auto accumulate = [](GCodeProcessorResult::ObjectMass &object) {
        for (size_t i = 1; i < object.printed_up_to_layer.size(); ++i)
            object.printed_up_to_layer[i].add(object.printed_up_to_layer[i - 1]);
    };
    accumulate(m_result.plate_mass);
    for (GCodeProcessorResult::ObjectMass &object : m_result.object_masses)
        accumulate(object);
    for (GCodeProcessorResult::ObjectMass &body : m_result.body_masses)
        accumulate(body);
    for (GCodeProcessorResult::ObjectMass &support : m_result.support_masses)
        accumulate(support);
}

References m_result.

Referenced by finalize().

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, Slic3r::GCodeProcessorResult::id, and m_time_processor.

Referenced by get_axis_max_jerk_with_jd(), get_axis_max_jerk_with_jd(), process_G1(), process_VG1(), and store_move_vertex().

Here is the caller graph for this function:

get_axis_max_acceleration() [1/2]

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

private

{
    return get_axis_max_acceleration(mode, axis, 0);
}

References get_axis_max_acceleration().

Referenced by calc_junction_acceleration(), get_axis_max_acceleration(), get_axis_max_jerk_with_jd(), process_G1(), and process_VG1().

Here is the call graph for this function:

Here is the caller graph for this function:

get_axis_max_acceleration() [2/2]

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

private

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

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

Here is the call graph for this function:

get_axis_max_feedrate() [1/2]

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

private

{
    return get_axis_max_feedrate(mode, axis, 0);
}

References get_axis_max_feedrate().

Referenced by get_axis_max_feedrate(), process_G1(), and process_VG1().

Here is the call graph for this function:

Here is the caller graph for this function:

get_axis_max_feedrate() [2/2]

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

private

{
    const size_t pos = static_cast<size_t>(machine_idx) * 2 + static_cast<size_t>(mode);
    switch (axis)
    {
    case X: { return get_option_value(m_time_processor.machine_limits.machine_max_speed_x, pos); }
    case Y: { return get_option_value(m_time_processor.machine_limits.machine_max_speed_y, pos); }
    case Z: { return get_option_value(m_time_processor.machine_limits.machine_max_speed_z, pos); }
    case E: { return get_option_value(m_time_processor.machine_limits.machine_max_speed_e, pos); }
    default: { return 0.0f; }
    }
}

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

Here is the call graph for this function:

get_axis_max_jerk()

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

private

{
    const size_t id = static_cast<size_t>(mode);
    const float jd = get_option_value(m_time_processor.machine_limits.machine_max_junction_deviation, id);
    if (m_flavor == gcfMarlinFirmware && jd > 0.0f) {
        return get_axis_max_jerk_with_jd(mode, axis);
    }
 
    switch (axis)
    {
    case X: { return get_option_value(m_time_processor.machine_limits.machine_max_jerk_x, id); }
    case Y: { return get_option_value(m_time_processor.machine_limits.machine_max_jerk_y, id); }
    case Z: { return get_option_value(m_time_processor.machine_limits.machine_max_jerk_z, id); }
    case E: { return get_option_value(m_time_processor.machine_limits.machine_max_jerk_e, id); }
    default: { return 0.0f; }
    }
}

References Slic3r::E, Slic3r::gcfMarlinFirmware, get_axis_max_jerk_with_jd(), Slic3r::get_option_value(), m_flavor, m_time_processor, Slic3r::X, Slic3r::Y, and Slic3r::Z.

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_axis_max_jerk_with_jd() [1/2]

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

private

{
    return get_axis_max_jerk_with_jd(mode, axis, get_acceleration(mode));
}

References get_acceleration(), and get_axis_max_jerk_with_jd().

Here is the call graph for this function:

get_axis_max_jerk_with_jd() [2/2]

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

private

{
    if (axis != X && axis != Y && axis != Z && axis != E)
        return 0.0f;
 
    const size_t id = static_cast<size_t>(mode);
    const float jd = get_option_value(m_time_processor.machine_limits.machine_max_junction_deviation, id);
    if (jd <= 0.0f)
        return 0.0f;
 
    const float axis_max_acc = get_axis_max_acceleration(mode, axis);
    float effective_acc = acceleration;
    if (effective_acc <= 0.0f)
        effective_acc = get_acceleration(mode);
    if (axis_max_acc > 0.0f)
        effective_acc = effective_acc > 0.0f ? std::min(effective_acc, axis_max_acc) : axis_max_acc;
    if (effective_acc <= 0.0f)
        return 0.0f;
 
    return std::sqrt(jd * effective_acc * 2.5f);
}

References Slic3r::E, get_acceleration(), get_axis_max_acceleration(), Slic3r::get_option_value(), m_time_processor, Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by get_axis_max_jerk(), get_axis_max_jerk_with_jd(), get_xyz_max_jerk(), and store_move_vertex().

Here is the call graph for this function:

Here is the caller graph for this function:

get_current_position()

GCodeProcessor::PositionState Slic3r::GCodeProcessor::get_current_position

(

)

const

{
    PositionState state;
    state.position = Vec3d(m_end_position[X], m_end_position[Y], m_end_position[Z]);
    state.axis_known = m_axis_position_known;
    return state;
}

References Slic3r::GCodeProcessor::PositionState::axis_known, m_axis_position_known, m_end_position, Slic3r::GCodeProcessor::PositionState::position, Slic3r::X, Slic3r::Y, and Slic3r::Z.

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::TimeMachine::time, and Slic3r::GCodeProcessor::TimeMachine::CustomGCodeTime::times.

Referenced by update_estimated_times_stats().

Here is the caller graph for this function:

get_extruder_change_time()

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

private

{
    //TODO: all extruder has the same value ?
    return m_time_processor.machine_tool_change_time;
}

References m_time_processor.

Referenced by process_filament_change(), and process_filament_change().

Here is the caller graph for this function:

get_extruder_id()

int Slic3r::GCodeProcessor::get_extruder_id ( bool force_initialize = true ) const

private

{
    if (m_extruder_id == (unsigned char)(-1))
        return force_initialize ? 0 : -1;
    return static_cast<int>(m_extruder_id);
}

References m_extruder_id.

Referenced by get_filament_id(), get_last_filament_id(), get_machine_config_idx(), process_filament_change(), process_filament_change(), process_filaments(), process_G1(), process_M1020(), process_T(), and process_VG1().

Here is the caller graph for this function:

get_filament_id()

int Slic3r::GCodeProcessor::get_filament_id ( bool force_initialize = true ) const

private

{
    int extruder_id = get_extruder_id(force_initialize);
    if (extruder_id == -1)
        return force_initialize ? 0 : -1;
 
    if (m_filament_id[extruder_id] == (unsigned char)(-1))
        return force_initialize ? 0 : -1;
 
    return static_cast<int>(m_filament_id[extruder_id]);
}

References get_extruder_id(), and m_filament_id.

Referenced by process_elegoo_M6211(), process_filament_change(), process_filament_change(), process_G1(), process_G2_G3(), process_M1020(), process_M104(), process_M109(), process_M702(), Slic3r::GCodeProcessor::UsedFilaments::process_model_cache(), Slic3r::GCodeProcessor::UsedFilaments::process_role_cache(), Slic3r::GCodeProcessor::UsedFilaments::process_support_cache(), process_T(), process_tags(), Slic3r::GCodeProcessor::UsedFilaments::process_total_volume_cache(), process_VG1(), Slic3r::GCodeProcessor::UsedFilaments::process_wipe_tower_cache(), and store_move_vertex().

Here is the call graph for this function:

Here is the caller graph for this function:

get_filament_load_time()

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

private

{
    //BBS: change load time to machine config and all extruder has same value
    return m_time_processor.extruder_unloaded ? 0.0f : m_time_processor.filament_load_times;
}

References m_time_processor.

Referenced by process_filament_change(), and process_filament_change().

Here is the caller graph for this function:

get_filament_unload_time()

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

private

{
    //BBS: change unload time to machine config and all extruder has same value
    return m_time_processor.extruder_unloaded ? 0.0f : m_time_processor.filament_unload_times;
}

References m_time_processor.

Referenced by process_filament_change(), process_filament_change(), and process_M702().

Here is the caller graph for this function:

get_filament_vitrification_temperature()

int Slic3r::GCodeProcessor::get_filament_vitrification_temperature ( size_t extrude_id )

private

{
    if (extrude_id < m_result.filament_vitrification_temperature.size())
        return m_result.filament_vitrification_temperature[extrude_id];
    else
        return 0;
}

References m_result.

Referenced by update_slice_warnings().

Here is the caller graph for this function:

get_first_layer_time()

float Slic3r::GCodeProcessor::get_first_layer_time

(

PrintEstimatedStatistics::ETimeMode

mode

)

const

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

References Slic3r::PrintEstimatedStatistics::Count, and m_time_processor.

Referenced by finalize().

Here is the caller graph for this function:

get_gcode_last_filament()

int Slic3r::GCodeProcessor::get_gcode_last_filament ( const std::string & gcode_str )

static

{
    int str_size = gcode_str.size();
    int start_index = 0;
    int end_index = 0;
    int out_filament = -1;
    while (end_index < str_size) {
        if (gcode_str[end_index] != '\n') {
            end_index++;
            continue;
        }
 
        if (end_index > start_index) {
            std::string line_str = gcode_str.substr(start_index, end_index - start_index);
            line_str.erase(0, line_str.find_first_not_of(" "));
            line_str.erase(line_str.find_last_not_of(" ") + 1);
            if (line_str.empty() || line_str[0] != 'T') {
                start_index = end_index + 1;
                end_index = start_index;
                continue;
            }
 
            int out = -1;
            if (parse_number(line_str.substr(1), out) && out >= 0 && out < 255)
                out_filament = out;
        }
 
        start_index = end_index + 1;
        end_index = start_index;
    }
 
    return out_filament;
}

References Slic3r::parse_number().

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_junction_deviation()

float Slic3r::GCodeProcessor::get_junction_deviation ( PrintEstimatedStatistics::ETimeMode mode, float acceleration ) const

private

{
    const size_t id = static_cast<size_t>(mode);
 
    // Klipper derives junction deviation from the live toolhead acceleration,
    // before a move is constrained by Z or extruder limits.
    if (m_flavor == gcfKlipper) {
        // machine_max_jerk_x holds the square corner velocity; process_SET_VELOCITY_LIMIT() writes it.
        const float scv = get_option_value(m_time_processor.machine_limits.machine_max_jerk_x, id);
        acceleration = m_time_processor.machines[id].acceleration;
        if (scv <= 0.0f || acceleration <= 0.0f)
            return 0.0f;
        return sqr(scv) * (std::sqrt(2.0f) - 1.0f) / acceleration;
    }
 
    // Marlin 2 plans with junction deviation only when M205 J > 0; classic jerk leaves it at 0.
    if (m_flavor == gcfMarlinFirmware)
        return get_option_value(m_time_processor.machine_limits.machine_max_junction_deviation, id);
 
    return 0.0f;
}

References Slic3r::gcfKlipper, Slic3r::gcfMarlinFirmware, Slic3r::get_option_value(), Slic3r::GCodeProcessorResult::id, m_flavor, m_time_processor, and Slic3r::sqr().

Referenced by calc_vmax_junction_deviation(), and process_G1().

Here is the call graph for this function:

Here is the caller graph for this function:

get_last_filament_id()

int Slic3r::GCodeProcessor::get_last_filament_id ( bool force_initialize = true ) const

private

{
    int extruder_id = get_extruder_id(force_initialize);
    if (extruder_id == -1)
        return force_initialize ? 0 : -1;
 
    if (m_last_filament_id[extruder_id] == (unsigned char)(-1))
        return force_initialize ? 0 : -1;
 
    return static_cast<int>(m_last_filament_id[extruder_id]);
}

References get_extruder_id(), and m_last_filament_id.

Referenced by process_G1(), and process_VG1().

Here is the call graph for this function:

Here is the caller graph for this function:

get_last_position_from_gcode()

bool Slic3r::GCodeProcessor::get_last_position_from_gcode ( const std::string & gcode_str, Vec3f & pos )

static

{
    int  str_size     = gcode_str.size();
    int  start_index  = 0;
    int  end_index    = 0;
    bool is_z_changed = false;
    while (end_index < str_size) {
        // find a full line
        if (gcode_str[end_index] != '\n') {
            end_index++;
            continue;
        }
        // parse the line
        if (end_index > start_index) {
            std::string line_str = gcode_str.substr(start_index, end_index - start_index);
            line_str.erase(0, line_str.find_first_not_of(" "));
            line_str.erase(line_str.find_last_not_of(";") + 1);
            line_str.erase(line_str.find_last_not_of(" ") + 1);
 
            // command which may have z movement
            if (line_str.size() > 5 && (line_str.find("G0 ") == 0 || line_str.find("G1 ") == 0 || line_str.find("G2 ") == 0 || line_str.find("G3 ") == 0)) {
                {
                    float &x      = pos.x();
                    auto   z_pos  = line_str.find(" X");
                    float  temp_z = 0;
                    if (z_pos != line_str.npos && z_pos + 2 < line_str.size()) {
                        // Try to parse the numeric value.
                        std::string z_sub = line_str.substr(z_pos + 2);
                        char       *c     = &z_sub[0];
                        char       *end   = c + sizeof(z_sub.c_str());
 
                        auto is_end_of_word = [](char c) { return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == 0 || c == ';'; };
 
                        auto [pend, ec] = fast_float::from_chars(c, end, temp_z);
                        if (pend != c && is_end_of_word(*pend)) {
                            // The axis value has been parsed correctly.
                            x            = temp_z;
                            is_z_changed = true;
                        }
                    }
                }
 
                {
                    float &y      = pos.y();
                    auto   z_pos  = line_str.find(" Y");
                    float  temp_z = 0;
                    if (z_pos != line_str.npos && z_pos + 2 < line_str.size()) {
                        // Try to parse the numeric value.
                        std::string z_sub = line_str.substr(z_pos + 2);
                        char       *c     = &z_sub[0];
                        char       *end   = c + sizeof(z_sub.c_str());
 
                        auto is_end_of_word = [](char c) { return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == 0 || c == ';'; };
 
                        auto [pend, ec] = fast_float::from_chars(c, end, temp_z);
                        if (pend != c && is_end_of_word(*pend)) {
                            // The axis value has been parsed correctly.
                            y            = temp_z;
                            is_z_changed = true;
                        }
                    }
                }
 
                {
                    float &z      = pos.z();
                    auto   z_pos  = line_str.find(" Z");
                    float  temp_z = 0;
                    if (z_pos != line_str.npos && z_pos + 2 < line_str.size()) {
                        // Try to parse the numeric value.
                        std::string z_sub = line_str.substr(z_pos + 2);
                        char       *c     = &z_sub[0];
                        char       *end   = c + sizeof(z_sub.c_str());
 
                        auto is_end_of_word = [](char c) { return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == 0 || c == ';'; };
 
                        auto [pend, ec] = fast_float::from_chars(c, end, temp_z);
                        if (pend != c && is_end_of_word(*pend)) {
                            // The axis value has been parsed correctly.
                            z            = temp_z;
                            is_z_changed = true;
                        }
                    }
                }
            }
        }
        // loop to handle next line
        start_index = end_index + 1;
        end_index   = start_index;
    }
    return is_z_changed;
}

References Slic3r::is_end_of_word().

Referenced by Slic3r::WipeTowerIntegration::append_tcr(), and Slic3r::WipeTowerIntegration::append_tcr2().

Here is the call graph for this function:

Here is the caller graph for this function:

get_last_z_from_gcode()

bool Slic3r::GCodeProcessor::get_last_z_from_gcode ( const std::string & gcode_str, double & z )

static

{
    int str_size = gcode_str.size();
    int start_index = 0;
    int end_index = 0;
    bool is_z_changed = false;
    while (end_index < str_size) {
        //find a full line
        if (gcode_str[end_index] != '\n') {
            end_index++;
            continue;
        }
        //parse the line
        if (end_index > start_index) {
            std::string line_str = gcode_str.substr(start_index, end_index - start_index);
            line_str.erase(0, line_str.find_first_not_of(" "));
            line_str.erase(line_str.find_last_not_of(";") + 1);
            line_str.erase(line_str.find_last_not_of(" ") + 1);
 
            //command which may have z movement
            if (line_str.size() > 4 && (line_str.find("G0 ") == 0
                                       || line_str.find("G1 ") == 0
                                       || line_str.find("G2 ") == 0
                                       || line_str.find("G3 ") == 0))
            {
                auto z_pos = line_str.find(" Z");
                double temp_z = 0;
                if (z_pos != line_str.npos
                    && z_pos + 2 < line_str.size()) {
                    // Try to parse the numeric value.
                    std::string z_sub = line_str.substr(z_pos + 2);
                    char* c = &z_sub[0];
                    char* end = c + sizeof(z_sub.c_str());
 
                    auto is_end_of_word = [](char c) {
                        return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == 0 || c == ';';
                    };
 
                    auto [pend, ec] = fast_float::from_chars(c, end, temp_z);
                    if (pend != c && is_end_of_word(*pend)) {
                        // The axis value has been parsed correctly.
                        z = temp_z;
                        is_z_changed = true;
                    }
                }
            }
        }
        //loop to handle next line
        start_index = end_index + 1;
        end_index = start_index;
    }
    return is_z_changed;
}

References Slic3r::is_end_of_word().

Referenced by Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::GCode::generate_timelapse_gcode(), and Slic3r::GCode::set_extruder().

Here is the call graph for this function:

Here is the caller graph for this function:

get_machine_config_idx()

int Slic3r::GCodeProcessor::get_machine_config_idx ( ) const

private

{
    const int extruder_id = get_extruder_id(false);
    if (!m_nozzle_group_result || extruder_id < 0)
        return 0;
    const int nozzle_id = m_nozzle_status_recorder.get_nozzle_in_extruder(extruder_id);
    auto nozzle_info = m_nozzle_group_result->get_nozzle_from_id(nozzle_id);
    // Orca: bounds guard — a stale grouping context after a printer swap must not index OOB.
    if (!nozzle_info || extruder_id >= (int) m_result.extruder_types.size())
        return 0;
    return std::max(0, get_config_index_base(nozzle_info->volume_type, m_result.extruder_types[extruder_id],
                                             extruder_id + 1, m_result.printer_extruder_variant,
                                             m_result.printer_extruder_id));
}

References Slic3r::get_config_index_base(), get_extruder_id(), m_nozzle_group_result, m_nozzle_status_recorder, and m_result.

Referenced by process_filament_change(), and process_filament_change().

Here is the call graph for this function:

Here is the caller graph for this function:

get_prepare_time()

float Slic3r::GCodeProcessor::get_prepare_time

(

PrintEstimatedStatistics::ETimeMode

mode

)

const

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

References Slic3r::PrintEstimatedStatistics::Count, and m_time_processor.

Referenced by update_estimated_times_stats().

Here is the caller graph for this function:

get_result()

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

inline

{ 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, Slic3r::GCodeProcessorResult::id, and m_time_processor.

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

Here is the caller graph for this function:

get_time()

double Slic3r::GCodeProcessor::get_time

(

PrintEstimatedStatistics::ETimeMode

mode

)

const

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

References Slic3r::PrintEstimatedStatistics::Count, and m_time_processor.

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(float(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, and Slic3r::short_time().

Referenced by run_post_process().

Here is the call graph for this function:

Here is the caller 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, Slic3r::GCodeProcessorResult::id, and m_time_processor.

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

Here is the caller graph for this function:

get_xyz_max_jerk()

Vec3f Slic3r::GCodeProcessor::get_xyz_max_jerk ( PrintEstimatedStatistics::ETimeMode mode ) const

private

{
    // Default values from config
    const size_t id = static_cast<size_t>(mode);
    float jx = 0.0f;
    float jy = 0.0f;
    float jz = 0.0f;
    const float jd = get_option_value(m_time_processor.machine_limits.machine_max_junction_deviation, id);
 
    // Classic Jerk: Junction Deviation is only supported by Marlin firmware when using a JD value grater than 0.
    if (m_flavor != gcfMarlinFirmware || jd <= 0.0f)
    {
        jx = get_option_value(m_time_processor.machine_limits.machine_max_jerk_x, id);
        jy = get_option_value(m_time_processor.machine_limits.machine_max_jerk_y, id);
        jz = get_option_value(m_time_processor.machine_limits.machine_max_jerk_z, id);
    }
    else
    {
        jx = get_axis_max_jerk_with_jd(mode, X);
        jy = get_axis_max_jerk_with_jd(mode, Y);
        jz = get_axis_max_jerk_with_jd(mode, Z);
    }
 
    return Vec3f(jx, jy, jz);
}

References Slic3r::gcfMarlinFirmware, get_axis_max_jerk_with_jd(), Slic3r::get_option_value(), m_flavor, m_time_processor, Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by process_G1(), and process_VG1().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_offsets_of_second_process()

void Slic3r::GCodeProcessor::handle_offsets_of_second_process ( const TimeProcessor::InsertedLinesMap & inserted_operation_lines )

private

{
    int total_offset = 0;
    auto iter = inserted_operation_lines.begin();
    for (GCodeProcessorResult::MoveVertex& move : m_result.moves) {
        while (iter != inserted_operation_lines.end() && iter->first < move.gcode_id) {
            total_offset += static_cast<int>(iter->second.size());
            ++iter;
        }
        move.gcode_id += total_offset;
    }
}

References Slic3r::GCodeProcessorResult::MoveVertex::gcode_id, and m_result.

Referenced by run_second_pass_injection().

Here is the caller graph for this function:

init_filament_maps_and_nozzle_type_when_import_only_gcode()

void Slic3r::GCodeProcessor::init_filament_maps_and_nozzle_type_when_import_only_gcode

(

)

{
    if (m_filament_maps.empty()) {
        m_filament_maps.assign((int) EnforcerBlockerType::ExtruderMax, 1);
    }
    if (m_result.nozzle_type.empty()) {
        m_result.nozzle_type.assign((int) EnforcerBlockerType::ExtruderMax, NozzleType::ntUndefine);
    }
}

References Slic3r::ExtruderMax, m_filament_maps, m_result, and Slic3r::ntUndefine.

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

Here is the caller graph for this function:

initialize()

void Slic3r::GCodeProcessor::initialize

(

const std::string &

filename

)

{
    assert(is_decimal_separator_point());
 
    // process gcode
    m_result.filename = filename;
    m_result.id = ++s_result_id;
}

References Slic3r::is_decimal_separator_point(), m_result, and s_result_id.

Here is the call graph for this function:

initialize_from_context()

void Slic3r::GCodeProcessor::initialize_from_context ( const std::shared_ptr< MultiNozzleUtils::NozzleGroupResultBase > & nozzle_group_result )

inline

                                                                                                                      {
            m_nozzle_group_result = nozzle_group_result;
        }

References m_nozzle_group_result.

Referenced by Slic3r::Print::export_gcode_from_previous_file(), Slic3r::DoExport::init_gcode_processor(), and Slic3r::Print::reload_gcode_moves().

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.

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, and Slic3r::PrintEstimatedStatistics::Stealth.

Referenced by run_post_process(), and 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(), and m_time_processor.

Referenced by process_G1(), and process_VG1().

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(), and m_time_processor.

Referenced by process_G1(), and process_VG1().

Here is the call graph for this function:

Here is the caller graph for this function:

process_bambuslicer_tags()

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

private

{
    return false;
}

Referenced by process_producers_tags().

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, and process_gcode_line().

Here is the call 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(erSkirt);
        else if (type == "Perimeter")
            set_extrusion_role(erExternalPerimeter);
        else if (type == "HShell")
            set_extrusion_role(erNone); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        else if (type == "InnerHair")
            set_extrusion_role(erNone); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        else if (type == "Loop")
            set_extrusion_role(erNone); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        else if (type == "Infill")
            set_extrusion_role(erInternalInfill);
        else if (type == "Raft")
            set_extrusion_role(erSkirt);
        else if (type == "Support")
            set_extrusion_role(erSupportMaterial);
        else if (type == "SupportTouch")
            set_extrusion_role(erSupportMaterial);
        else if (type == "SoftSupport")
            set_extrusion_role(erSupportMaterialInterface);
        else if (type == "Pillar")
            set_extrusion_role(erWipeTower);
        else {
            set_extrusion_role(erNone);
            BOOST_LOG_TRIVIAL(warning) << "GCodeProcessor found unknown extrusion role: " << type;
        }
 
        if (m_extrusion_role == erExternalPerimeter)
            m_seams_detector.activate(true);
 
        return true;
    }
 
    // layer
    pos = comment.find(" Layer #");
    if (pos == 0) {
        ++m_layer_id;
        return true;
    }
 
    return false;
}

References Slic3r::erExternalPerimeter, Slic3r::erInternalInfill, Slic3r::erNone, Slic3r::erSkirt, Slic3r::erSupportMaterial, Slic3r::erSupportMaterialInterface, Slic3r::erWipeTower, m_extrusion_role, m_layer_id, m_seams_detector, and set_extrusion_role().

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(erSkirt);
        else if (type == "WALL-OUTER")
            set_extrusion_role(erExternalPerimeter);
        else if (type == "WALL-INNER")
            set_extrusion_role(erPerimeter);
        else if (type == "SKIN")
            set_extrusion_role(erSolidInfill);
        else if (type == "FILL")
            set_extrusion_role(erInternalInfill);
        else if (type == "SUPPORT")
            set_extrusion_role(erSupportMaterial);
        else if (type == "SUPPORT-INTERFACE")
            set_extrusion_role(erSupportMaterialInterface);
        else if (type == "PRIME-TOWER")
            set_extrusion_role(erWipeTower);
        else {
            set_extrusion_role(erNone);
            BOOST_LOG_TRIVIAL(warning) << "GCodeProcessor found unknown extrusion role: " << type;
        }
 
        if (m_extrusion_role == erExternalPerimeter)
            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::erExternalPerimeter, Slic3r::erInternalInfill, Slic3r::erNone, Slic3r::erPerimeter, Slic3r::erSkirt, Slic3r::erSolidInfill, Slic3r::erSupportMaterial, Slic3r::erSupportMaterialInterface, Slic3r::erWipeTower, Slic3r::gcfMach3, Slic3r::gcfMakerWare, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepetier, Slic3r::gcfRepRapFirmware, m_extrusion_role, m_flavor, m_layer_id, m_seams_detector, and set_extrusion_role().

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

{
    //FIXME this simulates st_synchronize! is it correct?
    // The estimated time may be longer than the real print time.
    simulate_st_synchronize();
    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;
        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::TimeMachine::CustomGCodeTime::needed, 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_elegoo_M6211()

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

private

{
    float length = 0.0f;
    if (!line.has_value('L', length) || length <= 0.0f)
        return;
 
    float t = -1.0f;
    if (!line.has_value('T', t) || t < 0.0f)
        return;
 
    const int filament_id = static_cast<int>(std::round(t));
    if (filament_id < 0 || filament_id >= m_result.filaments_count)
        return;
 
    const int extruder_id = m_filament_maps[filament_id];
 
    float new_extruder_temp = 0.0f;
    if (line.has_value('S', new_extruder_temp)) {
        if (extruder_id >= 0 && static_cast<size_t>(extruder_id) < m_extruder_temps.size())
            m_extruder_temps[static_cast<size_t>(extruder_id)] = new_extruder_temp;
    }
 
    const float m6211_time         = estimate_M6211_time(line, m_printer_model, length, new_extruder_temp,
                                                         m_start_position[X], m_start_position[Y]);
    const int   curr_filament_id   = get_filament_id(false);
    const bool  is_first_extrusion = (curr_filament_id == -1) || (filament_id == curr_filament_id);
 
    m_time_processor.filament_unload_times = 0;
    m_time_processor.filament_load_times = m6211_time;
    process_filament_change(filament_id);
 
    if (extruder_id >= 0 && static_cast<size_t>(extruder_id) < m_remaining_volume.size()) {
        const float remaining_volume = static_cast<size_t>(extruder_id) < m_nozzle_volume.size() ?
                                           m_nozzle_volume[extruder_id] :
                                           0.0f;
        const float filament_diameter = static_cast<size_t>(filament_id) < m_result.filament_diameters.size() ?
                                            m_result.filament_diameters[filament_id] :
                                            m_result.filament_diameters.back();
        const float area_filament_cross_section = static_cast<float>(M_PI) * sqr(0.5f * filament_diameter);
        const float volume_flushed_filament     = area_filament_cross_section * length;
 
        if (volume_flushed_filament >= remaining_volume) {
            if (!is_first_extrusion)
                m_used_filaments.update_flush_per_filament(curr_filament_id, remaining_volume);
 
            m_used_filaments.update_flush_per_filament(filament_id, volume_flushed_filament - remaining_volume);
            m_remaining_volume[extruder_id] = 0.0f;
        } else {
            m_used_filaments.update_flush_per_filament(filament_id, volume_flushed_filament);
            m_remaining_volume[extruder_id] -= volume_flushed_filament;
        }
    }
}

References get_filament_id(), Slic3r::GCodeReader::GCodeLine::has_value(), Slic3r::length(), m_extruder_temps, m_filament_maps, m_nozzle_volume, M_PI, m_printer_model, m_remaining_volume, m_result, m_start_position, m_time_processor, m_used_filaments, process_filament_change(), Slic3r::sqr(), Slic3r::X, and Slic3r::Y.

Referenced by process_M6211().

Here is the call graph for this function:

Here is the caller graph for this function:

process_filament_change() [1/2]

void Slic3r::GCodeProcessor::process_filament_change ( int id )

private

{
    assert(id < m_result.filaments_count);
    int prev_extruder_id = get_extruder_id(false);
    int prev_filament_id = get_filament_id(false);
    int next_extruder_id = m_filament_maps[id];
    int next_filament_id = id;
    float extra_time = 0;
    unsigned int filament_changes_delta = 0;
    unsigned int extruder_changes_delta = 0;
    float filament_load_time_delta = 0.0f;
    float filament_unload_time_delta = 0.0f;
    float tool_change_time_delta = 0.0f;
 
    if (prev_filament_id == next_filament_id)
        return;
 
    if (prev_extruder_id != -1)
        m_last_filament_id[prev_extruder_id] = prev_filament_id;
 
    if (prev_extruder_id == next_extruder_id) {
        // don't need extruder change
        assert(prev_extruder_id != -1);
        process_filaments(CustomGCode::ToolChange);
        m_filament_id[next_extruder_id] = next_filament_id;
        filament_changes_delta += 1;
        const float filament_unload_time = get_filament_unload_time(static_cast<size_t>(prev_filament_id));
        extra_time += filament_unload_time;
        filament_unload_time_delta += filament_unload_time;
        m_time_processor.extruder_unloaded = false;
        const float filament_load_time = get_filament_load_time(static_cast<size_t>(next_filament_id));
        extra_time += filament_load_time;
        filament_load_time_delta += filament_load_time;
    }
    else {
        if (prev_extruder_id == -1) {
            // initialize
            m_extruder_id = next_extruder_id;
            m_filament_id[next_extruder_id] = next_filament_id;
            m_time_processor.extruder_unloaded = false;
            const float filament_load_time = get_filament_load_time(static_cast<size_t>(next_filament_id));
            extra_time += filament_load_time;
            filament_load_time_delta += filament_load_time;
        }
        else {
            //first process cache generated by last extruder
            process_filaments(CustomGCode::ToolChange);
            //switch to current extruder
            m_extruder_id = next_extruder_id;
            if (m_last_filament_id[next_extruder_id] == (unsigned char)(-1)) {
                //no filament in current extruder
                m_filament_id[next_extruder_id] = next_filament_id;
                m_time_processor.extruder_unloaded = false;
                const float filament_load_time = get_filament_load_time(static_cast<size_t>(next_filament_id));
                extra_time += filament_load_time;
                filament_load_time_delta += filament_load_time;
            }
            else if (m_last_filament_id[next_extruder_id] != next_filament_id) {
                //need to change filament
                m_filament_id[next_extruder_id] = next_filament_id;
                filament_changes_delta += 1;
                const float filament_unload_time = get_filament_unload_time(static_cast<size_t>(prev_filament_id));
                extra_time += filament_unload_time;
                filament_unload_time_delta += filament_unload_time;
                m_time_processor.extruder_unloaded = false;
                const float filament_load_time = get_filament_load_time(static_cast<size_t>(next_filament_id));
                extra_time += filament_load_time;
                filament_load_time_delta += filament_load_time;
            }
            extruder_changes_delta += 1;
            const float tool_change_time = get_extruder_change_time(next_extruder_id);
            extra_time += tool_change_time;
            tool_change_time_delta += tool_change_time;
        }
    }
 
    if (filament_changes_delta > 0 || extruder_changes_delta > 0 || filament_load_time_delta > 0.0f || filament_unload_time_delta > 0.0f || tool_change_time_delta > 0.0f) {
        m_result.lock();
        m_result.print_statistics.total_filament_changes += filament_changes_delta;
        m_result.print_statistics.total_extruder_changes += extruder_changes_delta;
        m_result.print_statistics.total_filament_load_time += filament_load_time_delta;
        m_result.print_statistics.total_filament_unload_time += filament_unload_time_delta;
        m_result.print_statistics.total_tool_change_time += tool_change_time_delta;
        m_result.unlock();
    }
 
    m_cp_color.current = m_extruder_colors[next_filament_id];
 
    // Store the tool-change move first, then attribute the filament-change delay to
    // it rather than to whichever motion block happens to be pending. This keeps the
    // delay out of the per-role feature-time distribution (tool-change moves are not
    // counted as an extrusion role) while still including it in the total and
    // per-layer times.
    store_move_vertex(EMoveType::Tool_change);
 
    // Construct a zero-distance time block for the tool-change move on each enabled
    // machine so the synchronize below can land the delay on it. The synchronize
    // flushes with keep_last_n_blocks == 0; if fewer than two blocks are queued it
    // buffers the delay instead, and this block stays queued to receive it on a
    // later pass.
    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;
        TimeBlock block;
        block.move_id             = static_cast<unsigned int>(m_result.moves.size()) - 1;
        block.move_type           = EMoveType::Tool_change;
        // stamp the current SKIPPABLE type onto the tool-change block (the fleet-wide time_lapse_gcode
        // regions stamp stTimelapse); byte-inert because nothing reads the stamp until the injector
        // consumes it.
        block.skippable_type      = m_skippable_type;
        block.layer_id            = std::max<unsigned int>(1, m_layer_id);
        block.g1_line_id          = m_g1_line_id;
        block.flags.prepare_stage = m_processing_start_custom_gcode;
        block.distance            = 0.0f;
        block.calculate_trapezoid();
        machine.blocks.push_back(block);
    }
 
    simulate_st_synchronize(extra_time, EMoveType::Tool_change);
 
    m_machine_config_idx = get_machine_config_idx();
}

References Slic3r::GCodeProcessor::TimeMachine::blocks, Slic3r::GCodeProcessor::TimeBlock::calculate_trapezoid(), Slic3r::PrintEstimatedStatistics::Count, Slic3r::GCodeProcessor::TimeBlock::distance, Slic3r::GCodeProcessor::TimeMachine::enabled, Slic3r::GCodeProcessor::TimeBlock::flags, Slic3r::GCodeProcessor::TimeBlock::g1_line_id, get_extruder_change_time(), get_extruder_id(), get_filament_id(), get_filament_load_time(), get_filament_unload_time(), get_machine_config_idx(), Slic3r::GCodeProcessor::TimeBlock::layer_id, m_cp_color, m_extruder_colors, m_extruder_id, m_filament_id, m_filament_maps, m_g1_line_id, m_last_filament_id, m_layer_id, m_machine_config_idx, m_processing_start_custom_gcode, m_result, m_skippable_type, m_time_processor, Slic3r::GCodeProcessor::TimeBlock::move_id, Slic3r::GCodeProcessor::TimeBlock::move_type, Slic3r::GCodeProcessor::TimeBlock::Flags::prepare_stage, process_filaments(), simulate_st_synchronize(), Slic3r::GCodeProcessor::TimeBlock::skippable_type, store_move_vertex(), Slic3r::Tool_change, and Slic3r::CustomGCode::ToolChange.

Referenced by process_elegoo_M6211(), process_filament_change(), process_M1020(), and process_T().

Here is the call graph for this function:

Here is the caller graph for this function:

process_filament_change() [2/2]

void Slic3r::GCodeProcessor::process_filament_change ( int id, int nozzle_id )

private

{
    // Gate: outside the multi-nozzle context, or when the nozzle-grouping result is not available
    // (e.g. re-importing a bare g-code file), run the existing single-arg model byte-for-byte.
    if (!use_multi_nozzle_change_time_model() || !m_result.nozzle_group_result) {
        // Orca: occupancy bookkeeping is deliberately decoupled from the gated change-time model:
        // the per-slot machine-limit resolution needs the recorder during the streaming pass,
        // where the richer time model stays byte-frozen behind the result-field gate above.
        // Recorder writes have no time effect.
        if (m_nozzle_group_result) {
            if (auto info = resolve_target_nozzle(*m_nozzle_group_result, id, nozzle_id))
                m_nozzle_status_recorder.set_nozzle_status(info->group_id, id, info->extruder_id);
        }
        process_filament_change(id);
        return;
    }
 
    assert(id < m_result.filaments_count);
    const int prev_extruder_id = get_extruder_id(false);
    const int prev_filament_id = get_filament_id(false);
    float     extra_time       = 0.0f;
 
    // A same-filament re-select with no explicit nozzle target costs nothing.
    if (prev_filament_id == id && nozzle_id == -1)
        return;
 
    if (prev_extruder_id != -1)
        m_last_filament_id[prev_extruder_id] = static_cast<unsigned char>(prev_filament_id);
 
    // Resolve the destination nozzle: by explicit H<nozzle> id first, else the filament's first nozzle.
    std::optional<MultiNozzleUtils::NozzleInfo> target_nozzle_info = resolve_target_nozzle(*m_result.nozzle_group_result, id, nozzle_id);
    if (!target_nozzle_info)
        return;
 
    const int new_extruder_id          = target_nozzle_info->extruder_id;
    const int old_extruder_id          = prev_extruder_id;
    const int new_nozzle_id_in_extruder = target_nozzle_info->group_id;
    const int old_nozzle_id_in_extruder = m_nozzle_status_recorder.get_nozzle_in_extruder(new_extruder_id);
    const int new_filament_id          = id;
    const int old_filament_in_nozzle   = m_nozzle_status_recorder.get_filament_in_nozzle(new_nozzle_id_in_extruder);
    const int old_filament_in_extruder = m_nozzle_status_recorder.get_filament_in_nozzle(old_nozzle_id_in_extruder);
 
    const bool extruder_change          = new_extruder_id != old_extruder_id;
    const bool nozzle_in_extruder_change = new_nozzle_id_in_extruder != old_nozzle_id_in_extruder;
    const bool filament_in_nozzle_change = new_filament_id != old_filament_in_nozzle;
 
    // Orca: attribute the accumulated volume usage to the OLD extruder before switching state. Unlike
    // an unconditional call, the single-arg model (and every other Orca estimator path) skips this on
    // the very first tool-select (prev_extruder_id == -1) where there is no prior filament segment to
    // close out. Matching that keeps H2C's initial `T<fil> H<n>` byte-identical to its single-arg
    // baseline; every subsequent change closes out identically.
    if (prev_extruder_id != -1)
        process_filaments(CustomGCode::ToolChange);
 
    m_result.lock();
    if (extruder_change && old_extruder_id != -1) {
        const float t = get_extruder_change_time(new_extruder_id);
        extra_time += t;
        m_result.print_statistics.total_tool_change_time += t;   // Orca-only stat
        m_result.print_statistics.total_extruder_changes += 1;   // Orca-only stat
    }
    if (nozzle_in_extruder_change || filament_in_nozzle_change) {
        if (old_filament_in_extruder >= 0) {
            const float t = get_filament_unload_time(static_cast<size_t>(old_filament_in_extruder));
            extra_time += t;
            m_result.print_statistics.total_filament_unload_time += t; // Orca-only stat
        }
        m_time_processor.extruder_unloaded = false;
        const float t = get_filament_load_time(static_cast<size_t>(new_filament_id));
        extra_time += t;
        m_result.print_statistics.total_filament_load_time += t;       // Orca-only stat
        if (filament_in_nozzle_change && old_filament_in_nozzle != -1)
            m_result.print_statistics.total_flush_filament_changes += 1;
    }
    if (prev_filament_id != -1)
        m_result.print_statistics.total_filament_changes += 1;
    m_result.unlock();
 
    if (new_extruder_id != -1)
        m_filament_id[new_extruder_id] = static_cast<unsigned char>(new_filament_id);
    m_extruder_id = static_cast<unsigned char>(new_extruder_id);
 
    // Record the resulting nozzle/extruder occupancy so the next change can classify itself.
    m_nozzle_status_recorder.set_nozzle_status(new_nozzle_id_in_extruder, new_filament_id, new_extruder_id);
 
    m_cp_color.current = m_extruder_colors[new_filament_id];
 
    // Same tool-change move + zero-distance time block plumbing as the single-arg model, so the flush
    // delay lands on a Tool_change block (kept out of the per-role feature-time distribution).
    store_move_vertex(EMoveType::Tool_change);
 
    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;
        TimeBlock block;
        block.move_id             = static_cast<unsigned int>(m_result.moves.size()) - 1;
        block.move_type           = EMoveType::Tool_change;
        block.skippable_type      = m_skippable_type;
        block.layer_id            = std::max<unsigned int>(1, m_layer_id);
        block.g1_line_id          = m_g1_line_id;
        block.flags.prepare_stage = m_processing_start_custom_gcode;
        block.distance            = 0.0f;
        block.calculate_trapezoid();
        machine.blocks.push_back(block);
    }
 
    simulate_st_synchronize(extra_time, EMoveType::Tool_change);
 
    m_machine_config_idx = get_machine_config_idx();
}

References Slic3r::GCodeProcessor::TimeMachine::blocks, Slic3r::GCodeProcessor::TimeBlock::calculate_trapezoid(), Slic3r::PrintEstimatedStatistics::Count, Slic3r::GCodeProcessor::TimeBlock::distance, Slic3r::GCodeProcessor::TimeMachine::enabled, Slic3r::GCodeProcessor::TimeBlock::flags, Slic3r::GCodeProcessor::TimeBlock::g1_line_id, get_extruder_change_time(), get_extruder_id(), get_filament_id(), get_filament_load_time(), get_filament_unload_time(), get_machine_config_idx(), Slic3r::GCodeProcessor::TimeBlock::layer_id, m_cp_color, m_extruder_colors, m_extruder_id, m_filament_id, m_g1_line_id, m_last_filament_id, m_layer_id, m_machine_config_idx, m_nozzle_group_result, m_nozzle_status_recorder, m_processing_start_custom_gcode, m_result, m_skippable_type, m_time_processor, Slic3r::GCodeProcessor::TimeBlock::move_id, Slic3r::GCodeProcessor::TimeBlock::move_type, Slic3r::GCodeProcessor::TimeBlock::Flags::prepare_stage, process_filament_change(), process_filaments(), resolve_target_nozzle(), simulate_st_synchronize(), Slic3r::GCodeProcessor::TimeBlock::skippable_type, store_move_vertex(), Slic3r::Tool_change, Slic3r::CustomGCode::ToolChange, and use_multi_nozzle_change_time_model().

Here is the call 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_model_cache(this);
        m_used_filaments.process_support_cache(this);
        m_used_filaments.process_total_volume_cache(this);
        //BBS: reset remaining filament
        size_t last_extruder_id = get_extruder_id();
        m_remaining_volume[last_extruder_id] = m_nozzle_volume[last_extruder_id];
    }
}

References Slic3r::CustomGCode::ColorChange, get_extruder_id(), m_nozzle_volume, m_remaining_volume, m_used_filaments, and Slic3r::CustomGCode::ToolChange.

Referenced by process_filament_change(), process_filament_change(), 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;
 
    // 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) {
                    if (m_producer == EProducer::Unknown) {
                        if (detect_producer(std::string_view(begin, end - begin))) {
                            m_parser.quit_parsing();
                        }
                    } else if (std::string(begin, end).find("CONFIG_BLOCK_END") != std::string::npos) {
                        m_parser.quit_parsing();
                    }
                }
            }
        });
        m_parser.reset();
 
        // if the gcode was produced by OrcaSlicer,
        // extract the config from it
        if (m_producer == EProducer::OrcaSlicer || 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 OrcaSlicer'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);
 
            // Get the correct printer vendor based on the `printer_model` field
            auto printer_model_opt = config.opt<ConfigOptionString>("printer_model");
            if (printer_model_opt && !printer_model_opt->value.empty()) {
                // TODO: Orca hack, proper vendor check?
                GCodeProcessor::s_IsBBLPrinter = boost::starts_with(printer_model_opt->value, "Bambu Lab");
            }
 
            ConfigOptionStrings *filament_color = config.opt<ConfigOptionStrings>("filament_colour");
            ConfigOptionInts    *filament_map   = config.opt<ConfigOptionInts>("filament_map", true);
            if (filament_color && filament_color->size() != filament_map->size()) {
                filament_map->values.resize(filament_color->size(), 1);
            }
 
            apply_config(config);
        }
        else if (m_producer == EProducer::Simplify3D)
            apply_config_simplify3d(filename);
        else if (m_producer == EProducer::SuperSlicer)
            apply_config_superslicer(filename);
    }
 
    // 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_simplify3d(), apply_config_superslicer(), detect_producer(), Slic3r::EnableSilent, Slic3r::filament_map(), finalize(), initialize_result_moves(), Slic3r::ConfigBase::load_from_gcode_file(), m_parser, m_producer, m_result, Slic3r::DynamicConfig::opt(), OrcaSlicer, process_gcode_line(), Slic3r::remove_eols(), s_IsBBLPrinter, s_result_id, Simplify3D, Slic3r::ConfigOptionVector< T >::size(), Slic3r::skip_whitespaces(), Slic3r, Slic3rPE, SuperSlicer, and Unknown.

Referenced by Slic3r::Print::export_gcode_from_previous_file(), Slic3r::GUI::Plater::load_gcode(), and Slic3r::Print::reload_gcode_moves().

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 register_commands().

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, const std::optional< unsigned int > & remaining_internal_g1_lines = std::nullopt )

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();
    if (m_flavor == gcfKlipper) {
        // Preserve decimal coordinates for short segments without parsing twice.
        for (unsigned char axis = X; axis <= E; ++axis)
            if (line.has(static_cast<Axis>(axis)))
                g1_axes[axis] = line.precise_value(static_cast<Axis>(axis));
        if (line.has_f())
            g1_feedrate = line.precise_value(F);
    }
    process_G1(g1_axes, g1_feedrate);
}

References Slic3r::E, Slic3r::GCodeReader::GCodeLine::e(), Slic3r::F, Slic3r::GCodeReader::GCodeLine::f(), Slic3r::gcfKlipper, Slic3r::GCodeReader::GCodeLine::has(), 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_flavor, Slic3r::GCodeReader::GCodeLine::precise_value(), process_G1(), Slic3r::X, Slic3r::GCodeReader::GCodeLine::x(), Slic3r::Y, Slic3r::GCodeReader::GCodeLine::y(), Slic3r::Z, and Slic3r::GCodeReader::GCodeLine::z().

Referenced by process_G0(), process_G1(), process_G10(), process_G11(), process_G28(), process_G2_G3(), and register_commands().

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 }, const std::optional< double > & feedrate = std::nullopt, G1DiscretizationOrigin origin = G1DiscretizationOrigin::G1, const std::optional< unsigned int > & remaining_internal_g1_lines = std::nullopt )

private

{
    const std::array<bool, 3> start_axis_known = m_axis_position_known;
    int filament_id = get_filament_id();
    int last_filament_id = get_last_filament_id();
    float filament_diameter = (static_cast<size_t>(filament_id) < m_result.filament_diameters.size()) ? m_result.filament_diameters[filament_id] : m_result.filament_diameters.back();
    float filament_radius = 0.5f * filament_diameter;
    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));
    }
    update_position_known_from_move(axes, origin);
 
    // updates feedrate from line, if present
    if (feedrate.has_value())
        m_feedrate = (*feedrate) * MMMIN_TO_MMSEC;
 
    // calculates movement deltas
    float max_abs_delta = 0.0f;
    AxisCoords delta_pos;
    for (unsigned char a = X; a <= E; ++a) {
        delta_pos[a] = m_end_position[a] - m_start_position[a];
        max_abs_delta = std::max<float>(max_abs_delta, std::abs(delta_pos[a]));
    }
 
    // no displacement, return
    if (max_abs_delta == 0.0f)
        return;
 
    EMoveType type = move_type(delta_pos);
    const float delta_xyz = std::sqrt(sqr(delta_pos[X]) + sqr(delta_pos[Y]) + sqr(delta_pos[Z]));
    m_travel_dist = delta_xyz;
 
    if (!m_processing_homing_move) {
        std::optional<ExclusionVolumeMotionType> exclusion_motion_type;
        switch (type) {
        case EMoveType::Travel:
            exclusion_motion_type = ExclusionVolumeMotionType::Travel;
            break;
        case EMoveType::Extrude:
        case EMoveType::Wipe:
            exclusion_motion_type = ExclusionVolumeMotionType::Extrude;
            break;
        case EMoveType::Retract:
        case EMoveType::Unretract:
            exclusion_motion_type = ExclusionVolumeMotionType::Other;
            break;
        default:
            break;
        }
 
        if (exclusion_motion_type) {
            m_exclusion_volume_path_checker.check_motion(
                Vec3d(m_start_position[X], m_start_position[Y], m_start_position[Z]),
                Vec3d(m_end_position[X], m_end_position[Y], m_end_position[Z]),
                start_axis_known[X] && start_axis_known[Y],
                m_axis_position_known[X] && m_axis_position_known[Y],
                start_axis_known[Z],
                m_axis_position_known[Z],
                get_extruder_id(false),
                *exclusion_motion_type,
                static_cast<unsigned char>(type),
                m_line_id,
                m_result.moves.size());
        }
    }
 
    if (type == EMoveType::Extrude) {
        float volume_extruded_filament = area_filament_cross_section * delta_pos[E];
        float area_toolpath_cross_section = volume_extruded_filament / delta_xyz;
 
        if(m_extrusion_role == ExtrusionRole::erSupportMaterial || m_extrusion_role == ExtrusionRole::erSupportMaterialInterface || m_extrusion_role ==ExtrusionRole::erSupportTransition)
            m_used_filaments.increase_support_caches(volume_extruded_filament);
        else if (m_extrusion_role==ExtrusionRole::erWipeTower) {
            m_used_filaments.increase_wipe_tower_caches(volume_extruded_filament);
        }
        else {
            // save extruded volume to the cache
            m_used_filaments.increase_model_caches(volume_extruded_filament);
        }
        // volume extruded filament / tool displacement = area toolpath cross section
        m_mm3_per_mm = area_toolpath_cross_section;
 
        if (m_forced_height > 0.0f)
            m_height = m_forced_height;
        else if (origin == G1DiscretizationOrigin::G1) {
            if (m_end_position[Z] > m_extruded_last_z + EPSILON)
                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_end_position[Z] = m_height;
 
        if (origin == G1DiscretizationOrigin::G1)
            m_extruded_last_z = m_end_position[Z];
        // The queued blocks of the moves after the erased one follow them down the list.
        if (const std::optional<size_t> erased = m_options_z_corrector.update(m_height)) {
            for (TimeMachine& machine : m_time_processor.machines) {
                for (TimeBlock& block : machine.blocks) {
                    if (block.move_id > *erased)
                        --block.move_id;
                }
            }
        }
 
        if (m_forced_width > 0.0f)
            m_width = m_forced_width;
        else if (m_extrusion_role == erExternalPerimeter)
            // 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 == erBridgeInfill || m_extrusion_role == erInternalBridgeInfill || m_extrusion_role == erNone)
            // cross section: circle
            m_width = static_cast<float>(m_result.filament_diameters[filament_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));
    }
    else if (type == EMoveType::Unretract && m_flushing) {
        int extruder_id = get_extruder_id();
        float volume_flushed_filament = area_filament_cross_section * delta_pos[E];
        if (m_remaining_volume[extruder_id] > volume_flushed_filament)
        {
            m_used_filaments.update_flush_per_filament(last_filament_id, volume_flushed_filament);
            m_remaining_volume[extruder_id] -= volume_flushed_filament;
        }
        else {
            m_used_filaments.update_flush_per_filament(last_filament_id, m_remaining_volume[extruder_id]);
            m_used_filaments.update_flush_per_filament(filament_id, volume_flushed_filament - m_remaining_volume[extruder_id]);
            m_remaining_volume[extruder_id] = 0.f;
        }
    }
 
    // time estimate section
    auto move_length = [](const AxisCoords& delta_pos) {
        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;
    };
 
    float distance = move_length(delta_pos);
    assert(distance != 0.0f);
    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);
 
        //BBS: calculeta enter and exit direction
        curr.enter_direction = { static_cast<float>(delta_pos[X]), static_cast<float>(delta_pos[Y]), static_cast<float>(delta_pos[Z]) };
        float norm = curr.enter_direction.norm();
        if (!is_extrusion_only_move(delta_pos))
            curr.enter_direction = curr.enter_direction / norm;
        curr.exit_direction = curr.enter_direction;
        curr.jd_unit_vec = Vec4f(static_cast<float>(delta_pos[X]),
                                 static_cast<float>(delta_pos[Y]),
                                 static_cast<float>(delta_pos[Z]),
                                 static_cast<float>(delta_pos[E])).normalized();
 
        TimeBlock block;
        block.move_type = type;
        // stamp the current SKIPPABLE type onto the block. Stamped stTimelapse inside the fleet-wide
        // time_lapse_gcode regions; byte-inert because nothing reads the stamp until the injector
        // consumes it.
        block.skippable_type = m_skippable_type;
        //BBS: don't calculate travel time into extrusion path, except travel inside start and end gcode.
        block.role = (type != EMoveType::Travel || m_extrusion_role == erCustom) ? m_extrusion_role : erNone;
        block.distance = distance;
        block.g1_line_id = m_g1_line_id;
        block.move_id = static_cast<unsigned int>(m_result.moves.size());
        block.remaining_internal_g1_lines = remaining_internal_g1_lines.has_value() ? *remaining_internal_g1_lines : 0;
        block.layer_id = std::max<unsigned int>(1, m_layer_id);
        block.flags.prepare_stage = m_processing_start_custom_gcode;
 
        //BBS: limite the cruise according to centripetal acceleration
        //Only need to handle when both prev and curr segment has movement in x-y plane
        if (m_flavor != gcfKlipper && (prev.exit_direction(0) != 0.0f || prev.exit_direction(1) != 0.0f) &&
            (curr.enter_direction(0) != 0.0f || curr.enter_direction(1) != 0.0f)) {
            Vec3f v1 = prev.exit_direction;
            v1(2, 0) = 0.0f;
            v1.normalize();
            Vec3f v2 = curr.enter_direction;
            v2(2, 0) = 0.0f;
            v2.normalize();
            float norm_diff = (v2 - v1).norm();
            //BBS: don't need to consider limitation of centripetal acceleration
            //when angle changing is larger than 28.96 degree or two lines are almost collinear.
            //Attention!!! these two value must be same with MC side.
            if (norm_diff < 0.5f && norm_diff > 0.00001f) {
                //BBS: calculate angle
                float dot = v1(0) * v2(0) + v1(1) * v2(1);
                float cross = v1(0) * v2(1) - v1(1) * v2(0);
                float angle = float(atan2(double(cross), double(dot)));
                float sin_theta_2 = sqrt((1.0f - cos(angle)) * 0.5f);
                float r = sqrt(sqr(delta_pos[X]) + sqr(delta_pos[Y])) * 0.5 / sin_theta_2;
                float acc = get_acceleration(static_cast<PrintEstimatedStatistics::ETimeMode>(i));
                curr.feedrate = std::min(curr.feedrate, sqrt(acc * r));
            }
        }
 
        if (m_flavor == gcfKlipper && !is_extrusion_only_move(delta_pos)) {
            const float max_velocity = get_axis_max_feedrate(static_cast<PrintEstimatedStatistics::ETimeMode>(i), X, m_machine_config_idx);
            if (max_velocity > 0.0f)
                curr.feedrate = std::min(curr.feedrate, max_velocity);
        }
        // Klipper applies E limits to retractions and moves without XY motion,
        // not to positive extrusion along a printing path.
        const bool limit_extruder = m_flavor != gcfKlipper || delta_pos[E] < 0.0 ||
                                    (delta_pos[X] == 0.0 && delta_pos[Y] == 0.0);
        // 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 && (a != E || limit_extruder) &&
                (m_flavor != gcfKlipper || a == Z || a == E)) {
                float axis_max_feedrate = get_axis_max_feedrate(static_cast<PrintEstimatedStatistics::ETimeMode>(i), static_cast<Axis>(a), m_machine_config_idx);
                if (axis_max_feedrate != 0.0f) min_feedrate_factor = std::min<float>(min_feedrate_factor, axis_max_feedrate / curr.abs_axis_feedrate[a]);
            }
        }
        //BBS: update curr.feedrate
        curr.feedrate *= min_feedrate_factor;
        block.feedrate_profile.cruise = 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;
        if (m_flavor == gcfKlipper && is_extrusion_only_move(delta_pos)) {
            // Klipper's max_extrude_only_accel. machine_max_acceleration_e is optional and some
            // shipped profiles leave it at 0, so keep the non-zero retract fallback.
            acceleration = get_axis_max_acceleration(static_cast<PrintEstimatedStatistics::ETimeMode>(i), E, m_machine_config_idx);
            if (acceleration <= 0.0f)
                acceleration = get_retract_acceleration(static_cast<PrintEstimatedStatistics::ETimeMode>(i));
        } else
            acceleration =
                (m_flavor == gcfKlipper) ? get_acceleration(static_cast<PrintEstimatedStatistics::ETimeMode>(i)) :
                (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)));
 
        //BBS
        for (unsigned char a = X; a <= E; ++a) {
            if ((a == E && !limit_extruder) || (m_flavor == gcfKlipper && (a == X || a == Y)))
                continue;
            float axis_max_acceleration = get_axis_max_acceleration(static_cast<PrintEstimatedStatistics::ETimeMode>(i), static_cast<Axis>(a), m_machine_config_idx);
            // An unset (0) limit means "no limit", as in the feedrate loop above. Only the Klipper
            // planner divides by the block acceleration, so leave the Marlin path as it was.
            if (m_flavor == gcfKlipper && axis_max_acceleration <= 0.0f)
                continue;
            if (acceleration * std::abs(delta_pos[a]) * inv_distance > axis_max_acceleration)
                acceleration = axis_max_acceleration / (std::abs(delta_pos[a]) * inv_distance);
        }
 
        block.acceleration = acceleration;
        if (m_flavor == gcfKlipper) {
            block.junction_deviation = get_junction_deviation(static_cast<PrintEstimatedStatistics::ETimeMode>(i), acceleration);
            const float cruise_acceleration = machine.requested_accel_to_decel >= 0.0f ?
                std::min(machine.acceleration, machine.requested_accel_to_decel) :
                machine.acceleration * (1.0f - machine.minimum_cruise_ratio);
            block.mcr_delta_v2 = 2.0f * distance * std::min(acceleration, cruise_acceleration);
        }
 
        static const float PREVIOUS_FEEDRATE_THRESHOLD = 0.0001f;
        const bool has_prev_move = !blocks.empty() && prev.feedrate > PREVIOUS_FEEDRATE_THRESHOLD;
 
        // Orca: junction deviation where the firmware uses it (Klipper always, Marlin 2 with M205 J).
        // Negative leaves the classic jerk path below unchanged.
        const float vmax_junction_jd = calc_vmax_junction_deviation(block, prev, curr, has_prev_move,
                                                                    static_cast<PrintEstimatedStatistics::ETimeMode>(i));
        const bool use_junction_deviation = vmax_junction_jd >= 0.0f;
 
        // calculates block exit feedrate. Junction deviation has no per axis jerk floor, so a move is
        // free to start from rest.
        curr.safe_feedrate = use_junction_deviation ? 0.0f : block.feedrate_profile.cruise;
 
        if (!use_junction_deviation) {
            for (unsigned char a = X; a <= E; ++a) {
                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;
 
        // calculates block entry feedrate
        float vmax_junction = use_junction_deviation ? vmax_junction_jd : curr.safe_feedrate;
        if (!use_junction_deviation && has_prev_move) {
            bool prev_speed_larger = prev.feedrate > block.feedrate_profile.cruise;
            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.
                if (a == X) {
                    Vec3f exit_v = prev.feedrate * (prev.exit_direction);
                    if (prev_speed_larger)
                        exit_v *= smaller_speed_factor;
                    Vec3f entry_v = block.feedrate_profile.cruise * (curr.enter_direction);
                    Vec3f jerk_v = entry_v - exit_v;
                    jerk_v = Vec3f(abs(jerk_v.x()), abs(jerk_v.y()), abs(jerk_v.z()));
                    Vec3f max_xyz_jerk_v = get_xyz_max_jerk(static_cast<PrintEstimatedStatistics::ETimeMode>(i));
 
                    for (size_t i = 0; i < 3; i++)
                    {
                        if (jerk_v[i] > max_xyz_jerk_v[i]) {
                            v_factor *= max_xyz_jerk_v[i] / jerk_v[i];
                            jerk_v *= v_factor;
                            limited = true;
                        }
                    }
                }
                else if (a == Y || a == Z) {
                    continue;
                }
                else {
                    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.
                    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));
 
 
                    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.
            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;
        }
 
        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;
        if (m_flavor == gcfKlipper && has_prev_move) {
            const TimeBlock& previous = blocks.back();
            block.max_entry_speed = std::min(block.max_entry_speed,
                                             std::sqrt(sqr(previous.max_entry_speed) + 2.0f * previous.distance * previous.acceleration));
            block.max_mcr_entry_speed_sqr = std::min(sqr(block.max_entry_speed), previous.max_mcr_entry_speed_sqr + previous.mcr_delta_v2);
        }
        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 (m_flavor == gcfKlipper && blocks.size() > 1)
            machine.klipper_junction_flush -= distance / curr.feedrate;
    }
 
    if (m_flavor == gcfKlipper ? m_time_processor.machines[0].klipper_junction_flush <= 0.0f :
        m_time_processor.machines[0].blocks.size() > TimeProcessor::Planner::refresh_threshold)
        calculate_time(m_result, TimeProcessor::Planner::queue_size);
 
    const Vec3f plate_offset = {(float) m_x_offset, (float) m_y_offset, 0.0f};
 
    if (m_seams_detector.is_active()) {
        // check for seam starting vertex
        if (type == EMoveType::Extrude && m_extrusion_role == erExternalPerimeter) {
            //BBS: m_result.moves.back().position has plate offset, must minus plate offset before calculate the real seam position
            const Vec3f new_pos = m_result.moves.back().position - m_extruder_offsets[filament_id] - plate_offset;
            if (!m_seams_detector.has_first_vertex()) {
                m_seams_detector.set_first_vertex(new_pos);
            } else if (m_detect_layer_based_on_tag) {
            // We may have sloped loop, drop any previous start pos if we have z increment
            const std::optional<Vec3f> first_vertex = m_seams_detector.get_first_vertex();
            if (new_pos.z() > first_vertex->z()) {
                m_seams_detector.set_first_vertex(new_pos);
                }
            }
        }
        // check for seam ending vertex and store the resulting move
        else if ((type != EMoveType::Extrude || (m_extrusion_role != erExternalPerimeter && m_extrusion_role != erOverhangPerimeter)) && 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]);
            //BBS: m_result.moves.back().position has plate offset, must minus plate offset before calculate the real seam position
            const Vec3f new_pos = m_result.moves.back().position - m_extruder_offsets[filament_id] - plate_offset;
            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 == erExternalPerimeter) {
        m_seams_detector.activate(true);
        m_seams_detector.set_first_vertex(m_result.moves.back().position - m_extruder_offsets[filament_id] - plate_offset);
    }
 
    if (type == EMoveType::Extrude)
        add_object_mass(filament_id, area_filament_cross_section * delta_pos[E]);
 
    // store move
    store_move_vertex(type);
}

References Slic3r::GCodeProcessor::TimeMachine::State::abs_axis_feedrate, Slic3r::GCodeProcessor::TimeBlock::acceleration, Slic3r::GCodeProcessor::TimeMachine::acceleration, add_object_mass(), Slic3r::angle(), Slic3r::GCodeProcessor::TimeMachine::State::axis_feedrate, Slic3r::GCodeProcessor::TimeMachine::blocks, calc_vmax_junction_deviation(), calculate_time(), Slic3r::GCodeProcessor::TimeBlock::calculate_trapezoid(), Slic3r::PrintEstimatedStatistics::Count, Slic3r::cross(), Slic3r::GCodeProcessor::FeedrateProfile::cruise, Slic3r::GCodeProcessor::TimeMachine::curr, DEFAULT_TOOLPATH_HEIGHT, DEFAULT_TOOLPATH_WIDTH, Slic3r::GCodeProcessor::TimeBlock::distance, Slic3r::dot(), Slic3r::E, Slic3r::GCodeProcessor::TimeMachine::enabled, Slic3r::GCodeProcessor::TimeMachine::State::enter_direction, Slic3r::GCodeProcessor::FeedrateProfile::entry, EPSILON, Slic3r::erBridgeInfill, Slic3r::erCustom, Slic3r::erExternalPerimeter, Slic3r::erInternalBridgeInfill, Slic3r::erNone, Slic3r::erOverhangPerimeter, Slic3r::erSupportMaterial, Slic3r::erSupportMaterialInterface, Slic3r::erSupportTransition, Slic3r::erWipeTower, Slic3r::GCodeProcessor::FeedrateProfile::exit, Slic3r::GCodeProcessor::TimeMachine::State::exit_direction, extract_absolute_position_on_axis(), Slic3r::Extrude, Slic3r::GCodeProcessor::TimeMachine::extrude_factor_override_percentage, Slic3r::GCodeProcessor::TimeMachine::State::feedrate, Slic3r::GCodeProcessor::TimeBlock::feedrate_profile, Slic3r::GCodeProcessor::TimeBlock::flags, G1, Slic3r::GCodeProcessor::TimeBlock::g1_line_id, Slic3r::gcfKlipper, get_acceleration(), get_axis_max_acceleration(), get_axis_max_feedrate(), get_axis_max_jerk(), get_extruder_id(), get_filament_id(), get_junction_deviation(), get_last_filament_id(), get_retract_acceleration(), get_travel_acceleration(), get_xyz_max_jerk(), Inches, INCHES_TO_MM, Slic3r::GCodeProcessor::TimeMachine::State::jd_unit_vec, Slic3r::GCodeProcessor::TimeBlock::junction_deviation, Slic3r::GCodeProcessor::TimeMachine::klipper_junction_flush, Slic3r::GCodeProcessor::TimeBlock::layer_id, m_axis_position_known, m_detect_layer_based_on_tag, m_e_local_positioning_type, m_end_position, m_exclusion_volume_path_checker, m_extruded_last_z, m_extruder_offsets, m_extrusion_role, m_feedrate, m_flavor, m_flushing, m_forced_height, m_forced_width, m_g1_line_id, m_global_positioning_type, m_height, m_layer_id, m_line_id, m_machine_config_idx, m_mm3_per_mm, m_options_z_corrector, m_origin, M_PI, m_processing_homing_move, m_processing_start_custom_gcode, m_remaining_volume, m_result, m_seams_detector, m_skippable_type, m_start_position, m_time_processor, m_travel_dist, m_units, m_used_filaments, m_width, m_wiping, m_x_offset, m_y_offset, m_z_offset, Slic3r::max_allowable_speed(), Slic3r::GCodeProcessor::TimeBlock::max_entry_speed, Slic3r::GCodeProcessor::TimeBlock::max_mcr_entry_speed_sqr, Slic3r::GCodeProcessor::TimeBlock::mcr_delta_v2, Slic3r::GCodeProcessor::TimeMachine::minimum_cruise_ratio, minimum_feedrate(), minimum_travel_feedrate(), MMMIN_TO_MMSEC, Slic3r::GCodeProcessor::TimeBlock::move_id, Slic3r::GCodeProcessor::TimeBlock::move_type, Slic3r::GCodeProcessor::TimeBlock::Flags::nominal_length, Slic3r::Noop, Slic3r::Other, Slic3r::GCodeProcessor::TimeBlock::Flags::prepare_stage, Slic3r::GCodeProcessor::TimeMachine::prev, Slic3r::GCodeProcessor::TimeProcessor::Planner::queue_size, Slic3r::GCodeProcessor::TimeBlock::Flags::recalculate, Slic3r::GCodeProcessor::TimeProcessor::Planner::refresh_threshold, Relative, Slic3r::GCodeProcessor::TimeBlock::remaining_internal_g1_lines, Slic3r::GCodeProcessor::TimeMachine::requested_accel_to_decel, Slic3r::Retract, Slic3r::GCodeProcessor::TimeBlock::role, Slic3r::GCodeProcessor::TimeBlock::safe_feedrate, Slic3r::GCodeProcessor::TimeMachine::State::safe_feedrate, Slic3r::Seam, Slic3r::GCodeProcessor::TimeBlock::skippable_type, Slic3r::sqr(), store_move_vertex(), Slic3r::Travel, Slic3r::Unretract, update_position_known_from_move(), Slic3r::Wipe, Slic3r::X, Slic3r::Y, and Slic3r::Z.

Here is the call graph for this function:

process_G10()

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

private

{
    // Emulate G1 retract, decrement G1 count as it's will be incremented in process_G1, but it's fake G1
    GCodeReader::GCodeLine g10;
    g10.set(Axis::E, -this->m_parser.config().retraction_length.get_at(m_extruder_id));
    g10.set(Axis::F,  this->m_parser.config().retraction_speed.get_at(m_extruder_id) * 60);
    //Orca: Firmware retract emulation must not change the modal G1 feedrate.
    const float feedrate = m_feedrate;
    --m_g1_line_id;
    process_G1(g10);
    m_feedrate = feedrate;
}

References Slic3r::E, Slic3r::F, m_extruder_id, m_feedrate, m_g1_line_id, m_parser, process_G1(), and Slic3r::GCodeReader::GCodeLine::set().

Referenced by register_commands().

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

{
    // Emulate G1 unretract, decrement G1 count as it's will be incremented in process_G1, but it's fake G1
    GCodeReader::GCodeLine g11;
    g11.set(Axis::E, this->m_parser.config().retraction_length.get_at(m_extruder_id) + this->m_parser.config().retract_restart_extra.get_at(m_extruder_id));
    g11.set(Axis::F, this->m_parser.config().deretraction_speed.get_at(m_extruder_id) * 60);
    // Orca: Firmware unretract emulation must not change the modal G1 feedrate.
    const float feedrate = m_feedrate;
    --m_g1_line_id;
    process_G1(g11);
    m_feedrate = feedrate;
}

References Slic3r::E, Slic3r::F, m_extruder_id, m_feedrate, m_g1_line_id, m_parser, process_G1(), and Slic3r::GCodeReader::GCodeLine::set().

Referenced by register_commands().

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 register_commands().

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 register_commands().

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 register_commands().

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 register_commands().

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() };
    const std::array<bool, 3> homed = g28_homed_axes(line);
    const bool found = std::any_of(homed.begin(), homed.end(), [](const bool value) { return value; });
    if (homed[X]) {
        new_line_raw += " X0";
    }
    if (homed[Y]) {
        new_line_raw += " Y0";
    }
    if (homed[Z]) {
        new_line_raw += " Z0";
    }
    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; });
    m_processing_homing_move = true;
    process_G1(new_gline);
    m_processing_homing_move = false;
 
    // G28's physical endpoint is printer-specific even though the preview uses
    // zero. Wait for a subsequent explicit absolute coordinate before checking
    // a path from any homed axis.
    for (unsigned char axis = X; axis <= Z; ++axis) {
        if (!found || homed[axis]) {
            m_axis_position_known[axis] = false;
            m_axis_origin_known[axis] = true;
        }
    }
}

References Slic3r::GCodeReader::GCodeLine::cmd(), Slic3r::g28_homed_axes(), m_axis_origin_known, m_axis_position_known, m_processing_homing_move, Slic3r::GCodeReader::parse_line(), process_G1(), Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by register_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

process_G29()

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

private

{
    // Firmware may split one bed-leveling sequence across multiple G29 subcommands.
    constexpr float g29_time = 260.0f;
    const bool should_add_time = !s_IsBBLPrinter || m_measure_g29_time;
    if (should_add_time && !m_g29_time_added) {
        simulate_st_synchronize(g29_time);
        m_g29_time_added = true;
    }
}

References m_g29_time_added, m_measure_g29_time, s_IsBBLPrinter, and simulate_st_synchronize().

Referenced by register_commands().

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

{
    enum class EFitting { None, IJ, R };
    std::string_view axis_pos_I;
    std::string_view axis_pos_J;
    EFitting fitting = EFitting::None;
    if (line.has('R')) {
        fitting = EFitting::R;
    } else {
        axis_pos_I = line.axis_pos('I');
        axis_pos_J = line.axis_pos('J');
        if (! axis_pos_I.empty() || ! axis_pos_J.empty())
            fitting = EFitting::IJ;
    }
 
    if (fitting == EFitting::None)
        return;
 
    int filament_id = get_filament_id();
    const float filament_diameter = (static_cast<size_t>(filament_id) < m_result.filament_diameters.size()) ? m_result.filament_diameters[filament_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));
    }
 
    // relative center
    Vec3f rel_center = Vec3f::Zero();
#ifndef NDEBUG
    double radius = 0.0;
#endif // NDEBUG
    if (fitting == EFitting::R) {
        float r;
        if (!line.has_value('R', r) || r == 0.0f)
            return;
#ifndef NDEBUG
        radius = (double)std::abs(r);
#endif // NDEBUG
        const Vec2f start_pos((float)m_start_position[X], (float)m_start_position[Y]);
        const Vec2f end_pos((float)end_position[X], (float)end_position[Y]);
        const Vec2f c = Geometry::ArcWelder::arc_center(start_pos, end_pos, r, !clockwise);
        rel_center.x() = c.x() - m_start_position[X];
        rel_center.y() = c.y() - m_start_position[Y];
    }
    else {
        assert(fitting == EFitting::IJ);
        if (! axis_pos_I.empty() && ! line.has_value(axis_pos_I, rel_center.x()))
            return;
        if (! axis_pos_J.empty() && ! line.has_value(axis_pos_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>();
 
    // 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()) > 0.001) {
        // what to do ???
    }
 
    assert(fitting != EFitting::R || std::abs(radius - arc.start_radius()) < EPSILON);
 
    // updates feedrate from line
    std::optional<float> feedrate;
    if (line.has_f()) {
        // feedrate = m_feed_multiply.current * line.f() * MMMIN_TO_MMSEC;
        feedrate = 1.0f * 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](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, const std::optional<unsigned int>& remaining_internal_g1_lines = std::nullopt) {
          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 (extrusion.has_value())
              g1_axes[E] = target[E];
          if (feedrate.has_value())
              g1_feedrate = (double)*feedrate / MMMIN_TO_MMSEC;
          process_G1(g1_axes, g1_feedrate, G1DiscretizationOrigin::G2G3, remaining_internal_g1_lines);
    };
 
    if (m_flavor == gcfMarlinFirmware) {
        // calculate arc segments
        // reference:
        // Prusa-Firmware-Buddy\lib\Marlin\Marlin\src\gcode\motion\G2_G3.cpp - plan_arc()
        // https://github.com/prusa3d/Prusa-Firmware-Buddy-Private/blob/private/lib/Marlin/Marlin/src/gcode/motion/G2_G3.cpp
 
        static const float MAX_ARC_DEVIATION = 0.02f;
        static const float MIN_ARC_SEGMENTS_PER_SEC = 50;
        static const float MIN_ARC_SEGMENT_MM = 0.1f;
        static const float MAX_ARC_SEGMENT_MM = 2.0f;
        const float feedrate_mm_s = feedrate.has_value() ? *feedrate : m_feedrate;
        const float radius_mm = rel_center.norm();
        const float segment_mm = std::clamp(std::min(std::sqrt(8.0f * radius_mm * MAX_ARC_DEVIATION), feedrate_mm_s * (1.0f / MIN_ARC_SEGMENTS_PER_SEC)), MIN_ARC_SEGMENT_MM, MAX_ARC_SEGMENT_MM);
        const float flat_mm = radius_mm * std::abs(arc.angle);
        const size_t segments = std::max<size_t>(flat_mm / segment_mm + 0.8f, 1);
 
        AxisCoords prev_target = m_start_position;
 
        if (segments > 1) {
            const float inv_segments = 1.0f / static_cast<float>(segments);
            const float theta_per_segment = static_cast<float>(arc.angle) * inv_segments;
            const float cos_T = cos(theta_per_segment);
            const float sin_T = sin(theta_per_segment);
            const float z_per_segment = arc.delta_z() * inv_segments;
            const float extruder_per_segment = (extrusion.has_value()) ? *extrusion * inv_segments : 0.0f;
 
            static const size_t N_ARC_CORRECTION = 25;
            size_t arc_recalc_count = N_ARC_CORRECTION;
 
            Vec2f rvec(-rel_center.x(), -rel_center.y());
            AxisCoords arc_target = { 0.0f, 0.0f, m_start_position[Z], m_start_position[E] };
            for (size_t i = 1; i < segments; ++i) {
                if (--arc_recalc_count) {
                    // Apply vector rotation matrix to previous rvec.a / 1
                    const float r_new_Y = rvec.x() * sin_T + rvec.y() * cos_T;
                    rvec.x() = rvec.x() * cos_T - rvec.y() * sin_T;
                    rvec.y() = r_new_Y;
                }
                else {
                    arc_recalc_count = N_ARC_CORRECTION;
                    // Arc correction to radius vector. Computed only every N_ARC_CORRECTION increments.
                    // Compute exact location by applying transformation matrix from initial radius vector(=-offset).
                    // To reduce stuttering, the sin and cos could be computed at different times.
                    // For now, compute both at the same time.
                    const float Ti = i * theta_per_segment;
                    const float cos_Ti = cos(Ti);
                    const float sin_Ti = sin(Ti);
                    rvec.x() = -rel_center.x() * cos_Ti + rel_center.y() * sin_Ti;
                    rvec.y() = -rel_center.x() * sin_Ti - rel_center.y() * cos_Ti;
                }
 
                // Update arc_target location
                arc_target[X] = arc.center.x() + rvec.x();
                arc_target[Y] = arc.center.y() + rvec.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, segments - i);
                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);
    }
    else {
        // 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
#if 0
        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);
#else
        static const double gcode_arc_tolerance = 0.0125;
        const size_t segments = Geometry::ArcWelder::arc_discretization_steps(arc.start_radius(), std::abs(arc.angle), gcode_arc_tolerance);
#endif
 
        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 sq_theta_per_segment = sqr(theta_per_segment);
        const double cos_T = 1.0 - 0.5 * sq_theta_per_segment;
        const double sin_T = theta_per_segment - sq_theta_per_segment * theta_per_segment / 6.0f;
 
        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 = N_ARC_CORRECTION;
 
        for (size_t i = 1; i < segments; ++i) {
            if (count-- == 0) {
                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 = N_ARC_CORRECTION;
            }
            else {
                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;
            }
 
            // 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, segments - i);
            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);
    }
 
    // Internal linearized arc segments inherit the arc's starting certainty.
    // Only the original absolute command may establish a newly known endpoint.
    update_position_known_from_move(line);
}

References Slic3r::angle(), Slic3r::Geometry::ArcWelder::arc_center(), Slic3r::Geometry::ArcWelder::arc_discretization_steps(), Slic3r::GCodeReader::GCodeLine::axis_pos(), Slic3r::center(), count, Slic3r::E, EPSILON, extract_absolute_position_on_axis(), Slic3r::GCodeReader::GCodeLine::f(), G2G3, Slic3r::gcfMarlinFirmware, get_filament_id(), Slic3r::GCodeReader::GCodeLine::has(), Slic3r::GCodeReader::GCodeLine::has_e(), Slic3r::GCodeReader::GCodeLine::has_f(), Slic3r::GCodeReader::GCodeLine::has_value(), Inches, INCHES_TO_MM, Slic3r::length(), m_e_local_positioning_type, m_end_position, m_feedrate, m_flavor, m_global_positioning_type, M_PI, m_result, m_start_position, m_units, MMMIN_TO_MMSEC, Slic3r::None, PI, process_G1(), Relative, Slic3r::sqr(), update_position_known_from_move(), Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by register_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

process_G4()

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

private

{
    float value_s = 0.0;
    float value_p = 0.0;
    if (line.has_value('S', value_s) || line.has_value('P', value_p)) {
        value_s += value_p * 0.001;
        simulate_st_synchronize(value_s);
    }
}

References Slic3r::GCodeReader::GCodeLine::has_value(), and simulate_st_synchronize().

Referenced by register_commands().

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 register_commands().

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 register_commands().

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_axis_origin_known[X] = m_axis_position_known[X];
        m_origin[X] = m_end_position[X] - line.x() * lengths_scale_factor;
        any_found = true;
    }
 
    if (line.has_y()) {
        m_axis_origin_known[Y] = m_axis_position_known[Y];
        m_origin[Y] = m_end_position[Y] - line.y() * lengths_scale_factor;
        any_found = true;
    }
 
    if (line.has_z()) {
        m_axis_origin_known[Z] = m_axis_position_known[Z];
        m_origin[Z] = m_end_position[Z] - line.z() * lengths_scale_factor;
        any_found = true;
        // Belt only: the start G-code's purge-blob advance + G92 Z0 resets leave a constant
        // machine-Z origin offset here; the designed-view back-transform subtracts it so
        // toolpaths map to the model's belt coordinate (gcode Z). Gated on belt_tilt_angle
        // (set from the belt header, parsed before the body) so non-belt G-code processing
        // is byte-identical — no unconditional work on the shared path.
        if (m_result.belt_tilt_angle != 0.f)
            m_result.belt_z_origin = m_origin[Z];
    }
 
    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) {
            if (a <= Z)
                m_axis_origin_known[a] = m_axis_position_known[a];
            m_origin[a] = m_end_position[a];
        }
    }
}

References Slic3r::E, Slic3r::GCodeReader::GCodeLine::e(), Slic3r::GCodeReader::GCodeLine::has_e(), Slic3r::GCodeReader::GCodeLine::has_unknown_axis(), Slic3r::GCodeReader::GCodeLine::has_x(), Slic3r::GCodeReader::GCodeLine::has_y(), Slic3r::GCodeReader::GCodeLine::has_z(), Inches, INCHES_TO_MM, m_axis_origin_known, m_axis_position_known, m_end_position, m_origin, m_result, m_units, simulate_st_synchronize(), Slic3r::X, Slic3r::GCodeReader::GCodeLine::x(), Slic3r::Y, Slic3r::GCodeReader::GCodeLine::y(), Slic3r::Z, and Slic3r::GCodeReader::GCodeLine::z().

Referenced by register_commands().

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 (m_flavor == gcfKlipper)
    {
        if (ascii_iequals(cmd, "SET_VELOCITY_LIMIT"))
        {
            process_SET_VELOCITY_LIMIT(line);
            return;
        }
// ORCA: Add Pressure Advance visualization support
        if (ascii_iequals(cmd, "SET_PRESSURE_ADVANCE"))
        {
            process_SET_PRESSURE_ADVANCE(line);
            return;
        }
    }
 
    if (cmd.length() > 1) {
        // process command lines
        m_command_processor.process_comand(cmd, line);
    }
    else {
        const std::string &comment = line.raw();
        if (comment.length() > 2 && comment.front() == ';')
        {
            std::string comment_content = comment.substr(1); // only format like ";V{cmd}" is valid
            if (comment_content[0] == 'V' || comment_content[0] == 'v') {
                GCodeReader reader;
                GCodeReader::GCodeLine new_line;
                reader.parse_line(comment_content, [&new_line](const auto& greader, const auto& gline) {
                    new_line = gline;
                    });
                m_command_processor.process_comand(new_line.cmd(), new_line);
            }
            else {
                // 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_content, producers_enabled);
            }
        }
    }
}

References Slic3r::ascii_iequals(), Slic3r::GCodeReader::GCodeLine::cmd(), Slic3r::gcfKlipper, m_command_processor, m_end_position, m_flavor, m_line_id, m_start_position, Slic3r::GCodeReader::parse_line(), process_SET_PRESSURE_ADVANCE(), process_SET_VELOCITY_LIMIT(), 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(erSkirt);
        else if (type == "WALL-OUTER")
            set_extrusion_role(erExternalPerimeter);
        else if (type == "WALL-INNER")
            set_extrusion_role(erPerimeter);
        else if (type == "SOLID-FILL")
            set_extrusion_role(erSolidInfill);
        else if (type == "FILL")
            set_extrusion_role(erInternalInfill);
        else if (type == "BRIDGE")
            set_extrusion_role(erBridgeInfill);
        else if (type == "INTERNAL BRIDGE")
            set_extrusion_role(erInternalBridgeInfill);
        else if (type == "SUPPORT")
            set_extrusion_role(erSupportMaterial);
        else {
            set_extrusion_role(erNone);
            BOOST_LOG_TRIVIAL(warning) << "GCodeProcessor found unknown extrusion role: " << type;
        }
 
        if (m_extrusion_role == erExternalPerimeter)
            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::erBridgeInfill, Slic3r::erExternalPerimeter, Slic3r::erInternalBridgeInfill, Slic3r::erInternalInfill, Slic3r::erNone, Slic3r::erPerimeter, Slic3r::erSkirt, Slic3r::erSolidInfill, Slic3r::erSupportMaterial, m_extrusion_role, m_forced_height, m_forced_width, m_layer_id, m_seams_detector, Slic3r::parse_number(), and set_extrusion_role().

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(erSkirt);
        return true;
    }
 
    // ; 'Support Interface Path'
    pos = comment.find(" 'Support Interface Path'");
    if (pos == 0) {
        set_extrusion_role(erSupportMaterialInterface);
        return true;
    }
 
    // ; 'Travel/Ironing Path'
    pos = comment.find(" 'Travel/Ironing Path'");
    if (pos == 0) {
        set_extrusion_role(erIroning);
        return true;
    }
 
    // ; 'Support (may Stack) Path'
    pos = comment.find(" 'Support (may Stack) Path'");
    if (pos == 0) {
        set_extrusion_role(erSupportMaterial);
        return true;
    }
 
    // ; 'Perimeter Path'
    pos = comment.find(" 'Perimeter Path'");
    if (pos == 0) {
        set_extrusion_role(erExternalPerimeter);
        m_seams_detector.activate(true);
        return true;
    }
 
    // ; 'Pillar Path'
    pos = comment.find(" 'Pillar Path'");
    if (pos == 0) {
        set_extrusion_role(erNone); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        return true;
    }
 
    // ; 'Destring/Wipe/Jump Path'
    pos = comment.find(" 'Destring/Wipe/Jump Path'");
    if (pos == 0) {
        set_extrusion_role(erNone); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        return true;
    }
 
    // ; 'Prime Pillar Path'
    pos = comment.find(" 'Prime Pillar Path'");
    if (pos == 0) {
        set_extrusion_role(erNone); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        return true;
    }
 
    // ; 'Loop Path'
    pos = comment.find(" 'Loop Path'");
    if (pos == 0) {
        set_extrusion_role(erNone); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        return true;
    }
 
    // ; 'Crown Path'
    pos = comment.find(" 'Crown Path'");
    if (pos == 0) {
        set_extrusion_role(erNone); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        return true;
    }
 
    // ; 'Solid Path'
    pos = comment.find(" 'Solid Path'");
    if (pos == 0) {
        set_extrusion_role(erNone);
        return true;
    }
 
    // ; 'Stacked Sparse Infill Path'
    pos = comment.find(" 'Stacked Sparse Infill Path'");
    if (pos == 0) {
        set_extrusion_role(erInternalInfill);
        return true;
    }
 
    // ; 'Sparse Infill Path'
    pos = comment.find(" 'Sparse Infill Path'");
    if (pos == 0) {
        set_extrusion_role(erSolidInfill);
        return true;
    }
 
    // geometry
 
    // layer
    pos = comment.find(" BEGIN_LAYER_");
    if (pos == 0) {
        ++m_layer_id;
        return true;
    }
 
    return false;
}

References Slic3r::erExternalPerimeter, Slic3r::erInternalInfill, Slic3r::erIroning, Slic3r::erNone, Slic3r::erSkirt, Slic3r::erSolidInfill, Slic3r::erSupportMaterial, Slic3r::erSupportMaterialInterface, m_layer_id, m_seams_detector, and set_extrusion_role().

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 register_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

process_M1020()

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

private

{
    int curr_filament_id = get_filament_id(false);
    int curr_extruder_id = get_extruder_id(false);
    if (line.raw().length() > 5) {
        std::string filament_id_str = line.raw().substr(7);
        if (filament_id_str.empty())
            return;
 
        int eid = 0;
        eid = std::stoi(filament_id_str);
        if (eid < 0 || eid > 254) {
            // M1020-1 is a valid gcode line for RepRap Firmwares (used to deselects all tools)
            if ((m_flavor != gcfRepRapFirmware && m_flavor != gcfRepRapSprinter) || eid != -1)
                BOOST_LOG_TRIVIAL(error) << "Invalid M1020 command (" << line.raw() << ").";
        }
        else {
            if (eid >= m_result.filaments_count) {
                BOOST_LOG_TRIVIAL(error) << "Invalid M1020 command (" << line.raw() << ").";
                return;
            }
            // carry the H<nozzle> logical-nozzle id. process_filament_change(int,int) self-gates back
            // to the single-arg model for the single-nozzle fleet, so this is byte-inert for them.
            int   nozzle_id = -1;
            float nozzle_val = 0.f;
            if (line.has_value('H', nozzle_val))
                nozzle_id = static_cast<int>(nozzle_val);
            process_filament_change(eid, nozzle_id);
        }
    }
}

References Slic3r::gcfRepRapFirmware, Slic3r::gcfRepRapSprinter, get_extruder_id(), get_filament_id(), Slic3r::GCodeReader::GCodeLine::has_value(), m_flavor, m_result, process_filament_change(), and Slic3r::GCodeReader::GCodeLine::raw().

Referenced by register_commands().

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

{
    int filament_id = get_filament_id();
    float new_temp;
    if (line.has_value('S', new_temp))
        m_extruder_temps[filament_id] = new_temp;
}

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

Referenced by process_VM104(), and register_commands().

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

{
    //BBS: for Bambu machine ,we both use M106 P1 and M106 to indicate the part cooling fan
    //So we must not ignore M106 P1
    if (!line.has('P') || (line.has('P') && line.p() == 1.0f)) {
        // 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(), m_fan_speed, and Slic3r::GCodeReader::GCodeLine::p().

Referenced by register_commands().

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 register_commands().

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
 
    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 Slic3r::gcfSailfish, m_flavor, process_T(), and Slic3r::GCodeReader::GCodeLine::raw().

Referenced by register_commands().

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

{
    if (m_flavor == gcfKlipper)
        simulate_st_synchronize();
    int filament_id = get_filament_id();
    float new_temp;
    if (line.has_value('R', new_temp)) {
        float val;
        if (line.has_value('T', val)) {
            size_t eid = static_cast<size_t>(val);
            if (eid < m_extruder_temps.size())
                m_extruder_temps[eid] = new_temp;
        }
        else
            m_extruder_temps[filament_id] = new_temp;
    }
    else if (line.has_value('S', new_temp))
        m_extruder_temps[filament_id] = new_temp;
}

References Slic3r::gcfKlipper, get_filament_id(), Slic3r::GCodeReader::GCodeLine::has_value(), m_extruder_temps, m_flavor, and simulate_st_synchronize().

Referenced by process_VM109(), and register_commands().

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
 
    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 register_commands().

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
 
    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 Slic3r::gcfMakerWare, m_flavor, process_T(), and Slic3r::GCodeReader::GCodeLine::raw().

Referenced by register_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

process_M140()

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

private

{
    float new_temp;
    if (line.has_value('S', new_temp))
        m_highest_bed_temp = m_highest_bed_temp < (int)new_temp ? (int)new_temp : m_highest_bed_temp;
}

References Slic3r::GCodeReader::GCodeLine::has_value(), and m_highest_bed_temp.

Referenced by register_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

process_M190()

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

private

{
    if (m_flavor == gcfKlipper)
        simulate_st_synchronize();
    float new_temp;
    if (line.has_value('S', new_temp))
        m_highest_bed_temp = m_highest_bed_temp < (int)new_temp ? (int)new_temp : m_highest_bed_temp;
}

References Slic3r::gcfKlipper, Slic3r::GCodeReader::GCodeLine::has_value(), m_flavor, m_highest_bed_temp, and simulate_st_synchronize().

Referenced by register_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

process_M191()

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

private

{
    float chamber_temp = 0;
    const float wait_chamber_temp_time = 720.0;
    // BBS: when chamber_temp>40,caculate time required for heating
    if (line.has_value('S', chamber_temp) && chamber_temp > 40)
        simulate_st_synchronize(wait_chamber_temp_time);
}

References Slic3r::GCodeReader::GCodeLine::has_value(), and simulate_st_synchronize().

Referenced by register_commands().

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;
 
    // The arrays are slot-major ([slot*2 + mode]); a firmware M201 changes the machine's live
    // limits globally, so write the value into EVERY slot's mode entry. Orca: covering every slot
    // (not a partial range) keeps the per-slot reads in lockstep with the mode-only reads they
    // replaced. Per-mode gating unchanged: Stealth entries only once envelope processing is on.
    auto set_all_slots = [](ConfigOptionFloats &option, size_t mode, float value) {
        for (size_t slot_base = 0; slot_base < option.size(); slot_base += 2)
            set_option_value(option, slot_base + mode, 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_x()) set_all_slots(m_time_processor.machine_limits.machine_max_acceleration_x, i, line.x() * factor);
 
            if (line.has_y()) set_all_slots(m_time_processor.machine_limits.machine_max_acceleration_y, i, line.y() * factor);
 
            if (line.has_z()) set_all_slots(m_time_processor.machine_limits.machine_max_acceleration_z, i, line.z() * factor);
 
            if (line.has_e()) set_all_slots(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::PrintEstimatedStatistics::Normal, Slic3r::set_option_value(), Slic3r::ConfigOptionVector< double >::size(), Slic3r::GCodeReader::GCodeLine::x(), Slic3r::GCodeReader::GCodeLine::y(), and Slic3r::GCodeReader::GCodeLine::z().

Referenced by register_commands().

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 || m_flavor == gcfKlipper) ? 1.0f : MMMIN_TO_MMSEC;
 
    // Slot-major arrays; a firmware M203 changes the live limits globally — write every slot's
    // mode entry (see process_M201). Per-mode gating unchanged.
    auto set_all_slots = [](ConfigOptionFloats &option, size_t mode, float value) {
        for (size_t slot_base = 0; slot_base < option.size(); slot_base += 2)
            set_option_value(option, slot_base + mode, 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_x())
                set_all_slots(m_time_processor.machine_limits.machine_max_speed_x, i, line.x() * factor);
 
            if (line.has_y())
                set_all_slots(m_time_processor.machine_limits.machine_max_speed_y, i, line.y() * factor);
 
            if (line.has_z())
                set_all_slots(m_time_processor.machine_limits.machine_max_speed_z, i, line.z() * factor);
 
            if (line.has_e())
                set_all_slots(m_time_processor.machine_limits.machine_max_speed_e, i, line.e() * factor);
        }
    }
}

References Slic3r::PrintEstimatedStatistics::Count, Slic3r::GCodeReader::GCodeLine::e(), Slic3r::gcfKlipper, 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, MMMIN_TO_MMSEC, Slic3r::PrintEstimatedStatistics::Normal, Slic3r::set_option_value(), Slic3r::ConfigOptionVector< double >::size(), Slic3r::GCodeReader::GCodeLine::x(), Slic3r::GCodeReader::GCodeLine::y(), and Slic3r::GCodeReader::GCodeLine::z().

Referenced by register_commands().

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;
    if (m_flavor == gcfKlipper) {
        if (!line.has_value('S', value)) {
            float travel;
            if (!line.has_value('P', value) || !line.has_value('T', travel))
                return;
            value = std::min(value, travel);
        }
        // Klipper replaces its single live max_accel for print and travel; the profile-clamping
        // setters would diverge from the firmware when custom G-code raises the limit.
        if (value > 0.0f) {
            for (auto& machine : m_time_processor.machines)
                machine.acceleration = machine.travel_acceleration = value;
        }
        return;
    }
    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::gcfKlipper, Slic3r::GCodeReader::GCodeLine::has_value(), m_flavor, m_time_processor, Slic3r::PrintEstimatedStatistics::Normal, set_acceleration(), set_retract_acceleration(), and set_travel_acceleration().

Referenced by register_commands().

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);
 
            if (line.has_value('J', value))
                set_option_value(m_time_processor.machine_limits.machine_max_junction_deviation, i, value);
        }
    }
}

References Slic3r::PrintEstimatedStatistics::Count, Slic3r::GCodeReader::GCodeLine::e(), Slic3r::GCodeReader::GCodeLine::has_e(), Slic3r::GCodeReader::GCodeLine::has_value(), Slic3r::GCodeReader::GCodeLine::has_x(), Slic3r::GCodeReader::GCodeLine::has_y(), Slic3r::GCodeReader::GCodeLine::has_z(), m_time_processor, Slic3r::PrintEstimatedStatistics::Normal, Slic3r::set_option_value(), Slic3r::GCodeReader::GCodeLine::x(), Slic3r::GCodeReader::GCodeLine::y(), and Slic3r::GCodeReader::GCodeLine::z().

Referenced by register_commands().

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(), and m_time_processor.

Referenced by register_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

process_M400()

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

private

{
    float value_s = 0.0;
    float value_p = 0.0;
    const bool has_delay = line.has_value('S', value_s) || line.has_value('P', value_p);
    if (m_flavor != gcfKlipper && !has_delay)
        return;
    value_s += value_p * 0.001;
    // Skip post-print end-gcode dwells so they don't inflate the M73 estimate (see
    // m_skip_end_gcode_delays). Only omits dwell time — no state is updated here.
    if (m_skip_end_gcode_delays && has_delay)
        return;
    simulate_st_synchronize(value_s);
}

References Slic3r::gcfKlipper, Slic3r::GCodeReader::GCodeLine::has_value(), m_flavor, m_skip_end_gcode_delays, and simulate_st_synchronize().

Referenced by register_commands().

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::gcfRepetier, m_cached_position, m_feedrate, m_flavor, and m_start_position.

Referenced by register_commands().

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::gcfRepetier, Slic3r::GCodeReader::GCodeLine::has(), Slic3r::GCodeReader::GCodeLine::has_value(), m_cached_position, m_feedrate, m_flavor, m_start_position, Slic3r::X, and Slic3r::Z.

Referenced by register_commands().

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, MMMIN_TO_MMSEC, Slic3r::set_option_value(), Slic3r::GCodeReader::GCodeLine::x(), Slic3r::GCodeReader::GCodeLine::y(), and Slic3r::GCodeReader::GCodeLine::z().

Referenced by register_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

process_M572()

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

private

{
    float pa_value = m_pressure_advance;
    line.has_value('S', pa_value);
    m_pressure_advance = std::max(0.0f, pa_value);
    // BOOST_LOG_TRIVIAL(debug) << "M572 command: PA set to " << m_pressure_advance;
}

References Slic3r::GCodeReader::GCodeLine::has_value(), and m_pressure_advance.

Referenced by register_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

process_M6211()

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

private

{
    if (boost::algorithm::istarts_with(m_printer_model, "elegoo"))
        process_elegoo_M6211(line);
}

References m_printer_model, and process_elegoo_M6211().

Referenced by register_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

process_M622()

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

private

{
    float value_j;
    if(line.has_value('J',value_j)){
        int interger_j = (int)(std::round(value_j));
        if(interger_j == 1 && !m_measure_g29_time)
            m_measure_g29_time = true;
    }
 
}

References Slic3r::GCodeReader::GCodeLine::has_value(), and m_measure_g29_time.

Referenced by register_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

process_M623()

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

private

{
    if(m_measure_g29_time)
        m_measure_g29_time = false;
}

References m_measure_g29_time.

Referenced by register_commands().

Here is the caller graph for this function:

process_M702()

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

private

{
    int filament_id = get_filament_id();
    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(filament_id));
    }
}

References get_filament_id(), get_filament_unload_time(), Slic3r::GCodeReader::GCodeLine::has(), m_time_processor, and simulate_st_synchronize().

Referenced by register_commands().

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 register_commands().

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 register_commands().

Here is the caller graph for this function:

process_M900()

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

private

{
    float pa_value = m_pressure_advance;
    line.has_value('K', pa_value);
    m_pressure_advance = std::max(0.0f, pa_value);
    // BOOST_LOG_TRIVIAL(debug) << "M900 command: PA set to " << m_pressure_advance;
}

References Slic3r::GCodeReader::GCodeLine::has_value(), and m_pressure_advance.

Referenced by register_commands().

Here is the call graph for this function:

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::OrcaSlicer: { return process_bambuslicer_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); }
    default:                     { return false; }
    }
}

References CraftWare, Cura, ideaMaker, KissSlicer, m_producer, OrcaSlicer, process_bambuslicer_tags(), process_craftware_tags(), process_cura_tags(), process_ideamaker_tags(), process_kissslicer_tags(), process_simplify3d_tags(), 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_SET_PRESSURE_ADVANCE()

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

private

{
    static const std::regex regex(R"(SET_PRESSURE_ADVANCE\s+(?:.*\s+)?ADVANCE\s*=\s*([\d.]+))");
    std::smatch matches;
 
    if (std::regex_search(line.raw(), matches, regex) && matches.size() > 1) {
        float pa_value = 0;
        try {
            pa_value = std::stof(matches[1].str());
        } catch (...) {}
        m_pressure_advance = std::max(0.0f, pa_value);
    }
}

References m_pressure_advance, 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_SET_VELOCITY_LIMIT()

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

private

{
    static const std::regex parameter_pattern(
        R"(\s(VELOCITY|ACCEL|ACCEL_TO_DECEL|SQUARE_CORNER_VELOCITY|MINIMUM_CRUISE_RATIO)\s*=\s*([+]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?)(?=\s|;|$))",
        std::regex::icase);
    const std::string command = line.raw().substr(0, line.raw().find(';'));
    std::vector<std::pair<std::string, float>> parameters;
    for (std::sregex_iterator it(command.begin(), command.end(), parameter_pattern), end; it != end; ++it) {
        float value;
        try {
            value = std::stof((*it)[2].str());
        } catch (const std::exception&) {
            continue;
        }
        if (std::isfinite(value))
            parameters.emplace_back(boost::to_upper_copy((*it)[1].str()), value);
    }
    // Klipper 0.13 converts ACCEL_TO_DECEL only when the line has no MINIMUM_CRUISE_RATIO, and later
    // releases ignore it, so a line carrying both (as Orca writes) is planned with the cruise ratio.
    const bool has_cruise_ratio = std::any_of(parameters.begin(), parameters.end(),
        [](const auto& parameter) { return parameter.first == "MINIMUM_CRUISE_RATIO" && parameter.second >= 0.0f && parameter.second < 1.0f; });
    for (const auto& [name, value] : parameters) {
        for (size_t i = 0; i < m_time_processor.machines.size(); ++i) {
            TimeMachine& machine = m_time_processor.machines[i];
            // Klipper replaces its single live max_accel for print and travel; the profile-clamping
            // setters would diverge from the firmware when custom G-code raises the limit.
            if (name == "ACCEL" && value > 0.0f)
                machine.acceleration = machine.travel_acceleration = value;
            else if (name == "MINIMUM_CRUISE_RATIO" && value >= 0.0f && value < 1.0f) {
                if (machine.klipper_queue_priming && machine.requested_accel_to_decel >= 0.0f)
                    machine.klipper_junction_flush -= 1.0f;
                machine.minimum_cruise_ratio = value;
                machine.requested_accel_to_decel = -1.0f;
            } else if (name == "ACCEL_TO_DECEL" && value > 0.0f && !has_cruise_ratio) {
                if (machine.klipper_queue_priming && machine.requested_accel_to_decel < 0.0f)
                    machine.klipper_junction_flush += 1.0f;
                machine.requested_accel_to_decel = value;
            } else if (name == "SQUARE_CORNER_VELOCITY" && value >= 0.0f) {
                set_option_value(m_time_processor.machine_limits.machine_max_jerk_x, i, value);
                set_option_value(m_time_processor.machine_limits.machine_max_jerk_y, i, value);
            } else if (name == "VELOCITY" && value > 0.0f) {
                set_option_value(m_time_processor.machine_limits.machine_max_speed_x, i, value);
                set_option_value(m_time_processor.machine_limits.machine_max_speed_y, i, value);
            }
        }
    }
}

References Slic3r::GCodeProcessor::TimeMachine::acceleration, Slic3r::GCodeProcessor::TimeMachine::klipper_junction_flush, Slic3r::GCodeProcessor::TimeMachine::klipper_queue_priming, m_time_processor, Slic3r::GCodeProcessor::TimeMachine::minimum_cruise_ratio, Slic3r::GCodeReader::GCodeLine::raw(), Slic3r::GCodeProcessor::TimeMachine::requested_accel_to_decel, Slic3r::set_option_value(), and Slic3r::GCodeProcessor::TimeMachine::travel_acceleration.

Referenced by process_gcode_line().

Here is the call graph for this function:

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(erSkirt);
        return true;
    }
 
    // ; outer perimeter
    pos = cmt.find(" outer perimeter");
    if (pos == 0) {
        set_extrusion_role(erExternalPerimeter);
        m_seams_detector.activate(true);
        return true;
    }
 
    // ; inner perimeter
    pos = cmt.find(" inner perimeter");
    if (pos == 0) {
        set_extrusion_role(erPerimeter);
        return true;
    }
 
    // ; gap fill
    pos = cmt.find(" gap fill");
    if (pos == 0) {
        set_extrusion_role(erGapFill);
        return true;
    }
 
    // ; infill
    pos = cmt.find(" infill");
    if (pos == 0) {
        set_extrusion_role(erInternalInfill);
        return true;
    }
 
    // ; solid layer
    pos = cmt.find(" solid layer");
    if (pos == 0) {
        set_extrusion_role(erSolidInfill);
        return true;
    }
 
    // ; bridge
    pos = cmt.find(" bridge");
    if (pos == 0) {
        set_extrusion_role(erBridgeInfill);
        return true;
    }
 
    // ; internal bridge
    pos = cmt.find(" internal bridge");
    if (pos == 0) {
        set_extrusion_role(erInternalBridgeInfill);
        return true;
    }
 
    // ; support
    pos = cmt.find(" support");
    if (pos == 0) {
        set_extrusion_role(erSupportMaterial);
        return true;
    }
 
    // ; dense support
    pos = cmt.find(" dense support");
    if (pos == 0) {
        set_extrusion_role(erSupportMaterialInterface);
        return true;
    }
 
    // ; prime pillar
    pos = cmt.find(" prime pillar");
    if (pos == 0) {
        set_extrusion_role(erWipeTower);
        return true;
    }
 
    // ; ooze shield
    pos = cmt.find(" ooze shield");
    if (pos == 0) {
        set_extrusion_role(erNone); // Missing mapping
        return true;
    }
 
    // ; raft
    pos = cmt.find(" raft");
    if (pos == 0) {
        set_extrusion_role(erSupportMaterial);
        return true;
    }
 
    // ; internal single extrusion
    pos = cmt.find(" internal single extrusion");
    if (pos == 0) {
        set_extrusion_role(erNone); // 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
    tag = " layer";
    pos = cmt.find(tag);
    if (pos == 0) {
        // 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::erBridgeInfill, Slic3r::erExternalPerimeter, Slic3r::erGapFill, Slic3r::erInternalBridgeInfill, Slic3r::erInternalInfill, Slic3r::erNone, Slic3r::erPerimeter, Slic3r::erSkirt, Slic3r::erSolidInfill, Slic3r::erSupportMaterial, Slic3r::erSupportMaterialInterface, Slic3r::erWipeTower, m_forced_height, m_forced_width, m_layer_id, m_seams_detector, Slic3r::parse_number(), and set_extrusion_role().

Referenced by process_producers_tags().

Here is the call graph for this function:

Here is the caller graph for this function:

process_SYNC()

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

private

{
    float time = 0;
    if (line.has_value('T', time) ) {
        simulate_st_synchronize(time);
    }
}

References Slic3r::GCodeReader::GCodeLine::has_value(), and simulate_st_synchronize().

Referenced by register_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

process_T() [1/3]

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

private

{
    // parse the H<nozzle> logical-nozzle id off the T line. H2C's change_filament template emits
    // `T<fil> H<nozzle>`; the single-nozzle fleet emits a bare `T<fil>` (H absent → -1 → byte-inert
    // via the self-gate).
    int   nozzle_id = -1;
    float nozzle_val = 0.f;
    if (line.has_value('H', nozzle_val))
        nozzle_id = static_cast<int>(nozzle_val);
    process_T(line.cmd(), nozzle_id);
}

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

Referenced by process_M108(), process_M135(), process_T(), process_T(), process_tags(), and register_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

process_T() [2/3]

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

private

{
    // the no-nozzle-context callers (custom-gcode tool-change strings, color-print T parsing) route
    // through the H-less variant; -1 keeps the richer model on its filament-first nozzle fallback.
    process_T(command, -1);
}

References process_T().

Here is the call graph for this function:

process_T() [3/3]

void Slic3r::GCodeProcessor::process_T ( const std::string_view command, int nozzle_id )

private

{
    unsigned int eid = 0;
    auto         ret          = std::from_chars(command.data() + 1, command.data()+command.size(), eid);
    if (std::errc::invalid_argument == ret.ec)
        return;
 
    int curr_filament_id = get_filament_id(false);
    int curr_extruder_id = get_extruder_id(false);
    //TODO: multi switch
    if (command.length() > 1) {
        if (eid < 0 || eid > 254) {
            //BBS: T255, T1000 and T1100 is used as special command for BBL machine and does not cost time. return directly
            // Orca: T1001 (hotend-type detection) and T65535/T65279 (AMS unload virtual-tool selects, paired with
            // M620/M621 S65535/S65279) are firmware opcodes emitted verbatim by BBL machine start/end g-code, not
            // real tool changes - whitelist them so the time estimator stops flagging these valid lines.
            if ((m_flavor == gcfMarlinLegacy || m_flavor == gcfMarlinFirmware) && (command == "Tx" || command == "Tc" || command == "T?" ||
                 eid == 1000 || eid == 1100 || eid == 255 || eid == 1001 || eid == 65279 || eid == 65535))
                return;
 
            // T-1 is a valid gcode line for RepRap Firmwares (used to deselects all tools)
            if ((m_flavor != gcfRepRapFirmware && m_flavor != gcfRepRapSprinter) || eid != -1)
                BOOST_LOG_TRIVIAL(error) << "Invalid T command (" << command << ").";
        }
        else {
            if (eid >= m_result.filaments_count) {
                BOOST_LOG_TRIVIAL(error) << "Invalid T command (" << command << ").";
                return;
            }
            // process_filament_change(int,int) self-gates back to the single-arg model for the
            // single-nozzle fleet, so this call is byte-inert for X1/P1/A1/H2S/A2L.
            process_filament_change(eid, nozzle_id);
        }
    }
}

References Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepRapFirmware, Slic3r::gcfRepRapSprinter, get_extruder_id(), get_filament_id(), m_flavor, m_result, and process_filament_change().

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(ExtrusionEntity::string_to_role(comment.substr(reserved_tag(ETags::Role).length())));
        if (m_extrusion_role == erExternalPerimeter)
            m_seams_detector.activate(true);
        m_processing_start_custom_gcode = (m_extrusion_role == erCustom && m_g1_line_id == 0);
        return;
    }
 
    // ; OBJECT_ID  start
    if (boost::starts_with(comment, " start printing object")) {
        m_object_label_id = get_object_label_id(comment);
        return;
    }
 
    // ; OBJECT_ID  end
    if (boost::starts_with(comment, " stop printing object")) {
        m_object_label_id = -1;
        return;
    }
 
    // ; Z_HEIGHT:
    if (boost::starts_with(comment, " Z_HEIGHT:")) {
        m_print_z = get_z_height(comment);
        return;
    }
 
    // ;Z: -- the layer Z tag non-BBL printers write.  Only read on a belt printer,
    // where the preview labels its layers with it (GCodeViewer::load_as_gcode);
    // elsewhere print_z stays unset, as it always was, so nothing downstream of
    // it changes for other printers.
    if (m_belt_printer && boost::starts_with(comment, "Z:")) {
        m_print_z = get_z_height(comment);
        return;
    }
 
    if (boost::starts_with(comment, " CONFIG_BLOCK_START")) {
        m_in_config_block = true;
        return;
    }
    if (boost::starts_with(comment, " CONFIG_BLOCK_END")) {
        m_in_config_block = false;
        return;
    }
 
    // Belt printer: derive the physical tilt magnitude from the slicing-rotation
    // angle header comment (used to enable the preview's belt view). Only the belt
    // header carries it outside the config block; the config block lists the key
    // for every printer, belt or not.
    if (!m_in_config_block && boost::starts_with(comment, " belt_slice_rotation_angle = ")) {
        try {
            m_result.belt_tilt_angle = std::abs(std::stof(std::string(comment.substr(29))));
        } catch (...) {}
        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 (boost::starts_with(comment, reserved_tag(ETags::Wipe_Tower_Start))) {
        m_wipe_tower = true;
        return;
    }
 
    if (boost::starts_with(comment, reserved_tag(ETags::Wipe_Tower_End))) {
        m_wipe_tower = false;
        m_used_filaments.process_wipe_tower_cache(this);
        return;
    }
 
    // SKIPPABLE region tags. Mark the current section so its time blocks are stamped with the skip
    // type. The shipping time_lapse_gcode template emits these tags fleet-wide, so this parse fires on
    // essentially every slice (m_skippable → true, m_skippable_type → stTimelapse); it only sets
    // internal state and early-returns, so the output is byte-identical until the injector reads the
    // stamps.
    if (boost::starts_with(comment, GCodeProcessor::Skippable_Start_Tag)) {
        m_skippable = true;
        return;
    }
 
    if (boost::starts_with(comment, GCodeProcessor::Skippable_End_Tag)) {
        m_skippable = false;
        m_skippable_type = SkipType::stNone;
        return;
    }
 
    // skippable type
    if (boost::starts_with(comment, GCodeProcessor::Skippable_Type_Tag)) {
        std::string_view type = comment.substr(GCodeProcessor::Skippable_Type_Tag.length());
        set_skippable_type(type);
        return;
    }
 
    //BBS: flush start tag
    if (boost::starts_with(comment, GCodeProcessor::Flush_Start_Tag)) {
        m_flushing = true;
        return;
    }
 
    //BBS: flush end tag
    if (boost::starts_with(comment, GCodeProcessor::Flush_End_Tag)) {
        m_flushing = false;
        return;
    }
 
    if (boost::starts_with(comment, GCodeProcessor::VFlush_Start_Tag)) {
        m_virtual_flushing = true;
        return;
    }
 
    if (boost::starts_with(comment, GCodeProcessor::VFlush_End_Tag)) {
        m_virtual_flushing = false;
        return;
    }
 
    // End gcode marker: skip post-print M400 S/P dwells after this point so the M73 estimate reports
    // print-completion time, not post-print filtration/cooldown. BBS drops the same remainder in
    // calculate_time(is_final).
    if (comment == Machine_End_GCode_Start_Tag) {
        m_skip_end_gcode_delays = true;
        return;
    }
 
    // Orca: Integrate filament consumption for purging performed to an external device and controlled via macros
    // (eg. Happy Hare) in the filament consumption stats.
    if (boost::starts_with(comment, GCodeProcessor::External_Purge_Tag)) {
        static const std::regex numberRegex(R"(\d+\.\d+)");
        std::smatch match;
        std::string line(comment);
        if (std::regex_search(line, match, numberRegex)) {
            int filament_id = get_filament_id();
            float filament_diameter = (static_cast<size_t>(filament_id) < m_result.filament_diameters.size()) ?  m_result.filament_diameters[filament_id] : m_result.filament_diameters.back();
            float filament_radius = 0.5f * filament_diameter;
            float area_filament_cross_section = static_cast<float>(M_PI) * sqr(filament_radius);
 
            float dE = std::stof(match.str());
            float volume_extruded_filament = area_filament_cross_section * dE;
            m_used_filaments.update_flush_per_filament(filament_id, volume_extruded_filament);
        }
        return;
    }
 
    if (!producers_enabled || m_producer == EProducer::OrcaSlicer) {
        // 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;
        }
        // Orca: manual tool change tag
        if (m_manual_filament_change && boost::starts_with(comment, reserved_tag(ETags::Manual_Tool_Change))) {
            std::string_view tool_change_cmd = comment.substr(reserved_tag(ETags::Manual_Tool_Change).length());
            if (boost::starts_with(tool_change_cmd, "T")) {
                process_T(tool_change_cmd);
            }
        }
    }
 
    // color change tag
    if (boost::starts_with(comment, reserved_tag(ETags::Color_Change))) {
        unsigned char filament_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;
                }
                filament_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 (filament_id < m_extruder_colors.size())
            m_extruder_colors[filament_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 (get_filament_id() == filament_id) {
            m_cp_color.current = m_extruder_colors[filament_id];
            store_move_vertex(EMoveType::Color_change);
            CustomGCode::Item item = { static_cast<double>(m_end_position[2]), CustomGCode::ColorChange, filament_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, get_filament_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, get_filament_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;
        return;
    }
}

References Color_Change, Slic3r::Color_change, Slic3r::CustomGCode::ColorChange, Slic3r::CustomGCode::Custom, Custom_Code, Slic3r::Custom_GCode, Slic3r::erCustom, Slic3r::erExternalPerimeter, External_Purge_Tag, Flush_End_Tag, Flush_Start_Tag, get_filament_id(), Slic3r::get_object_label_id(), Slic3r::get_z_height(), Height, Slic3r::is_hex_digit(), Layer_Change, Slic3r::length(), m_belt_printer, m_cp_color, m_end_position, m_extruder_colors, m_extruder_offsets, m_extrusion_role, m_flushing, m_forced_height, m_forced_width, m_g1_line_id, m_in_config_block, m_last_default_color_id, m_layer_id, m_manual_filament_change, m_object_label_id, m_options_z_corrector, M_PI, m_print_z, m_processing_start_custom_gcode, m_producer, m_result, m_seams_detector, m_skip_end_gcode_delays, m_skippable, m_skippable_type, m_used_filaments, m_virtual_flushing, m_wipe_tower, m_wiping, Machine_End_GCode_Start_Tag, Manual_Tool_Change, OrcaSlicer, Slic3r::parse_number(), Slic3r::Pause_Print, Pause_Print, Slic3r::CustomGCode::PausePrint, process_custom_gcode_time(), process_filaments(), process_producers_tags(), process_T(), reserved_tag(), Role, set_extrusion_role(), set_skippable_type(), Skippable_End_Tag, Skippable_Start_Tag, Skippable_Type_Tag, Slic3r::sqr(), Slic3r::stNone, store_move_vertex(), Slic3r::ExtrusionEntity::string_to_role(), VFlush_End_Tag, VFlush_Start_Tag, Width, Wipe_End, Wipe_Start, Wipe_Tower_End, and Wipe_Tower_Start.

Referenced by process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

process_VG1()

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

private

{
    int filament_id = get_filament_id();
    int last_filament_id = get_last_filament_id();
    float filament_diameter = (static_cast<size_t>(filament_id) < m_result.filament_diameters.size()) ? m_result.filament_diameters[filament_id] : m_result.filament_diameters.back();
    float filament_radius = 0.5f * filament_diameter;
    float area_filament_cross_section = static_cast<float>(M_PI) * sqr(filament_radius);
 
    auto absolute_position = [this](Axis axis, const GCodeReader::GCodeLine& lineG1) {
        bool is_relative = (m_global_positioning_type == EPositioningType::Relative);
        if (axis == E)
            is_relative |= (m_e_local_positioning_type == EPositioningType::Relative);
 
        if (lineG1.has(Slic3r::Axis(axis))) {
            float lengthsScaleFactor = (m_units == EUnits::Inches) ? INCHES_TO_MM : 1.0f;
            float ret = lineG1.value(Slic3r::Axis(axis)) * lengthsScaleFactor;
            return is_relative ? m_start_position[axis] + ret : m_origin[axis] + ret;
        }
        else
            return m_start_position[axis];
        };
 
    auto move_type = [this](const AxisCoords& delta_pos) {
        EMoveType type = EMoveType::Noop;
 
        if (m_wiping)
            type = EMoveType::Wipe;
        else if (delta_pos[E] < 0.0f)
            type = (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)
                type = (delta_pos[Z] == 0.0f) ? EMoveType::Unretract : EMoveType::Travel;
            else if (delta_pos[X] != 0.0f || delta_pos[Y] != 0.0f)
                type = EMoveType::Extrude;
        }
        else if (delta_pos[X] != 0.0f || delta_pos[Y] != 0.0f || delta_pos[Z] != 0.0f)
            type = EMoveType::Travel;
 
        return type;
        };
 
    ++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] = absolute_position((Axis)a, line);
    }
 
    // updates feedrate from line, if present
    if (line.has_f())
        m_feedrate = line.f() * MMMIN_TO_MMSEC;
 
    // calculates movement deltas
    float max_abs_delta = 0.0f;
    AxisCoords delta_pos;
    for (unsigned char a = X; a <= E; ++a) {
        delta_pos[a] = m_end_position[a] - m_start_position[a];
        max_abs_delta = std::max<float>(max_abs_delta, std::abs(delta_pos[a]));
    }
 
    // no displacement, return
    if (max_abs_delta == 0.0f)
        return;
 
    EMoveType type = move_type(delta_pos);
    // BBS: now we only support virtual flush
    if (EMoveType::Unretract == type && m_virtual_flushing) {
        int extruder_id = get_extruder_id();
        float volume_flushed_filament = area_filament_cross_section * delta_pos[E];
        if (m_remaining_volume[extruder_id] > volume_flushed_filament)
        {
            m_used_filaments.update_flush_per_filament(last_filament_id, volume_flushed_filament);
            m_remaining_volume[extruder_id] -= volume_flushed_filament;
        }
        else {
            m_used_filaments.update_flush_per_filament(last_filament_id, m_remaining_volume[extruder_id]);
            m_used_filaments.update_flush_per_filament(filament_id, volume_flushed_filament - m_remaining_volume[extruder_id]);
            m_remaining_volume[extruder_id] = 0.f;
        }
    }
 
    if (line.has_f())
        m_feedrate = line.f() * MMMIN_TO_MMSEC;
 
    // time estimate section
    auto move_length = [](const AxisCoords& delta_pos) {
        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;
    };
 
    float distance = move_length(delta_pos);
    assert(distance != 0.0f);
    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);
 
        //BBS: calculeta enter and exit direction
        curr.enter_direction = { static_cast<float>(delta_pos[X]), static_cast<float>(delta_pos[Y]), static_cast<float>(delta_pos[Z]) };
        float norm = curr.enter_direction.norm();
        if (!is_extrusion_only_move(delta_pos))
            curr.enter_direction = curr.enter_direction / norm;
        curr.exit_direction = curr.enter_direction;
        curr.jd_unit_vec = Vec4f(static_cast<float>(delta_pos[X]),
                                 static_cast<float>(delta_pos[Y]),
                                 static_cast<float>(delta_pos[Z]),
                                 static_cast<float>(delta_pos[E])).normalized();
 
        TimeBlock block;
        block.move_type = type;
        // stamp the current SKIPPABLE type onto the block. Stamped stTimelapse inside the fleet-wide
        // time_lapse_gcode regions; byte-inert because nothing reads the stamp until the injector
        // consumes it.
        block.skippable_type = m_skippable_type;
        //BBS: don't calculate travel time into extrusion path, except travel inside start and end gcode.
        block.role = (type != EMoveType::Travel || m_extrusion_role == erCustom) ? m_extrusion_role : erNone;
        block.distance = distance;
        block.g1_line_id = m_g1_line_id;
        block.layer_id = std::max<unsigned int>(1, m_layer_id);
        block.flags.prepare_stage = m_processing_start_custom_gcode;
 
        //BBS: limite the cruise according to centripetal acceleration
        //Only need to handle when both prev and curr segment has movement in x-y plane
        if ((prev.exit_direction(0) != 0.0f || prev.exit_direction(1) != 0.0f) &&
            (curr.enter_direction(0) != 0.0f || curr.enter_direction(1) != 0.0f)) {
            Vec3f v1 = prev.exit_direction;
            v1(2, 0) = 0.0f;
            v1.normalize();
            Vec3f v2 = curr.enter_direction;
            v2(2, 0) = 0.0f;
            v2.normalize();
            float norm_diff = (v2 - v1).norm();
            //BBS: don't need to consider limitation of centripetal acceleration
            //when angle changing is larger than 28.96 degree or two lines are almost collinear.
            //Attention!!! these two value must be same with MC side.
            if (norm_diff < 0.5f && norm_diff > 0.00001f) {
                //BBS: calculate angle
                float dot = v1(0) * v2(0) + v1(1) * v2(1);
                float cross = v1(0) * v2(1) - v1(1) * v2(0);
                float angle = float(atan2(double(cross), double(dot)));
                float sin_theta_2 = sqrt((1.0f - cos(angle)) * 0.5f);
                float r = sqrt(sqr(delta_pos[X]) + sqr(delta_pos[Y])) * 0.5 / sin_theta_2;
                float acc = get_acceleration(static_cast<PrintEstimatedStatistics::ETimeMode>(i));
                curr.feedrate = std::min(curr.feedrate, sqrt(acc * r));
            }
        }
 
        // 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) {
                float axis_max_feedrate = get_axis_max_feedrate(static_cast<PrintEstimatedStatistics::ETimeMode>(i), static_cast<Axis>(a), m_machine_config_idx);
                if (axis_max_feedrate != 0.0f) min_feedrate_factor = std::min<float>(min_feedrate_factor, axis_max_feedrate / curr.abs_axis_feedrate[a]);
            }
        }
        //BBS: update curr.feedrate
        curr.feedrate *= min_feedrate_factor;
        block.feedrate_profile.cruise = 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)));
 
        //BBS
        for (unsigned char a = X; a <= E; ++a) {
            float axis_max_acceleration = get_axis_max_acceleration(static_cast<PrintEstimatedStatistics::ETimeMode>(i), static_cast<Axis>(a), m_machine_config_idx);
            if (acceleration * std::abs(delta_pos[a]) * inv_distance > axis_max_acceleration)
                acceleration = axis_max_acceleration / (std::abs(delta_pos[a]) * inv_distance);
        }
 
        block.acceleration = acceleration;
 
        static const float PREVIOUS_FEEDRATE_THRESHOLD = 0.0001f;
        const bool has_prev_move = !blocks.empty() && prev.feedrate > PREVIOUS_FEEDRATE_THRESHOLD;
 
        // Orca: junction deviation where the firmware uses it (Klipper always, Marlin 2 with M205 J).
        // Negative leaves the classic jerk path below unchanged.
        const float vmax_junction_jd = calc_vmax_junction_deviation(block, prev, curr, has_prev_move,
                                                                    static_cast<PrintEstimatedStatistics::ETimeMode>(i));
        const bool use_junction_deviation = vmax_junction_jd >= 0.0f;
 
        // calculates block exit feedrate. Junction deviation has no per axis jerk floor, so a move is
        // free to start from rest.
        curr.safe_feedrate = use_junction_deviation ? 0.0f : block.feedrate_profile.cruise;
 
        if (!use_junction_deviation) {
            for (unsigned char a = X; a <= E; ++a) {
                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;
 
        // calculates block entry feedrate
        float vmax_junction = use_junction_deviation ? vmax_junction_jd : curr.safe_feedrate;
        if (!use_junction_deviation && has_prev_move) {
            bool prev_speed_larger = prev.feedrate > block.feedrate_profile.cruise;
            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.
                if (a == X) {
                    Vec3f exit_v = prev.feedrate * (prev.exit_direction);
                    if (prev_speed_larger)
                        exit_v *= smaller_speed_factor;
                    Vec3f entry_v = block.feedrate_profile.cruise * (curr.enter_direction);
                    Vec3f jerk_v = entry_v - exit_v;
                    jerk_v = Vec3f(abs(jerk_v.x()), abs(jerk_v.y()), abs(jerk_v.z()));
                    Vec3f max_xyz_jerk_v = get_xyz_max_jerk(static_cast<PrintEstimatedStatistics::ETimeMode>(i));
 
                    for (size_t i = 0; i < 3; i++)
                    {
                        if (jerk_v[i] > max_xyz_jerk_v[i]) {
                            v_factor *= max_xyz_jerk_v[i] / jerk_v[i];
                            jerk_v *= v_factor;
                            limited = true;
                        }
                    }
                }
                else if (a == Y || a == Z) {
                    continue;
                }
                else {
                    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.
                    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));
 
 
                    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.
            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;
        }
 
        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);
    }
 
    // do not save the move
}

References Slic3r::GCodeProcessor::TimeMachine::State::abs_axis_feedrate, Slic3r::GCodeProcessor::TimeBlock::acceleration, Slic3r::angle(), Slic3r::GCodeProcessor::TimeMachine::State::axis_feedrate, Slic3r::GCodeProcessor::TimeMachine::blocks, calc_vmax_junction_deviation(), Slic3r::GCodeProcessor::TimeBlock::calculate_trapezoid(), Slic3r::PrintEstimatedStatistics::Count, Slic3r::cross(), Slic3r::GCodeProcessor::FeedrateProfile::cruise, Slic3r::GCodeProcessor::TimeMachine::curr, Slic3r::GCodeProcessor::TimeBlock::distance, Slic3r::dot(), Slic3r::E, Slic3r::GCodeProcessor::TimeMachine::enabled, Slic3r::GCodeProcessor::TimeMachine::State::enter_direction, Slic3r::GCodeProcessor::FeedrateProfile::entry, Slic3r::erCustom, Slic3r::erNone, Slic3r::GCodeProcessor::FeedrateProfile::exit, Slic3r::GCodeProcessor::TimeMachine::State::exit_direction, Slic3r::Extrude, Slic3r::GCodeProcessor::TimeMachine::extrude_factor_override_percentage, Slic3r::GCodeReader::GCodeLine::f(), Slic3r::GCodeProcessor::TimeMachine::State::feedrate, Slic3r::GCodeProcessor::TimeBlock::feedrate_profile, Slic3r::GCodeProcessor::TimeBlock::flags, Slic3r::GCodeProcessor::TimeBlock::g1_line_id, get_acceleration(), get_axis_max_acceleration(), get_axis_max_feedrate(), get_axis_max_jerk(), get_extruder_id(), get_filament_id(), get_last_filament_id(), get_retract_acceleration(), get_travel_acceleration(), get_xyz_max_jerk(), Slic3r::GCodeReader::GCodeLine::has_f(), Inches, INCHES_TO_MM, Slic3r::GCodeProcessor::TimeMachine::State::jd_unit_vec, Slic3r::GCodeProcessor::TimeBlock::layer_id, m_e_local_positioning_type, m_end_position, m_extrusion_role, m_feedrate, m_g1_line_id, m_global_positioning_type, m_layer_id, m_machine_config_idx, m_origin, M_PI, m_processing_start_custom_gcode, m_remaining_volume, m_result, m_skippable_type, m_start_position, m_time_processor, m_units, m_used_filaments, m_virtual_flushing, m_wiping, Slic3r::max_allowable_speed(), Slic3r::GCodeProcessor::TimeBlock::max_entry_speed, minimum_feedrate(), minimum_travel_feedrate(), MMMIN_TO_MMSEC, Slic3r::GCodeProcessor::TimeBlock::move_type, Slic3r::GCodeProcessor::TimeBlock::Flags::nominal_length, Slic3r::Noop, Slic3r::GCodeProcessor::TimeBlock::Flags::prepare_stage, Slic3r::GCodeProcessor::TimeMachine::prev, Slic3r::GCodeProcessor::TimeBlock::Flags::recalculate, Relative, Slic3r::Retract, Slic3r::GCodeProcessor::TimeBlock::role, Slic3r::GCodeProcessor::TimeBlock::safe_feedrate, Slic3r::GCodeProcessor::TimeMachine::State::safe_feedrate, Slic3r::GCodeProcessor::TimeBlock::skippable_type, Slic3r::sqr(), Slic3r::Travel, Slic3r::Unretract, Slic3r::Wipe, Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by register_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

process_VM104()

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

private

{
    process_M104(line);
}

References process_M104().

Referenced by register_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

process_VM109()

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

private

{
    process_M109(line);
}

References process_M109().

Referenced by register_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

register_commands()

void Slic3r::GCodeProcessor::register_commands ( )

private

{
    // !!! registered command must be upper case
    std::unordered_map<std::string, CommandProcessor::command_handler_t> command_handler_list = {
        {"G0", [this](const GCodeReader::GCodeLine& line) { process_G0(line); }}, // Move
        {"G1", [this](const GCodeReader::GCodeLine& line) { process_G1(line); }}, // Move
        {"G2", [this](const GCodeReader::GCodeLine& line) { process_G2_G3(line, true); }}, // Move
        {"G3", [this](const GCodeReader::GCodeLine& line) { process_G2_G3(line, false); }}, // Move
        {"G4", [this](const GCodeReader::GCodeLine& line) { process_G4(line); }}, // Delay
 
        {"G10", [this](const GCodeReader::GCodeLine& line) { process_G10(line); }}, // Retract
        {"G11", [this](const GCodeReader::GCodeLine& line) { process_G11(line); }}, // Unretract
 
        {"G20", [this](const GCodeReader::GCodeLine& line) { process_G20(line); }}, // Set Units to Inches
        {"G21", [this](const GCodeReader::GCodeLine& line) { process_G21(line); }}, // Set Units to Millimeters
        {"G22", [this](const GCodeReader::GCodeLine& line) { process_G22(line); }}, // Firmware controlled retract
        {"G23", [this](const GCodeReader::GCodeLine& line) { process_G23(line); }}, // Firmware controlled unretract
        {"G28", [this](const GCodeReader::GCodeLine& line) { process_G28(line); }}, // Move to origin
        {"G29", [this](const GCodeReader::GCodeLine& line) { process_G29(line); }},
 
        {"G90", [this](const GCodeReader::GCodeLine& line) { process_G90(line); }}, // Set to Absolute Positioning
        {"G91", [this](const GCodeReader::GCodeLine& line) { process_G91(line); }}, // Set to Relative Positioning
        {"G92", [this](const GCodeReader::GCodeLine& line) { process_G92(line); }}, // Set Position
 
        {"M1", [this](const GCodeReader::GCodeLine& line) { process_M1(line); }}, // Sleep or Conditional stop
 
        {"M82", [this](const GCodeReader::GCodeLine& line) { process_M82(line); }}, // Set extruder to absolute mode
        {"M83", [this](const GCodeReader::GCodeLine& line) { process_M83(line); }}, // Set extruder to relative mode
 
        {"M104", [this](const GCodeReader::GCodeLine& line) { process_M104(line); }}, // Set extruder temperature
        {"M106", [this](const GCodeReader::GCodeLine& line) { process_M106(line); }}, // Set fan speed
        {"M107", [this](const GCodeReader::GCodeLine& line) { process_M107(line); }}, // Disable fan
        {"M108", [this](const GCodeReader::GCodeLine& line) { process_M108(line); }}, // Set tool (Sailfish)
        {"M109", [this](const GCodeReader::GCodeLine& line) { process_M109(line); }}, // Set extruder temperature and wait
 
        {"M132", [this](const GCodeReader::GCodeLine& line) { process_M132(line); }}, // Recall stored home offsets
        {"M135", [this](const GCodeReader::GCodeLine& line) { process_M135(line); }}, // Set tool (MakerWare)
 
        {"M140", [this](const GCodeReader::GCodeLine& line) { process_M140(line); }}, // Set bed temperature
        {"M190", [this](const GCodeReader::GCodeLine& line) { process_M190(line); }}, // Wait bed temperature
        {"M191", [this](const GCodeReader::GCodeLine& line) { process_M191(line); }}, // Wait chamber temperature
 
        {"M201", [this](const GCodeReader::GCodeLine& line) { process_M201(line); }}, // Set max printing acceleration
        {"M203", [this](const GCodeReader::GCodeLine& line) { process_M203(line); }}, // Set maximum feedrate
        {"M204", [this](const GCodeReader::GCodeLine& line) { process_M204(line); }}, // Set default acceleration
        {"M205", [this](const GCodeReader::GCodeLine& line) { process_M205(line); }}, // Advanced settings
        {"M221", [this](const GCodeReader::GCodeLine& line) { process_M221(line); }}, // Set extrude factor override percentage
 
        {"M400", [this](const GCodeReader::GCodeLine& line) { process_M400(line); }}, // BBS delay
        {"M401", [this](const GCodeReader::GCodeLine& line) { process_M401(line); }}, // Repetier: Store x, y and z position
        {"M402", [this](const GCodeReader::GCodeLine& line) { process_M402(line); }}, // Repetier: Go to stored position
        {"M566", [this](const GCodeReader::GCodeLine& line) { process_M566(line); }}, // Set allowable instantaneous speed change
        {"M702", [this](const GCodeReader::GCodeLine& line) { process_M702(line); }}, // Unload the current filament into the MK3 MMU2 unit at the end of print.
        {"M1020", [this](const GCodeReader::GCodeLine& line) { process_M1020(line); }}, // Select Tool
 
// ORCA: Add Pressure Advance visualization support
        {"M900", [this](const GCodeReader::GCodeLine& line) { process_M900(line); }}, // Marlin: Set pressure advance
        {"M572", [this](const GCodeReader::GCodeLine& line) { process_M572(line); }}, // RepRapFirmware/Duet: Set pressure advance
 
        {"T", [this](const GCodeReader::GCodeLine& line) { process_T(line); }}, // Select Tool
        {"SYNC", [this](const GCodeReader::GCodeLine& line) { process_SYNC(line); }}, // SYNC TIME
 
        {"VG1", [this](const GCodeReader::GCodeLine& line) { process_VG1(line); }},
        {"VM104", [this](const GCodeReader::GCodeLine& line) { process_VM104(line); }},
        {"VM109", [this](const GCodeReader::GCodeLine& line) { process_VM109(line); }},
        {"M622", [this](const GCodeReader::GCodeLine& line) { process_M622(line);}},
        {"M623", [this](const GCodeReader::GCodeLine& line) { process_M623(line);}},
        {"M6211", [this](const GCodeReader::GCodeLine& line) { process_M6211(line); }}
    };
 
    std::unordered_set<std::string>early_quit_commands = {
        "T"
    };
 
    auto to_lowercase = [](std::string str)->std::string {
        std::transform(str.begin(), str.end(), str.begin(), [](unsigned char c) {
            return std::tolower(c);
            });
        return str;
        };
 
    for (auto elem : command_handler_list) {
        auto& uppercase_cmd = elem.first;
        auto& handler = elem.second;
        bool early_quit = early_quit_commands.count(uppercase_cmd) > 0;
        m_command_processor.register_command(uppercase_cmd, handler,early_quit);
        if (auto lowercase_cmd = to_lowercase(uppercase_cmd); lowercase_cmd != uppercase_cmd)
            m_command_processor.register_command(lowercase_cmd, handler,early_quit);
    }
}

References m_command_processor, process_G0(), process_G1(), process_G10(), process_G11(), process_G20(), process_G21(), process_G22(), process_G23(), process_G28(), process_G29(), process_G2_G3(), process_G4(), process_G90(), process_G91(), process_G92(), process_M1(), process_M1020(), process_M104(), process_M106(), process_M107(), process_M108(), process_M109(), process_M132(), process_M135(), process_M140(), process_M190(), process_M191(), process_M201(), process_M203(), process_M204(), process_M205(), process_M221(), process_M400(), process_M401(), process_M402(), process_M566(), process_M572(), process_M6211(), process_M622(), process_M623(), process_M702(), process_M82(), process_M83(), process_M900(), process_SYNC(), process_T(), process_VG1(), process_VM104(), and process_VM109().

Referenced by GCodeProcessor().

Here is the call graph for this function:

Here is the caller graph for this function:

reserved_tag()

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

inlinestatic

{ return s_IsBBLPrinter ? Reserved_Tags[static_cast<unsigned char>(tag)] : Reserved_Tags_compatible[static_cast<unsigned char>(tag)]; }

References Reserved_Tags, Reserved_Tags_compatible, and s_IsBBLPrinter.

Referenced by Slic3r::WipeTowerWriter::WipeTowerWriter(), Slic3r::WipeTowerWriter2::WipeTowerWriter2(), Slic3r::GCode::_do_export(), Slic3r::GCode::_extrude(), Slic3r::WipeTowerWriter2::change_analyzer_line_width(), Slic3r::WipeTowerWriter::change_analyzer_line_width(), Slic3r::ProcessLayer::emit_custom_gcode_per_print_z(), Slic3r::WipeTower::finish_block(), Slic3r::WipeTower::finish_block_solid(), Slic3r::WipeTower::finish_layer_new(), Slic3r::CalibPressureAdvancePattern::generate_custom_gcodes(), Slic3r::WipeTowerWriter::line(), Slic3r::WipeTower::only_generate_out_wall(), Slic3r::CalibPressureAdvanceLine::print_pa_lines(), Slic3r::GCode::process_belt_brim_layer(), Slic3r::GCode::process_layer(), process_tags(), Slic3r::WipeTower::ramming(), Slic3r::WipeTowerWriter::rectangle_fill_box(), run_post_process(), Slic3r::WipeTower2::tool_change(), Slic3r::WipeTower::tool_change(), Slic3r::WipeTower::tool_change_new(), Slic3r::GCodeWriter::toolchange_prefix(), Slic3r::WipeTower::toolchange_Wipe(), Slic3r::WipeTower::toolchange_wipe_new(), Slic3r::WipeTowerIntegration::tower_height_tag(), 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_nozzle_volume = std::vector<float>(MAXIMUM_EXTRUDER_NUMBER, 0.f);
 
    m_start_position = { 0.0f, 0.0f, 0.0f, 0.0f };
    m_end_position = { 0.0f, 0.0f, 0.0f, 0.0f };
    m_origin = { 0.0f, 0.0f, 0.0f, 0.0f };
    m_axis_position_known = { false, false, false };
    m_axis_origin_known = { true, true, true };
    m_processing_homing_move = false;
    m_exclusion_volume_path_checker.clear();
    m_cached_position.reset();
    m_wiping = false;
    m_flushing = false;
    m_virtual_flushing = false;
    m_wipe_tower = false;
    // reset SKIPPABLE tracking + the collected ranges (stored on the member; see run_post_process).
    m_skippable = false;
    m_skippable_type = SkipType::stNone;
    m_skippable_blocks.clear();
    // reset the first-pass usage-block state (rebuilt each run_post_process).
    m_filament_blocks.clear();
    m_extruder_blocks.clear();
    m_machine_start_gcode_end_line_id = (unsigned int) (-1);
    m_machine_end_gcode_start_line_id = (unsigned int) (-1);
    m_skip_end_gcode_delays = false;
    m_remaining_volume = std::vector<float>(MAXIMUM_EXTRUDER_NUMBER, 0.f);
 
    m_line_id = 0;
    m_last_line_id = 0;
    m_feedrate = 0.0f;
    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_travel_dist = 0.0f;
    m_fan_speed = 0.0f;
    m_z_offset = 0.0f;
 
    m_extrusion_role = erNone;
 
    m_filament_id = std::vector<unsigned char>(MAXIMUM_EXTRUDER_NUMBER, static_cast<unsigned char>(-1));
    m_last_filament_id = std::vector<unsigned char>(MAXIMUM_EXTRUDER_NUMBER, static_cast<unsigned char>(-1));
    m_extruder_id = static_cast<unsigned char>(-1);
    // clear the multi-nozzle occupancy tracker between slices (the richer hotend-change model's only
    // mutable state). Inert for the single-nozzle fleet (never populated).
    m_nozzle_status_recorder = MultiNozzleUtils::NozzleStatusRecorder{};
    // drop the slot-resolution context and its cached slot; re-seeded per export.
    m_nozzle_group_result.reset();
    m_machine_config_idx = 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_physical_extruder_map.clear();
    m_extruder_max_nozzle_count = { 1 };
 
    // reset pre-heat / pre-cool injector estimator inputs to defaults. Repopulated by apply_config
    // each slice.
    m_filament_types.clear();
    m_nozzle_diameter.clear();
    m_hotend_cooling_rate = m_hotend_heating_rate = { 2.f };
    m_filament_pre_cooling_temp = { 0 };
    m_filament_preheat_temperature_delta.clear();
    m_enable_pre_heating = false;
    m_handle_hotend_as_extruder = false;
    m_has_filament_switcher = false;
 
    m_highest_bed_temp = 0;
 
    m_extruded_last_z = 0.0f;
    m_zero_layer_height = 0.0f;
    m_first_layer_height = 0.0f;
    m_processing_start_custom_gcode = false;
    m_in_config_block = false;
    m_g1_line_id = 0;
    m_layer_id = 0;
    m_cp_color.reset();
    m_mass_locator = nullptr;
 
    m_producer = EProducer::Unknown;
 
    m_time_processor.reset();
    m_used_filaments.reset();
 
    m_result.reset();
    m_result.id = ++s_result_id;
 
    m_last_default_color_id = 0;
 
    m_options_z_corrector.reset();
 
    m_detect_layer_based_on_tag = false;
 
    m_seams_count = 0;
    m_g29_time_added = false;
    m_preheat_time = 0.f;
    m_preheat_steps = 1;
}

References Absolute, Slic3r::erNone, Slic3r::gcfRepRapSprinter, m_axis_origin_known, m_axis_position_known, m_cached_position, m_cp_color, m_detect_layer_based_on_tag, m_e_local_positioning_type, m_enable_pre_heating, m_end_position, m_exclusion_volume_path_checker, m_extruded_last_z, m_extruder_blocks, m_extruder_colors, m_extruder_id, m_extruder_max_nozzle_count, m_extruder_offsets, m_extruder_temps, m_extrusion_role, m_fan_speed, m_feedrate, m_filament_blocks, m_filament_id, m_filament_pre_cooling_temp, m_filament_preheat_temperature_delta, m_filament_types, m_first_layer_height, m_flavor, m_flushing, m_forced_height, m_forced_width, m_g1_line_id, m_g29_time_added, m_global_positioning_type, m_handle_hotend_as_extruder, m_has_filament_switcher, m_height, m_highest_bed_temp, m_hotend_cooling_rate, m_hotend_heating_rate, m_in_config_block, m_last_default_color_id, m_last_filament_id, m_last_line_id, m_layer_id, m_line_id, m_machine_config_idx, m_machine_end_gcode_start_line_id, m_machine_start_gcode_end_line_id, m_mass_locator, m_mm3_per_mm, m_nozzle_diameter, m_nozzle_group_result, m_nozzle_status_recorder, m_nozzle_volume, m_options_z_corrector, m_origin, m_physical_extruder_map, m_preheat_steps, m_preheat_time, m_processing_homing_move, m_processing_start_custom_gcode, m_producer, m_remaining_volume, m_result, m_seams_count, m_skip_end_gcode_delays, m_skippable, m_skippable_blocks, m_skippable_type, m_start_position, m_time_processor, m_travel_dist, m_units, m_used_filaments, m_virtual_flushing, m_width, m_wipe_tower, m_wiping, m_z_offset, m_zero_layer_height, MAXIMUM_EXTRUDER_NUMBER, Millimeters, MIN_EXTRUDERS_COUNT, s_result_id, Slic3r::stNone, and Unknown.

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

Here is the caller graph for this function:

resolve_target_nozzle()

std::optional< MultiNozzleUtils::NozzleInfo > Slic3r::GCodeProcessor::resolve_target_nozzle ( const MultiNozzleUtils::NozzleGroupResultBase & group, int id, int nozzle_id ) const

private

{
    std::optional<MultiNozzleUtils::NozzleInfo> info;
    if (nozzle_id != -1)
        info = group.get_nozzle_from_id(nozzle_id);
    if (!info) {
        auto used_nozzles = group.get_nozzles_for_filament(id);
        if (!used_nozzles.empty())
            info = used_nozzles.front();
    }
    return info;
}

References Slic3r::MultiNozzleUtils::NozzleGroupResultBase::get_nozzle_from_id(), and Slic3r::MultiNozzleUtils::NozzleGroupResultBase::get_nozzles_for_filament().

Referenced by process_filament_change().

Here is the call graph for this function:

Here is the caller graph for this function:

result()

GCodeProcessorResult & Slic3r::GCodeProcessor::result ( )

inline

{ return m_result; }

References m_result.

Referenced by Slic3r::GCodeProcessor::OptionsZCorrector::OptionsZCorrector(), calculate_time(), Slic3r::GCodeProcessor::TimeMachine::calculate_time(), ensure_nozzle_group_result(), Slic3r::Print::reload_gcode_moves(), and Slic3r::ExportLines::synchronize_moves().

Here is the caller graph for this function:

run_post_process()

void Slic3r::GCodeProcessor::run_post_process ( )

private

M104.1: Early Set Hotend Temperature (preheat, and with stealth mode support)

This GCode is used to tell the XL printer the time estimate when a tool will be used next, so that the printer can start preheating the tool in advance.

Parameters

• P - <number> - time in seconds till the temperature S is required (in standard mode)
• Q - <number> - time in seconds till the temperature S is required (in stealth mode) The rest is same as M104

{
    FilePtr in{ boost::nowide::fopen(m_result.filename.c_str(), "rb") };
    if (in.f == nullptr)
        throw Slic3r::RuntimeError(_u8L("G-code 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(_u8L("G-code processor post-process export failed.\nCannot open file for writing.\n"));
 
    std::vector<double> filament_mm(m_result.filaments_count, 0.0);
    std::vector<double> filament_cm3(m_result.filaments_count, 0.0);
    std::vector<double> filament_g(m_result.filaments_count, 0.0);
    std::vector<double> filament_cost(m_result.filaments_count, 0.0);
 
    double filament_total_g = 0.0;
    double filament_total_cost = 0.0;
 
    for (const auto& [id, volume] : m_result.print_statistics.total_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_costs[id]) * 0.001;
        filament_total_g += filament_g[id];
        filament_total_cost += filament_cost[id];
    }
 
    double total_g_wipe_tower = m_print->print_statistics().total_wipe_tower_filament;
 
 
    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 = [this](const std::string& mask, int percent, int time) {
        if(this->m_disable_m73)
            return std::string("");
 
        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 = [this](const std::string& mask, int time) {
        if (this->m_disable_m73)
            return std::string("");
        char line_M73[64];
        sprintf(line_M73, mask.c_str(), std::to_string(time).c_str());
        return std::string(line_M73);
    };
 
    auto format_line_exhaust_fan_control = [](const std::string& mask,int fan_index,int percent) {
        char line_fan[64] = { 0 };
        sprintf(line_fan,mask.c_str(),
            std::to_string(fan_index).c_str(),
            std::to_string(int((percent/100.0)*255)).c_str());
        return std::string(line_fan);
    };
 
    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);
    }
 
    m_result.lines_ends.clear();
    // m_result.lines_ends.emplace_back(std::vector<size_t>());
    GCodeFileWriter writer(out, out_path, m_result.lines_ends, "GCode processor post process export failed.\nIs the disk full?");
    ExportLines export_line(m_result.backtrace_enabled ? ExportLines::EWriteType::ByTime : ExportLines::EWriteType::BySize,
        m_time_processor.machines, writer);
    // The line map holds an entry for each line of the file, and the first pass counted them
    export_line.reserve(m_line_id);
 
    // 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 (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_line.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_line.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];
                        if (!s_IsBBLPrinter)
                            // Orca: compatibility with klipper_estimator
                            sprintf(buf, "; estimated printing time (%s mode) = %s\n",
                                    (mode == PrintEstimatedStatistics::ETimeMode::Normal) ? "normal" : "silent",
                                    get_time_dhms(machine.time).c_str());
                        else {
                            sprintf(buf, "; model printing time: %s; total estimated time: %s\n",
                                    get_time_dhms(machine.time - machine.prepare_time).c_str(), get_time_dhms(machine.time).c_str());
                        }
                        export_line.append_line(buf);
                    }
                }
                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.prepare_time).c_str());
                        export_line.append_line(buf);
                        processed = true;
                    }
                }
            }
            // Orca: write total layer number, this is used by Bambu printers only as of now
            else if (line == reserved_tag(ETags::Total_Layer_Number_Placeholder)) {
                char buf[128];
                sprintf(buf, "; total layer number: %u\n", m_layer_id);
                export_line.append_line(buf);
                processed = true;
            }
        }
 
        return processed;
    };
 
    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, PrintStatistics::FilamentUsedMmMask, filament_mm);
        ret |= process_tag(gcode_line, PrintStatistics::FilamentUsedGMask, filament_g);
        ret |= process_tag(gcode_line, PrintStatistics::TotalFilamentUsedGMask, { filament_total_g });
        ret |= process_tag(gcode_line, PrintStatistics::FilamentUsedCm3Mask, filament_cm3);
        ret |= process_tag(gcode_line, PrintStatistics::FilamentCostMask, filament_cost);
        ret |= process_tag(gcode_line, PrintStatistics::TotalFilamentCostMask, { filament_total_cost });
        return ret;
    };
 
    // Process inline placeholders (print_time_*, used_filament_length and the print statistics known only after export)
    auto process_inline_placeholders = [&](std::string& gcode_line) {
        bool processed = false;
        // Every inline placeholder contains '@', so a line without one has nothing to replace.
        if (gcode_line.find('@') == std::string::npos)
            return processed;
 
        auto replace_tag = [&gcode_line, &processed](ETags tag, const std::string& value) {
            const std::string& placeholder = reserved_tag(tag);
            size_t pos = gcode_line.find(placeholder);
            while (pos != std::string::npos) {
                gcode_line.replace(pos, placeholder.length(), value);
                processed = true;
                pos = gcode_line.find(placeholder, pos + value.length());
            }
        };
 
        double print_time_total_sec = m_time_processor.machines[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Normal)].time;
        if (print_time_total_sec < 0.0)
            print_time_total_sec = 0.0;
 
        int total_seconds = static_cast<int>(print_time_total_sec);
        int print_time_day = total_seconds / 86400;
        int day_remainder_seconds = total_seconds % 86400;
        int print_time_hour = day_remainder_seconds / 3600;
        int print_time_minute = (day_remainder_seconds % 3600) / 60;
        int print_time_sec = day_remainder_seconds % 60;
 
        double total_filament_mm = 0.0;
        for (const auto& mm : filament_mm) {
            total_filament_mm += mm;
        }
 
        replace_tag(ETags::Print_Time_Total_Sec_Placeholder, Slic3r::float_to_string_decimal_point(print_time_total_sec, 2));
        replace_tag(ETags::Print_Time_Day_Placeholder, std::to_string(print_time_day));
        replace_tag(ETags::Print_Time_Hour_Placeholder, std::to_string(print_time_hour));
        replace_tag(ETags::Print_Time_Minute_Placeholder, std::to_string(print_time_minute));
        replace_tag(ETags::Print_Time_Sec_Placeholder, std::to_string(print_time_sec));
        replace_tag(ETags::Used_Filament_Length_Placeholder,
                    Slic3r::float_to_string_decimal_point(total_filament_mm / 1000.0, 2)); // Convert mm to m
        // Same values as the print statistics that filename_format gets (PrintStatistics::config(), filled in by
        // update_print_estimated_stats() in GCode.cpp), which runs only after this post-processing.
        replace_tag(ETags::Normal_Print_Time_Placeholder, get_time_dhm(PrintEstimatedStatistics::ETimeMode::Normal));
        replace_tag(ETags::Silent_Print_Time_Placeholder, is_stealth_time_estimator_enabled() ?
                                                              get_time_dhm(PrintEstimatedStatistics::ETimeMode::Stealth) :
                                                              short_time("N/A"));
        const double total_cost = filament_total_cost + m_print->config().time_cost.value * print_time_total_sec / 3600.0;
        replace_tag(ETags::Total_Weight_Placeholder, Slic3r::float_to_string_decimal_point(filament_total_g, 2));
        replace_tag(ETags::Total_Cost_Placeholder, Slic3r::float_to_string_decimal_point(total_cost, 2));
        replace_tag(ETags::Total_Wipe_Tower_Cost_Placeholder,
                    Slic3r::float_to_string_decimal_point(m_print->print_statistics().total_wipe_tower_cost, 2));
        replace_tag(ETags::Total_Wipe_Tower_Filament_Placeholder,
                    Slic3r::float_to_string_decimal_point(m_print->print_statistics().total_wipe_tower_filament, 2));
 
        return processed;
    };
 
    // 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_move = [
        // 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,
        &self = std::as_const(m_time_processor),
        // Caches, to be modified
        &g1_times_cache_it, &last_exported_main, &last_exported_stop,
        // String output
        &export_line]
        (const size_t g1_lines_counter) {
        for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
            const TimeMachine& machine = self.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_line.append_line(format_line_M73_main(machine.line_m73_main_mask.c_str(),
                            to_export_main.first, to_export_main.second), true);
                        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_line.append_line(format_line_M73_stop_int(machine.line_m73_stop_mask.c_str(), to_export_stop), true);
                                    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_line.append_line(format_line_M73_stop_int(machine.line_m73_stop_mask.c_str(), to_export_stop), true);
                                    else
                                        export_line.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)), true);
 
                                    last_exported_stop[i] = to_export_stop;
                                }
                            }
                        }
                    }
                }
            }
        }
    };
 
    // Orca: track the current layer during the post-processing pass so that preheat M104s emitted
    // for tool changes on the first layer use the correct first-layer temperature. The member
    // m_layer_id is populated during the analysis pass and ends at the total layer count, so it
    // cannot be used here — it would always select the "other layers" temperature for multi-layer
    // prints.
    unsigned int current_layer_id = 0;
 
    // add lines M104 to exported gcode
    auto process_line_T = [this, &export_line, &current_layer_id](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);
 
        int tool_number = -1;
        if (!parse_number(std::string_view(cmd).substr(1), tool_number)){
            // invalid T<n> command, such as the "TIMELAPSE_TAKE_FRAME" gcode, just ignore
            return;
        }
        if (cmd.size() >= 2) {
            if (tool_number != -1) {
                if (tool_number < 0 || (int)m_filament_nozzle_temp.size() <= tool_number) {
                    // found an invalid value, clamp it to a valid one
                    tool_number = std::clamp<int>(0, m_filament_nozzle_temp.size() - 1, tool_number);
                    // emit warning
                    std::string warning = _u8L("The G-code post-processor encountered an invalid tool change, maybe from custom G-code:");
                    warning += "\n> ";
                    warning += gcode_line;
                    warning += _u8L("Generated M104 lines may be incorrect.");
                    BOOST_LOG_TRIVIAL(error) << warning;
                    // Orca todo
                    if (m_print != nullptr)
                        m_print->active_step_add_warning(PrintStateBase::WarningLevel::CRITICAL, warning);
                }
                export_line.insert_lines(
                    backtrace, cmd,
                    // line inserter
                    [tool_number, this, &current_layer_id](unsigned int id, const std::vector<float>& time_diffs) {
                        // Orca: use the locally-tracked layer index (current_layer_id) rather than
                        // the stale m_layer_id from the analysis pass. current_layer_id == 0 means
                        // we haven't reached the first ;LAYER_CHANGE marker yet (e.g. tool change
                        // inside start gcode); == 1 means we are inside the first printed layer.
                        // Both cases should use the first-layer nozzle temperature.
                        const int temperature = int(current_layer_id > 1 ? m_filament_nozzle_temp[tool_number] :
                                                                         m_filament_nozzle_temp_first_layer[tool_number]);
                        // Orca: M104.1 for XL printers, I can't find the documentation for this so I copied the C++ comments from
                        // Prusa-Firmware-Buddy here
                        if (this->m_is_XL_printer) {
                            std::string out = "M104.1 T" + std::to_string(tool_number);
                            if (time_diffs.size() > 0)
                                out += " P" + std::to_string(int(std::round(time_diffs[0])));
                            if (time_diffs.size() > 1)
                                out += " Q" + std::to_string(int(std::round(time_diffs[1])));
                            out += " S" + std::to_string(temperature) + "\n";
                            return out;
                        } else {
                            const int real_tool = tool_number < m_physical_extruder_map.size() ? m_physical_extruder_map[tool_number] : tool_number;
                            std::string comment = "preheat T" + std::to_string(real_tool) +
                                                " time: " + std::to_string((int) std::round(time_diffs[0])) + "s";
                            return GCodeWriter::set_temperature(temperature, this->m_flavor, false, real_tool, comment);
                        }
                    },
                    // 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) {
                                if (static_cast<int>(val) == (tool_number < m_physical_extruder_map.size() ? m_physical_extruder_map[tool_number] : tool_number))
                                    return std::string("; removed M104\n");
                            }
                        }
                        return line;
                    }
                );
            }
        }
    };
 
    // Orca: freshly collect SKIPPABLE ranges each post-process pass. The ranges are stored on the
    // member (rather than a local) so the injection pass can consume them, hence the clear here to
    // avoid stale ranges on re-invocation.
    m_skippable_blocks.clear();
 
    unsigned int line_id = 0;
    // Backtrace data for Tx gcode lines
    const ExportLines::Backtrace backtrace_T = { m_preheat_time, m_preheat_steps };
    // 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;
 
    // First-pass usage-block builder. Reconstructs, from the emitted g-code, which filament/extruder
    // is active over each output-line span so the pre-heat injector can locate idle-hotend windows.
    // Gated behind m_enable_pre_heating: the byte-frozen fleet (X1/P1/A1/H2S, which never set the
    // flag) runs none of this. It is pure data construction — it only fills m_filament_blocks /
    // m_extruder_blocks / m_machine_*_gcode_*_line_id and never touches the exported g-code, so even
    // the enable_pre_heating fleet stays byte-identical (nothing reads the blocks until the injection
    // pass). The wipe tower emits the NOZZLE_CHANGE_* (ramming) and CP_TOOLCHANGE_WIPE markers this
    // builder keys off; the MACHINE_*_GCODE_* markers come from the machine g-code templates.
    m_filament_blocks.clear();
    m_extruder_blocks.clear();
    m_machine_start_gcode_end_line_id = (unsigned int) (-1);
    m_machine_end_gcode_start_line_id = (unsigned int) (-1);
    // the first use of an extruder emits no nozzle-change tag, so seed a dummy leading block
    if (m_enable_pre_heating)
        m_extruder_blocks.push_back(ExtruderPreHeating::ExtruderUsageBlcok());
    // Resolve the concrete layer-aware grouping: get_nozzle_id/get_extruder_id are not on the base
    // interface. May be null on slicing paths that never populated it, in which case the builder
    // degrades to empty blocks (every dereference below is nil-guarded).
    auto layered_ngr = std::dynamic_pointer_cast<MultiNozzleUtils::LayeredNozzleGroupResult>(m_result.nozzle_group_result);
    ExtruderPreHeating::ExtruderUsageBlcok temp_construct_block; // constructed, then pushed after init
 
    // Append a per-filament usage block at a filament change.
    auto handle_filament_change = [&](int filament_id, int cur_line_id, int nozzle_id) {
        // Skip filament changes emitted inside the machine start / end gcode. One forward pass assigns
        // the tag ids and tests them in the same loop, so inside the start gcode the end tag is unseen
        // and the id still holds the sentinel. That is why the first clause tests == and the second !=.
        if ((m_machine_start_gcode_end_line_id == (unsigned int) (-1) && (unsigned int) (cur_line_id) < m_machine_start_gcode_end_line_id) ||
            (m_machine_end_gcode_start_line_id != (unsigned int) (-1) && (unsigned int) (cur_line_id) > m_machine_end_gcode_start_line_id))
            return;
        if (!m_filament_blocks.empty())
            m_filament_blocks.back().upper_gcode_id = cur_line_id;
        if (nozzle_id == -1 && layered_ngr)
            nozzle_id = layered_ngr->get_nozzle_id(filament_id, current_layer_id);
        int extruder_id = 0;
        if (layered_ngr) {
            // Orca: nil-guard the optional nozzle lookup.
            if (auto nozzle_info = layered_ngr->get_nozzle_from_id(nozzle_id))
                extruder_id = nozzle_info->extruder_id;
        }
        m_filament_blocks.emplace_back(filament_id, extruder_id, nozzle_id, cur_line_id, (unsigned int) (-1));
    };
 
    // Parse a "; NOZZLE_CHANGE_* OF<of> NF<nf> ON<on> NN<nn>" line. The get_nozzle_from_id optional
    // is nil-guarded here.
    auto handle_nozzle_change_line = [&](const std::string& line, int& old_filament, int& next_filament, int& extruder_id, int gcode_id, int& old_nozzle_id, int& new_nozzle_id) -> bool {
        std::regex re(R"(OF(\d+)\s+NF(\d+)\s+ON(\d+)\s+NN(\d+))");
        std::smatch match;
        if (!std::regex_search(line, match, re))
            return false;
        old_filament  = std::stoi(match[1]);
        next_filament = std::stoi(match[2]);
        old_nozzle_id = std::stoi(match[3]);
        new_nozzle_id = std::stoi(match[4]);
        std::optional<MultiNozzleUtils::NozzleInfo> nozzle_info;
        if (layered_ngr)
            nozzle_info = layered_ngr->get_nozzle_from_id(new_nozzle_id);
        extruder_id = nozzle_info ? nozzle_info->extruder_id : -1;
        return true;
    };
 
    // Parse a "; CP_TOOLCHANGE_WIPE CT<contact> [FL<first_layer>]" line.
    auto handle_toolchange_wipe_line = [](const std::string& line, bool& is_contact, bool& is_first_layer) -> bool {
        std::regex re(R"(CT(\d)(?:\s+FL(\d))?)");
        std::smatch match;
        if (!std::regex_search(line, match, re))
            return false;
        is_contact     = std::stoi(match[1]) != 0;
        is_first_layer = match[2].matched ? std::stoi(match[2]) != 0 : false;
        return true;
    };
 
    // Inspect one output line and update the usage-block state. Called only when m_enable_pre_heating;
    // never modifies gcode_line.
    auto build_usage_blocks = [&](const std::string& gcode_line, int line_id) {
        using GLine = GCodeReader::GCodeLine;
        // leading-whitespace count (GCodeReader::skip_whitespaces is private; is_whitespace == space|tab)
        size_t skips = 0;
        while (skips < gcode_line.size() && (gcode_line[skips] == ' ' || gcode_line[skips] == '\t'))
            ++skips;
 
        // whole-line machine start / end gcode markers
        if (gcode_line.size() > 1 && gcode_line.front() == ';') {
            std::string_view tag(gcode_line);
            while (!tag.empty() && (tag.back() == '\n' || tag.back() == '\r'))
                tag.remove_suffix(1);
            tag.remove_prefix(1); // strip leading ';'
            if (tag == Machine_Start_GCode_End_Tag) { m_machine_start_gcode_end_line_id = line_id; return; }
            if (tag == Machine_End_GCode_Start_Tag) { m_machine_end_gcode_start_line_id = line_id; return; }
        }
 
        // filament-change commands: T<fid>, ;VT<fid>, M1020 S<fid>, each optionally " H<nozzle_id>"
        if (GLine::cmd_starts_with(gcode_line, "T")) {
            std::istringstream str(gcode_line.substr(skips + 1)); // skip whitespace and 'T'
            int fid;
            str >> fid;
            if (!str.fail() && 0 <= fid && fid < 255) {
                int nozzle_id = -1; char param;
                while (str >> param) { if (param == 'H') { if (!(str >> nozzle_id)) BOOST_LOG_TRIVIAL(warning) << "Invalid nozzle id format in T command: " << gcode_line; break; } }
                handle_filament_change(fid, line_id, nozzle_id);
            }
            return;
        }
        if (GLine::cmd_starts_with(gcode_line, ";VT")) {
            std::istringstream str(gcode_line.substr(skips + 3)); // skip whitespace and ";VT"
            int fid;
            str >> fid;
            if (!str.fail() && 0 <= fid && fid < 255) {
                int nozzle_id = -1; char param;
                while (str >> param) { if (param == 'H') { if (!(str >> nozzle_id)) BOOST_LOG_TRIVIAL(warning) << "Invalid nozzle id format in VT command: " << gcode_line; break; } }
                handle_filament_change(fid, line_id, nozzle_id);
            }
            return;
        }
        if (GLine::cmd_starts_with(gcode_line, "M1020")) {
            size_t s_pos = gcode_line.find('S');
            if (s_pos != std::string::npos) {
                std::istringstream str(gcode_line.substr(s_pos + 1));
                int fid;
                str >> fid;
                if (!str.fail() && 0 <= fid && fid < 255) {
                    int nozzle_id = -1; char param;
                    while (str >> param) { if (param == 'H') { if (!(str >> nozzle_id)) BOOST_LOG_TRIVIAL(warning) << "Invalid nozzle id format in M1020 command: " << gcode_line; break; } }
                    handle_filament_change(fid, line_id, nozzle_id);
                }
            }
            return;
        }
 
        // extruder usage blocks are delimited by the NOZZLE_CHANGE_START/END markers
        if (GLine::cmd_starts_with(gcode_line, (std::string(";") + Nozzle_Change_Start_Tag).c_str())) {
            int prev_filament{-1}, next_filament{-1}, extruder_id{-1}, prev_nozzle_id{-1}, next_nozzle_id{-1};
            handle_nozzle_change_line(gcode_line, prev_filament, next_filament, extruder_id, line_id, prev_nozzle_id, next_nozzle_id);
            if (!m_extruder_blocks.empty())
                m_extruder_blocks.back().initialize_step_2(line_id);
            return;
        }
        if (GLine::cmd_starts_with(gcode_line, (std::string(";") + Nozzle_Change_End_Tag).c_str())) {
            int prev_filament{-1}, next_filament{-1}, extruder_id{-1}, prev_nozzle_id{-1}, next_nozzle_id{-1};
            handle_nozzle_change_line(gcode_line, prev_filament, next_filament, extruder_id, line_id, prev_nozzle_id, next_nozzle_id);
            if (!m_extruder_blocks.empty())
                m_extruder_blocks.back().initialize_step_3(line_id, prev_filament, line_id, prev_nozzle_id);
            temp_construct_block.initialize_step_1(extruder_id, line_id, next_filament, next_nozzle_id);
            m_extruder_blocks.emplace_back(temp_construct_block);
            temp_construct_block.reset();
            return;
        }
        // CP_TOOLCHANGE_WIPE records whether the upcoming tower wipe contacts the model / is on the
        // first layer, which later suppresses pre-cooling before the tower.
        if (GLine::cmd_starts_with(gcode_line, (std::string(";") + Toolchange_Wipe_Tag).c_str())) {
            bool is_contact = false, is_first_layer = false;
            handle_toolchange_wipe_line(gcode_line, is_contact, is_first_layer);
            if (!m_extruder_blocks.empty())
                m_extruder_blocks.back().ignore_cooling_before_tower = is_contact || is_first_layer;
            return;
        }
    };
 
    {
        // 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(_u8L("G-code 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);
 
                it = it_end;
                // append EOL.
                if (it != it_bufend && *it == '\r') {
                    gcode_line += *it++;
                }
                if (it != it_bufend && *it == '\n') {
                    gcode_line += *it++;
                }
 
                if (eol) {
                    ++line_id;
                    const unsigned int internal_g1_lines_counter = export_line.update(gcode_line, line_id, g1_lines_counter);
                    // Orca: track the current layer for preheat temperature selection.
                    // The line is ";" + reserved_tag(Layer_Change) + EOL; match it independent of
                    // BBL vs. compatible flavor (which differ in the tag text).
                    if (gcode_line.size() > 1 && gcode_line.front() == ';') {
                        std::string_view tag_line(gcode_line);
                        // strip trailing CR/LF
                        while (!tag_line.empty() && (tag_line.back() == '\n' || tag_line.back() == '\r'))
                            tag_line.remove_suffix(1);
                        // strip leading ';'
                        tag_line.remove_prefix(1);
                        if (tag_line == reserved_tag(ETags::Layer_Change))
                            ++current_layer_id;
                        // Collect [start,end] output-line-id ranges of each SKIPPABLE region for the
                        // pre-heat injector. The `!empty()` guard on END avoids dereferencing .back()
                        // on an empty vector. The shipping time_lapse_gcode template emits SKIPPABLE_*
                        // fleet-wide, so this records ~100 ranges per timelapse-on slice; output stays
                        // byte-identical because it only records line-ids (comment lines pass through
                        // unmodified) and nothing reads the ranges until the injection pass.
                        else if (tag_line == Skippable_Start_Tag)
                            m_skippable_blocks.emplace_back(line_id, 0);
                        else if (tag_line == Skippable_End_Tag && !m_skippable_blocks.empty())
                            m_skippable_blocks.back().second = line_id;
                    }
                    // Build the first-pass usage blocks off the raw line (before any placeholder
                    // replacement/clear below). Gated on m_enable_pre_heating so the byte-frozen fleet
                    // executes nothing; pure data construction, so the output is untouched regardless.
                    if (m_enable_pre_heating)
                        build_usage_blocks(gcode_line, line_id);
                    // replace placeholder lines
                    bool processed = process_placeholders(gcode_line);
                    if (processed)
                        gcode_line.clear();
                    if (!processed)
                        processed = process_used_filament(gcode_line);
                    if (!gcode_line.empty())
                        process_inline_placeholders(gcode_line);
                    if (!processed && !is_temporary_decoration(gcode_line)) {
                        if (GCodeReader::GCodeLine::cmd_is(gcode_line, "G0") || GCodeReader::GCodeLine::cmd_is(gcode_line, "G1")) {
                            export_line.append_line(gcode_line);
                            // add lines M73 where needed
                            process_line_move(g1_lines_counter++);
                            gcode_line.clear();
                        }
                        else if (GCodeReader::GCodeLine::cmd_is(gcode_line, "G2") || GCodeReader::GCodeLine::cmd_is(gcode_line, "G3")) {
                            export_line.append_line(gcode_line);
                            // add lines M73 where needed
                            process_line_move(g1_lines_counter + internal_g1_lines_counter);
                            g1_lines_counter += (1 + internal_g1_lines_counter);
                            gcode_line.clear();
                        }
                        else if (GCodeReader::GCodeLine::cmd_is(gcode_line, "G28")) {
                            ++g1_lines_counter;
                        }
                        else if (m_result.backtrace_enabled && GCodeReader::GCodeLine::cmd_starts_with(gcode_line, "T")) {
                            // add lines M104 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_line.append_line(gcode_line);
                    export_line.write(1.1f * max_backtrace_time);
                    gcode_line.clear();
                }
            }
            if (eof)
                break;
        }
    }
 
    // Close out the usage blocks after the stream. The trailing filament block runs to the end-gcode
    // start; the seeded first extruder block gets its start filled from the first filament, and the
    // open last extruder block is completed with the trailing filament/nozzle. Gated + pure data —
    // no effect on the exported g-code.
    if (m_enable_pre_heating) {
        if (!m_filament_blocks.empty())
            m_filament_blocks.back().upper_gcode_id = m_machine_end_gcode_start_line_id;
 
        if (!m_extruder_blocks.empty()) {
            int first_filament = 0;
            int last_filament  = 0;
            if (!m_filament_blocks.empty()) {
                first_filament = m_filament_blocks.front().filament_id;
                last_filament  = m_filament_blocks.back().filament_id;
            }
            {
                int extruder_id = -1;
                std::optional<MultiNozzleUtils::NozzleInfo> nozzle_info;
                if (layered_ngr)
                    nozzle_info = layered_ngr->get_first_nozzle_for_filament(first_filament);
                if (nozzle_info)
                    extruder_id = nozzle_info->extruder_id;
                int start_nozzle_id = nozzle_info ? nozzle_info->group_id : -1;
                m_extruder_blocks.front().initialize_step_1(extruder_id, m_machine_start_gcode_end_line_id, first_filament, start_nozzle_id);
            }
            m_extruder_blocks.back().initialize_step_2(m_machine_end_gcode_start_line_id);
            int last_nozzle_id = -1;
            if (!m_filament_blocks.empty())
                last_nozzle_id = m_filament_blocks.back().nozzle_id;
            m_extruder_blocks.back().initialize_step_3(m_machine_end_gcode_start_line_id, last_filament, m_machine_end_gcode_start_line_id, last_nozzle_id);
        }
    }
 
    export_line.flush();
 
    out.close();
    in.close();
 
    const std::string result_filename = m_result.filename;
    export_line.synchronize_moves(m_result);
 
    // Rebase the first-pass usage/skippable blocks + the machine start/end gcode line ids from the
    // pre-M73 input-line-id space into the final output-line-id space, so they share one coordinate
    // system with the moves (whose gcode_ids synchronize_moves() just rebased) and with the
    // second-pass line_id. This is the block-side counterpart to synchronize_moves, which does the
    // same rebasing for the moves. Gated on m_enable_pre_heating so the byte-frozen fleet skips it
    // entirely; on the flag-true fleet it writes only the (inert) block members, so the emitted
    // g-code is unaffected either way.
    if (m_enable_pre_heating) {
        auto remap = [&export_line](unsigned int& id) { id = export_line.remap_gcode_id(id); };
        for (auto& b : m_filament_blocks) {
            remap(b.lower_gcode_id);
            remap(b.upper_gcode_id);
        }
        for (auto& b : m_extruder_blocks) {
            remap(b.start_id);
            remap(b.end_id);
            remap(b.post_extrusion_start_id);
            remap(b.post_extrusion_end_id);
        }
        for (auto& b : m_skippable_blocks) {
            remap(b.first);
            remap(b.second);
        }
        remap(m_machine_start_gcode_end_line_id);
        remap(m_machine_end_gcode_start_line_id);
    }
 
    if (rename_file(out_path, result_filename))
        // TRN %1% is the temporary file path, %2% the output file path.
        throw Slic3r::RuntimeError(Slic3r::format(_u8L("Failed to rename the output G-code file from %1% to %2%.\nIs %1% locked?"),
                                                  out_path, result_filename) + '\n');
}

References _u8L, Slic3r::ExportLines::append_line(), Slic3r::ExportLines::BySize, Slic3r::ExportLines::ByTime, Slic3r::FilePtr::close(), Slic3r::GCodeReader::GCodeLine::cmd_is(), Slic3r::GCodeReader::GCodeLine::cmd_starts_with(), Slic3r::PrintEstimatedStatistics::Count, Slic3r::PrintStateBase::CRITICAL, Slic3r::GCodeProcessor::TimeMachine::enabled, Estimated_Printing_Time_Placeholder, ExportLines, Slic3r::GCodeReader::GCodeLine::extract_cmd(), Slic3r::FilePtr::f, Slic3r::filament_cost(), Slic3r::PrintStatistics::FilamentCostMask, Slic3r::PrintStatistics::FilamentUsedCm3Mask, Slic3r::PrintStatistics::FilamentUsedGMask, Slic3r::PrintStatistics::FilamentUsedMmMask, First_Line_M73_Placeholder, Slic3r::float_to_string_decimal_point(), Slic3r::ExportLines::flush(), Slic3r::format(), Slic3r::GCodeProcessor::TimeMachine::g1_times_cache, get_time_dhm(), Slic3r::get_time_dhms(), Slic3r::GCodeReader::GCodeLine::has_value(), Slic3r::ExtruderPreHeating::ExtruderUsageBlcok::initialize_step_1(), Slic3r::ExportLines::insert_lines(), is_stealth_time_estimator_enabled(), Last_Line_M73_Placeholder, Layer_Change, Slic3r::GCodeProcessor::TimeMachine::line_m73_main_mask, Slic3r::GCodeProcessor::TimeMachine::line_m73_stop_mask, m_disable_m73, m_enable_pre_heating, m_extruder_blocks, m_filament_blocks, m_filament_nozzle_temp, m_filament_nozzle_temp_first_layer, m_flavor, m_is_XL_printer, m_layer_id, m_line_id, m_machine_end_gcode_start_line_id, m_machine_start_gcode_end_line_id, m_physical_extruder_map, M_PI, m_preheat_steps, m_preheat_time, m_print, m_result, m_skippable_blocks, m_time_processor, Machine_End_GCode_Start_Tag, Machine_Start_GCode_End_Tag, Slic3r::PrintEstimatedStatistics::Normal, Normal_Print_Time_Placeholder, Nozzle_Change_End_Tag, Nozzle_Change_Start_Tag, Slic3r::GCodeReader::parse_line(), Slic3r::parse_number(), Slic3r::GCodeProcessor::TimeMachine::prepare_time, Print_Time_Day_Placeholder, Print_Time_Hour_Placeholder, Print_Time_Minute_Placeholder, Print_Time_Sec_Placeholder, Print_Time_Total_Sec_Placeholder, Slic3r::GCodeReader::GCodeLine::raw(), Slic3r::ExportLines::remap_gcode_id(), Slic3r::rename_file(), Slic3r::ExportLines::reserve(), Slic3r::reserve_vector(), reserved_tag(), Slic3r::ExtruderPreHeating::ExtruderUsageBlcok::reset(), s_IsBBLPrinter, Slic3r::GCodeWriter::set_temperature(), Slic3r::short_time(), Silent_Print_Time_Placeholder, Skippable_End_Tag, Skippable_Start_Tag, Slic3r::sqr(), Slic3r::PrintEstimatedStatistics::Stealth, Slic3r::GCodeProcessor::TimeMachine::stop_times, Slic3r::string_to_double_decimal_point(), Slic3r::ExportLines::synchronize_moves(), Slic3r::ExportLines::Backtrace::time, Slic3r::GCodeProcessor::TimeMachine::time, Toolchange_Wipe_Tag, Total_Cost_Placeholder, Total_Layer_Number_Placeholder, Total_Weight_Placeholder, Total_Wipe_Tower_Cost_Placeholder, Total_Wipe_Tower_Filament_Placeholder, Slic3r::PrintStatistics::TotalFilamentCostMask, Slic3r::PrintStatistics::TotalFilamentUsedGMask, Slic3r::ExportLines::update(), Used_Filament_Length_Placeholder, and Slic3r::ExportLines::write().

Referenced by finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

run_second_pass_injection()

void Slic3r::GCodeProcessor::run_second_pass_injection ( )

private

{
    // The ordered map of M632/M400/M104/M633 lines to splice into the finished g-code, keyed on the
    // final output line id. Populated by the PreCoolingInjector below. If the injector produces
    // nothing (no idle windows / no usage blocks), the map stays empty and the rewrite below is a
    // byte-for-byte identity pass.
    TimeProcessor::InsertedLinesMap inserted_operation_lines;
 
    // The enable_pre_heating orchestration block. Build the injector from the reconciled first-pass
    // usage/skippable blocks (now in the final output-line-id space, sharing one coordinate with the
    // moves' synchronized gcode_ids) and the per-move time substrate, then have it populate
    // inserted_operation_lines. Runs under the same m_enable_pre_heating gate finalize() already
    // applied, so the byte-frozen fleet (X1/P1/A1/H2S) never reaches here.
    {
        // Pick the active time mode (Normal/Stealth) whose move.time[] the injector reads.
        int valid_machine_id = 0;
        for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
            if (m_time_processor.machines[i].enabled) {
                valid_machine_id = (int) i;
                break;
            }
        }
        // Reach the concrete layer-aware grouping (get_nozzle_from_id / is_support_dynamic_nozzle_map
        // are not on the base interface). Orca: nil-guard it — on a slicing path that never populated
        // the grouping, skip injection → empty map → identity rewrite. The shared_ptr local keeps the
        // object alive for the injector's const ref.
        auto layered_ngr = std::dynamic_pointer_cast<MultiNozzleUtils::LayeredNozzleGroupResult>(m_result.nozzle_group_result);
        if (layered_ngr) {
            constexpr float inject_time_threshold = 0.f; // threshold hardcoded to 0
            // Orca: nozzle temps are stored as float (ExtruderTemps) but the injector signature takes
            // std::vector<int>, so convert to int locals that outlive the injector (they are
            // int-valued floats — see apply_config).
            std::vector<int> filament_nozzle_temps(m_filament_nozzle_temp.begin(), m_filament_nozzle_temp.end());
            std::vector<int> filament_nozzle_temps_initial(m_filament_nozzle_temp_first_layer.begin(), m_filament_nozzle_temp_first_layer.end());
            // filament_max_temperature_drop_when_ec is inert (default {0}, never read by the injector);
            // pass the same inert default (the config is registered but unwired).
            const std::vector<double> filament_max_temperature_drop_when_ec{ 0.f };
 
            // Orca: MoveVertex.time[mode] stores the per-move DURATION (calculate_time: `= block_time`),
            // but the injector's algorithm reads move.time[] as CUMULATIVE print time (idle-window gap =
            // upper.time - prev(lower).time; heating_start back-solve = upper.time - delta/rate). Build a
            // cumulative view of the active mode IN PLACE (prefix-sum in gcode-id/move order — moves are
            // sorted by gcode_id), run the injector, then RESTORE the per-move durations so every
            // downstream consumer (and the byte output) is unperturbed. Only the single active-mode
            // column is touched.
            std::vector<float> saved_time;
            saved_time.reserve(m_result.moves.size());
            {
                float acc = 0.f;
                for (auto& mv : m_result.moves) {
                    saved_time.push_back(mv.time[valid_machine_id]);
                    acc += mv.time[valid_machine_id];
                    mv.time[valid_machine_id] = acc;
                }
            }
 
            PreCoolingInjector injector(
                m_result.moves,
                m_filament_types,
                *layered_ngr,
                filament_nozzle_temps,
                filament_nozzle_temps_initial,
                m_physical_extruder_map,
                valid_machine_id,
                inject_time_threshold,
                m_handle_hotend_as_extruder,
                m_has_filament_switcher,
                m_filament_pre_cooling_temp,
                m_hotend_cooling_rate,
                m_hotend_heating_rate,
                m_skippable_blocks,
                m_extruder_max_nozzle_count,
                m_filament_preheat_temperature_delta,
                filament_max_temperature_drop_when_ec,
                m_machine_start_gcode_end_line_id,
                m_machine_end_gcode_start_line_id,
                m_result.extruder_types,
                m_nozzle_diameter);
            injector.build_extruder_free_blocks(m_filament_blocks, m_extruder_blocks);
            injector.process_pre_cooling_and_heating(inserted_operation_lines);
 
            // Restore the per-move durations (leave the moves exactly as run_post_process produced them).
            for (size_t i = 0; i < m_result.moves.size(); ++i)
                m_result.moves[i].time[valid_machine_id] = saved_time[i];
        }
    }
 
    FilePtr in{ boost::nowide::fopen(m_result.filename.c_str(), "rb") };
    if (in.f == nullptr)
        throw Slic3r::RuntimeError(_u8L("G-code processor pre-heat injection pass failed.\nCannot open file for reading.\n"));
 
    const std::string out_path = m_result.filename + ".preheat";
    FilePtr out{ boost::nowide::fopen(out_path.c_str(), "wb") };
    if (out.f == nullptr)
        throw Slic3r::RuntimeError(_u8L("G-code processor pre-heat injection pass failed.\nCannot open file for writing.\n"));
 
    // The rewrite may shift byte positions (once the injector inserts lines), so rebuild lines_ends from scratch.
    // With an empty map the scanned '\n' offsets reproduce the current lines_ends exactly.
    m_result.lines_ends.clear();
    GCodeFileWriter writer(out, out_path, m_result.lines_ends, "GCode processor pre-heat injection pass failed.\nIs the disk full?\n");
 
    // Orca: read/split lines with EOL-preserving semantics (keep the original \r and \n bytes, and
    // synthesize no trailing newline). This is required for the empty-map identity: normalizing every
    // line ending to "\n" would not be byte-identical if the finished file used \r\n or lacked a
    // final newline.
    std::string gcode_line;
    unsigned int line_id = 0;
    auto op_it = inserted_operation_lines.begin();
    std::vector<char> buffer(65536 * 10, 0);
    for (;;) {
        size_t cnt_read = ::fread(buffer.data(), 1, buffer.size(), in.f);
        if (::ferror(in.f))
            throw Slic3r::RuntimeError(_u8L("G-code processor pre-heat injection pass 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())) {
            bool eol    = false;
            auto it_end = it;
            for (; it_end != it_bufend && !(eol = *it_end == '\r' || *it_end == '\n'); ++it_end);
            eol |= eof && it_end == it_bufend;
            gcode_line.insert(gcode_line.end(), it, it_end);
            it = it_end;
            if (it != it_bufend && *it == '\r')
                gcode_line += *it++;
            if (it != it_bufend && *it == '\n')
                gcode_line += *it++;
            if (eol) {
                ++line_id;
                // Splice any injector lines registered at this output line id. They are appended to the
                // end of the current line's text (which already carries its EOL), so they land AFTER
                // this line. PlaceholderReplace / TimePredict / ExtruderChangePredict are handled in the
                // first pass and skipped here.
                if (op_it != inserted_operation_lines.end() && line_id == op_it->first) {
                    for (const auto& elem : op_it->second) {
                        switch (elem.second) {
                        case TimeProcessor::InsertLineType::PreCooling:
                        case TimeProcessor::InsertLineType::PreHeating:
                        case TimeProcessor::InsertLineType::FilamentChangePredict:
                            gcode_line += elem.first;
                            break;
                        default:
                            break;
                        }
                    }
                    ++op_it;
                }
                writer.append(gcode_line);
                gcode_line.clear();
            }
        }
        if (eof)
            break;
    }
    writer.flush();
 
    out.close();
    in.close();
 
    // Re-shift the moves by the inserted-line counts (no-op with an empty map).
    handle_offsets_of_second_process(inserted_operation_lines);
 
    if (rename_file(out_path, m_result.filename))
        // TRN %1% is the temporary file path, %2% the output file path.
        throw Slic3r::RuntimeError(Slic3r::format(_u8L("Failed to rename the output G-code file from %1% to %2%.\nIs %1% locked?"),
                                                  out_path, m_result.filename) + '\n');
}

References _u8L, Slic3r::GCodeProcessor::PreCoolingInjector::build_extruder_free_blocks(), Slic3r::FilePtr::close(), Slic3r::PrintEstimatedStatistics::Count, Slic3r::FilePtr::f, Slic3r::GCodeProcessor::TimeProcessor::FilamentChangePredict, Slic3r::format(), handle_offsets_of_second_process(), m_extruder_blocks, m_extruder_max_nozzle_count, m_filament_blocks, m_filament_nozzle_temp, m_filament_nozzle_temp_first_layer, m_filament_pre_cooling_temp, m_filament_preheat_temperature_delta, m_filament_types, m_handle_hotend_as_extruder, m_has_filament_switcher, m_hotend_cooling_rate, m_hotend_heating_rate, m_machine_end_gcode_start_line_id, m_machine_start_gcode_end_line_id, m_nozzle_diameter, m_physical_extruder_map, m_result, m_skippable_blocks, m_time_processor, Slic3r::GCodeProcessor::TimeProcessor::PreCooling, Slic3r::GCodeProcessor::TimeProcessor::PreHeating, Slic3r::GCodeProcessor::PreCoolingInjector::process_pre_cooling_and_heating(), and Slic3r::rename_file().

Referenced by finalize().

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 Slic3r::GCodeProcessorResult::id, and m_time_processor.

Referenced by process_M204().

Here is the caller graph for this function:

set_extrusion_role()

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

private

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

References m_extrusion_role, and m_used_filaments.

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

Here is the caller graph for this function:

set_mass_locator()

void Slic3r::GCodeProcessor::set_mass_locator ( MassLocator locator, std::vector< GCodeProcessorResult::ObjectMass > objects )

inline

        {
            m_mass_locator = std::move(locator);
            m_result.support_masses.assign(objects.size(), {});
            m_result.object_masses = std::move(objects);
        }

References m_mass_locator, and m_result.

Referenced by Slic3r::set_mass_locator().

Here is the caller graph for this function:

set_print()

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

inline

{ m_print = print; }

References m_print.

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 Slic3r::GCodeProcessorResult::id, and m_time_processor.

Referenced by process_M204().

Here is the caller graph for this function:

set_skippable_type()

void Slic3r::GCodeProcessor::set_skippable_type ( const std::string_view type )

private

{
    if (!m_skippable) {
        m_skippable_type = SkipType::stNone;
        return;
    }
    auto iter = skip_type_map.find(type);
    if (iter != skip_type_map.end()) {
        m_skippable_type = iter->second;
    } else {
        m_skippable_type = SkipType::stOther;
    }
}

References m_skippable, m_skippable_type, Slic3r::skip_type_map, Slic3r::stNone, and Slic3r::stOther.

Referenced by process_tags().

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 Slic3r::GCodeProcessorResult::id, and m_time_processor.

Referenced by process_M204().

Here is the caller graph for this function:

set_xy_offset()

void Slic3r::GCodeProcessor::set_xy_offset ( double x, double y )

inline

{ m_x_offset = x; m_y_offset = y; }

References m_x_offset, and m_y_offset.

Referenced by Slic3r::Print::export_gcode_from_previous_file(), and Slic3r::Print::reload_gcode_moves().

Here is the caller graph for this function:

simulate_st_synchronize()

void Slic3r::GCodeProcessor::simulate_st_synchronize ( float additional_time = 0.0f, EMoveType target_move_type = EMoveType::Noop )

private

{
    calculate_time(m_result, 0, additional_time, target_move_type);
    if (m_flavor == gcfKlipper) {
        // ToolHead overrides the normal look-ahead window with BUFFER_TIME_HIGH
        // at startup and after synchronization: 2 s on legacy, 1 s on modern Klipper.
        for (TimeMachine& machine : m_time_processor.machines) {
            machine.klipper_junction_flush = machine.requested_accel_to_decel >= 0.0f ? 2.0f : 1.0f;
            machine.klipper_queue_priming = true;
        }
    }
}

References calculate_time(), Slic3r::gcfKlipper, Slic3r::GCodeProcessor::TimeMachine::klipper_junction_flush, Slic3r::GCodeProcessor::TimeMachine::klipper_queue_priming, m_flavor, m_result, m_time_processor, and Slic3r::GCodeProcessor::TimeMachine::requested_accel_to_decel.

Referenced by process_custom_gcode_time(), process_filament_change(), process_filament_change(), process_G29(), process_G4(), process_G92(), process_M1(), process_M109(), process_M190(), process_M191(), process_M400(), process_M702(), and process_SYNC().

Here is the call graph for this function:

Here is the caller graph for this function:

store_move_vertex()

void Slic3r::GCodeProcessor::store_move_vertex ( EMoveType type, EMovePathType path_type = EMovePathType::Noop_move, bool internal_only = false )

private

{
    int filament_id = get_filament_id();
    const auto normal_mode = PrintEstimatedStatistics::ETimeMode::Normal;
    const size_t normal_mode_id = static_cast<size_t>(normal_mode);
    const float delta_x = std::abs(m_end_position[X] - m_start_position[X]);
    const float delta_y = std::abs(m_end_position[Y] - m_start_position[Y]);
    const float delta_z = std::abs(m_end_position[Z] - m_start_position[Z]);
    const float delta_e = std::abs(m_end_position[E] - m_start_position[E]);
    const bool has_x = delta_x > 0.0f;
    const bool has_y = delta_y > 0.0f;
    const bool has_z = delta_z > 0.0f;
    const bool has_e = delta_e > 0.0f;
    const float move_acceleration =
        (type == EMoveType::Travel) ? get_travel_acceleration(normal_mode) :
        ((type == EMoveType::Retract || type == EMoveType::Unretract) ? get_retract_acceleration(normal_mode) :
                                                                    get_acceleration(normal_mode));
    const float junction_deviation = get_option_value(m_time_processor.machine_limits.machine_max_junction_deviation, normal_mode_id);
    const bool use_jd_jerk = (m_flavor == gcfMarlinFirmware && junction_deviation > 0.0f);
    const auto axis_jerk_for_preview = [this, use_jd_jerk, move_acceleration](Axis axis) {
        return use_jd_jerk ? get_axis_max_jerk_with_jd(normal_mode, axis, move_acceleration) : get_axis_max_jerk(normal_mode, axis);
    };
    const float jerk_x = axis_jerk_for_preview(X);
    const float jerk_y = axis_jerk_for_preview(Y);
    const float jerk_z = axis_jerk_for_preview(Z);
    const float jerk_e = axis_jerk_for_preview(E);
    const float move_jerk =
        (has_e && !has_x && !has_y && !has_z) ? jerk_e :
        (has_z && !has_x && !has_y) ? jerk_z :
        (has_x && has_y) ? std::min(jerk_x, jerk_y) :
        has_x ? jerk_x :
        has_y ? jerk_y :
        has_z ? jerk_z :
                std::min(jerk_x, jerk_y);
    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);
 
    if (type == EMoveType::Travel) {
        m_result.print_statistics.total_travel_moves++;
        m_result.print_statistics.total_travel_distance += m_travel_dist;
    }
 
    // During the start G-code "prepare" stage the toolhead Z is not yet a real
    // print height on a normal printer, so it is pinned to the first-layer height
    // to keep the preview tidy. Belt printers are the exception: there the Z is
    // written explicitly by the belt kinematics and the designed-view back-transform
    // couples machine Z into the rendered model Y (the belt tilt mixes the height
    // and belt-feed axes). Overriding Z therefore back-transforms the last
    // prepare-stage move (the unretract before the first extrusion) to model
    // Y ~= 0, and the libvgcode path builder then draws a phantom extrusion
    // segment from Y ~= 0 to the first real toolpath. Keep the real Z for belt
    // printers so prepare-stage moves map correctly. Gated on belt_tilt_angle (set
    // from the G-code header before the body is processed) so non-belt processing
    // is byte-identical.
    const float store_z = (m_processing_start_custom_gcode && m_result.belt_tilt_angle == 0.f)
        ? m_first_layer_height
        : m_end_position[Z] - m_z_offset;
 
    m_result.moves.push_back({
        m_last_line_id,
        type,
        m_extrusion_role,
        static_cast<unsigned char>(filament_id),
        m_cp_color.current,
        //BBS: add plate's offset to the rendering vertices
        Vec3f(m_end_position[X] + m_x_offset, m_end_position[Y] + m_y_offset, store_z) + m_extruder_offsets[filament_id],
        static_cast<float>(m_end_position[E] - m_start_position[E]),
        m_feedrate,
        0.0f, // actual feedrate
        m_width,
        m_height,
        m_mm3_per_mm,
        m_travel_dist,
        m_fan_speed,
        m_extruder_temps[filament_id],
// ORCA: Add Pressure Advance visualization support
        m_pressure_advance,
        // ORCA: Add Acceleration visualization support
        move_acceleration,
        // ORCA: Add Jerk visualization support
        move_jerk,
        { 0.0f, 0.0f }, // time
        static_cast<float>(m_layer_id), //layer_duration: set later
        std::max<unsigned int>(1, m_layer_id) - 1,
        internal_only,
        m_object_label_id,
        m_print_z
    });
 
    if (type == EMoveType::Seam) {
        m_seams_count++;
    }
 
    // 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::Custom_GCode, Slic3r::E, Slic3r::GCodeProcessor::TimeMachine::enabled, Slic3r::gcfMarlinFirmware, get_acceleration(), get_axis_max_jerk(), get_axis_max_jerk_with_jd(), get_filament_id(), Slic3r::get_option_value(), get_retract_acceleration(), get_travel_acceleration(), m_cp_color, m_end_position, m_extruder_offsets, m_extruder_temps, m_extrusion_role, m_fan_speed, m_feedrate, m_first_layer_height, m_flavor, m_g1_line_id, m_height, m_last_line_id, m_layer_id, m_line_id, m_mm3_per_mm, m_object_label_id, m_pressure_advance, m_print_z, m_processing_start_custom_gcode, m_result, m_seams_count, m_start_position, m_time_processor, m_travel_dist, m_width, m_x_offset, m_y_offset, m_z_offset, Slic3r::PrintEstimatedStatistics::Normal, Slic3r::Pause_Print, Slic3r::Retract, Slic3r::Seam, Slic3r::GCodeProcessor::TimeMachine::stop_times, Slic3r::Travel, Slic3r::Unretract, Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by process_filament_change(), process_filament_change(), process_G1(), process_G22(), process_G23(), and process_tags().

Here is the call graph for this function:

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.prepare_time = get_prepare_time(mode);
        data.custom_gcode_times = get_custom_gcode_times(mode, true);
    };
 
    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.model_volumes_per_extruder      = m_used_filaments.model_volumes_per_filament;
    m_result.print_statistics.wipe_tower_volumes_per_extruder = m_used_filaments.wipe_tower_volumes_per_filament;
    m_result.print_statistics.support_volumes_per_extruder = m_used_filaments.support_volumes_per_filament;
    m_result.print_statistics.flush_per_filament      = m_used_filaments.flush_per_filament;
    m_result.print_statistics.used_filaments_per_role   = m_used_filaments.filaments_per_role;
    m_result.print_statistics.total_volumes_per_extruder = m_used_filaments.total_volumes_per_filament;
}

References Slic3r::PrintEstimatedStatistics::Mode::custom_gcode_times, get_custom_gcode_times(), get_prepare_time(), get_time(), m_result, m_time_processor, m_used_filaments, Slic3r::PrintEstimatedStatistics::Normal, Slic3r::PrintEstimatedStatistics::Mode::prepare_time, Slic3r::GCodeProcessorResult::reset(), Slic3r::PrintEstimatedStatistics::Stealth, and Slic3r::PrintEstimatedStatistics::Mode::time.

Referenced by finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

update_exclusion_volume_path_check_result()

void Slic3r::GCodeProcessor::update_exclusion_volume_path_check_result ( )

private

{
    m_result.exclusion_volume_path_checked = m_exclusion_volume_path_checker.configured();
    const ExclusionVolumePathCheckResult &check = m_exclusion_volume_path_checker.result();
    m_result.exclusion_volume_path_conflict = check.has_any_conflict;
    m_result.exclusion_volume_travel_conflict = check.has_travel_conflict;
    m_result.exclusion_volume_extrusion_conflict = check.has_extrusion_conflict;
    m_result.exclusion_volume_other_motion_conflict = check.has_other_motion_conflict;
 
    if (!check.first_hit)
        return;
 
    const ExclusionVolumePathHit &hit = *check.first_hit;
    m_result.exclusion_volume_conflict_gcode_id = hit.gcode_id;
    m_result.exclusion_volume_conflict_move_id = hit.move_id;
    m_result.exclusion_volume_conflict_move_type = static_cast<EMoveType>(hit.source_move_type);
    m_result.exclusion_volume_conflict_extruder_id = hit.extruder_id;
    m_result.exclusion_volume_conflict_region_id = hit.region_id;
    m_result.exclusion_volume_conflict_used_unknown_z = hit.used_unknown_z;
}

References Slic3r::ExclusionVolumePathHit::extruder_id, Slic3r::ExclusionVolumePathHit::gcode_id, m_exclusion_volume_path_checker, m_result, Slic3r::ExclusionVolumePathHit::move_id, Slic3r::ExclusionVolumePathHit::region_id, Slic3r::ExclusionVolumePathHit::source_move_type, and Slic3r::ExclusionVolumePathHit::used_unknown_z.

Referenced by finalize().

Here is the caller graph for this function:

update_position_known_from_move() [1/2]

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

private

{
    if (m_global_positioning_type != EPositioningType::Absolute)
        return;
 
    for (unsigned char axis = X; axis <= Z; ++axis) {
        if (line.has(static_cast<Axis>(axis)))
            m_axis_position_known[axis] = m_axis_origin_known[axis];
    }
}

References Absolute, Slic3r::GCodeReader::GCodeLine::has(), m_axis_origin_known, m_axis_position_known, m_global_positioning_type, Slic3r::X, and Slic3r::Z.

Here is the call graph for this function:

update_position_known_from_move() [2/2]

void Slic3r::GCodeProcessor::update_position_known_from_move ( const std::array< std::optional< double >, 4 > & axes, G1DiscretizationOrigin origin )

private

{
    if (origin != G1DiscretizationOrigin::G1 || m_global_positioning_type != EPositioningType::Absolute)
        return;
 
    for (unsigned char axis = X; axis <= Z; ++axis) {
        if (axes[axis].has_value())
            m_axis_position_known[axis] = m_axis_origin_known[axis];
    }
}

References Absolute, G1, m_axis_origin_known, m_axis_position_known, m_global_positioning_type, Slic3r::X, and Slic3r::Z.

Referenced by process_G1(), and process_G2_G3().

Here is the caller graph for this function:

update_slice_warnings()

void Slic3r::GCodeProcessor::update_slice_warnings ( )

private

{
    m_result.warnings.clear();
 
    auto get_used_filaments = [this]() {
        std::vector<size_t> used_filaments;
        used_filaments.reserve(m_used_filaments.total_volumes_per_filament.size());
        for (auto item : m_used_filaments.total_volumes_per_filament) {
            used_filaments.push_back(item.first);
        }
        return used_filaments;
    };
 
    auto used_filaments = get_used_filaments();
    assert(!used_filaments.empty());
    GCodeProcessorResult::SliceWarning warning;
    warning.level = 1;
    if (m_highest_bed_temp != 0) {
        for (size_t i = 0; i < used_filaments.size(); i++) {
            int temperature = get_filament_vitrification_temperature(used_filaments[i]);
            if (temperature != 0 && m_highest_bed_temp >= temperature)
                warning.params.push_back(std::to_string(used_filaments[i]));
        }
    }
 
    if (!warning.params.empty()) {
        warning.level       = 3;
        warning.msg         = BED_TEMP_TOO_HIGH_THAN_FILAMENT;
        warning.error_code  = "1000C001";
        m_result.warnings.push_back(warning);
    }
 
    //bbs:HRC checker
    warning.params.clear();
    warning.level=1;
 
    std::vector<int> nozzle_hrc_lists(m_result.nozzle_type.size(), 0);
    // store the nozzle hrc of each extruder
    for (size_t idx = 0; idx < m_result.nozzle_type.size(); ++idx) {
        nozzle_hrc_lists[idx] = m_result.nozzle_hrc;
        if(nozzle_hrc_lists[idx] <= 0)
            nozzle_hrc_lists[idx] = Print::get_hrc_by_nozzle_type(m_result.nozzle_type[idx]);
    }
 
    for (size_t idx = 0; idx < used_filaments.size(); ++idx) {
        int filament_hrc = 0;
 
        if (used_filaments[idx] < m_result.required_nozzle_HRC.size())
            filament_hrc = m_result.required_nozzle_HRC[used_filaments[idx]];
 
        int filament_extruder_id = used_filaments[idx] < m_filament_maps.size() ? m_filament_maps[used_filaments[idx]] : -1;
        int extruder_hrc = (filament_extruder_id >= 0 && (size_t) filament_extruder_id < nozzle_hrc_lists.size()) ? nozzle_hrc_lists[filament_extruder_id] : 0;
 
        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": Check HRC: filament:%1%, hrc=%2%, extruder:%3%, hrc:%4%") % used_filaments[idx] % filament_hrc % filament_extruder_id % extruder_hrc;
 
        if (extruder_hrc!=0 && extruder_hrc < filament_hrc)
            warning.params.push_back(std::to_string(used_filaments[idx]));
    }
 
    if (!warning.params.empty()) {
        warning.level      = 3;
        warning.msg = NOZZLE_HRC_CHECKER;
        warning.error_code = "1000C002";
        m_result.warnings.push_back(warning);
    }
 
    // bbs:HRC checker
    warning.params.clear();
    warning.level = 1;
    if (!m_result.support_traditional_timelapse) {
        warning.level      = 2;
        warning.msg        = NOT_SUPPORT_TRADITIONAL_TIMELAPSE;
        warning.error_code = "10018003";
        m_result.warnings.push_back(warning);
 
        // Compatible with older version for A series
        warning.level      = 3;
        warning.error_code = "1000C003";
        m_result.warnings.push_back(warning);
    }
 
    if (m_result.timelapse_warning_code != 0) {
        if (m_result.timelapse_warning_code & 1) {
            warning.level      = 1;
            warning.msg        = NOT_GENERATE_TIMELAPSE;
            warning.error_code = "10014001";
            m_result.warnings.push_back(warning);
        }
        if ((m_result.timelapse_warning_code >> 1) & 1) {
            warning.level      = 1;
            warning.msg        = NOT_GENERATE_TIMELAPSE;
            warning.error_code = "10014002";
            m_result.warnings.push_back(warning);
        }
        if ((m_result.timelapse_warning_code >> 2) & 1) {
            warning.level      = 2;
            warning.msg        = SMOOTH_TIMELAPSE_WITHOUT_PRIME_TOWER;
            warning.error_code = "10018004";
            m_result.warnings.push_back(warning);
        }
    }
 
    m_result.warnings.shrink_to_fit();
}

References BED_TEMP_TOO_HIGH_THAN_FILAMENT, Slic3r::GCodeProcessorResult::SliceWarning::error_code, get_filament_vitrification_temperature(), Slic3r::Print::get_hrc_by_nozzle_type(), Slic3r::GCodeProcessorResult::SliceWarning::level, m_filament_maps, m_highest_bed_temp, m_result, m_used_filaments, Slic3r::GCodeProcessorResult::SliceWarning::msg, NOT_GENERATE_TIMELAPSE, NOT_SUPPORT_TRADITIONAL_TIMELAPSE, NOZZLE_HRC_CHECKER, Slic3r::GCodeProcessorResult::SliceWarning::params, and SMOOTH_TIMELAPSE_WITHOUT_PRIME_TOWER.

Referenced by finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

use_multi_nozzle_change_time_model()

bool Slic3r::GCodeProcessor::use_multi_nozzle_change_time_model ( ) const

private

{
    // Multi-nozzle context = a printer that can incur nozzle-change events the single-arg model
    // cannot distinguish: either a multi-extruder machine (nozzle_diameter has >1 physical extruder,
    // e.g. H2D/X2D/H2D-Pro) or an extruder that carries a nozzle cluster (extruder_max_nozzle_count>1,
    // e.g. H2C's {1,6}). Every single-extruder single-nozzle printer (X1/P1/A1/H2S/A2L) fails both
    // tests → false → they keep the byte-frozen single-arg time model. Both members are populated by
    // apply_config (each overload) and cleared in reset(), so this is stream-time safe.
    if (m_nozzle_diameter.size() > 1)
        return true;
    for (int count : m_extruder_max_nozzle_count)
        if (count > 1)
            return true;
    return false;
}

References count, m_extruder_max_nozzle_count, and m_nozzle_diameter.

Referenced by process_filament_change().

Here is the caller graph for this function:

Friends And Related Symbol Documentation

ExportLines

friend class ExportLines

friend

References ExportLines.

Referenced by ExportLines, and run_post_process().

Member Data Documentation

External_Purge_Tag

const std::string Slic3r::GCodeProcessor::External_Purge_Tag = " EXTERNAL_PURGE"

staticprivate

Referenced by process_tags().

Flush_End_Tag

const std::string Slic3r::GCodeProcessor::Flush_End_Tag = " FLUSH_END"

staticprivate

Referenced by process_tags().

Flush_Start_Tag

const std::string Slic3r::GCodeProcessor::Flush_Start_Tag = " FLUSH_START"

staticprivate

Referenced by process_tags().

m_actual_speed_id_map

std::vector<std::pair<unsigned int, unsigned int> > Slic3r::GCodeProcessor::m_actual_speed_id_map

private

Referenced by calculate_time().

m_axis_origin_known

std::array<bool, 3> Slic3r::GCodeProcessor::m_axis_origin_known { true, true, true }

private

{ true, true, true };

Referenced by process_G28(), process_G92(), reset(), update_position_known_from_move(), and update_position_known_from_move().

m_axis_position_known

std::array<bool, 3> Slic3r::GCodeProcessor::m_axis_position_known { false, false, false }

private

{ false, false, false };

Referenced by get_current_position(), process_G1(), process_G28(), process_G92(), reset(), update_position_known_from_move(), and update_position_known_from_move().

m_belt_printer

bool Slic3r::GCodeProcessor::m_belt_printer { false }

private

{ false };

Referenced by apply_config(), check_multi_extruder_gcode_valid(), and process_tags().

m_belt_render_config

DynamicConfig Slic3r::GCodeProcessor::m_belt_render_config

private

Referenced by apply_config(), and export_config_for_render().

m_cached_position

CachedPosition Slic3r::GCodeProcessor::m_cached_position

private

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

m_command_processor

CommandProcessor Slic3r::GCodeProcessor::m_command_processor

private

Referenced by process_gcode_line(), and register_commands().

m_cp_color

CpColor Slic3r::GCodeProcessor::m_cp_color

private

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

m_detect_layer_based_on_tag

bool Slic3r::GCodeProcessor::m_detect_layer_based_on_tag {false}

private

{false};

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

m_disable_m73

bool Slic3r::GCodeProcessor::m_disable_m73

private

Referenced by apply_config(), and run_post_process().

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(), process_VG1(), and reset().

m_enable_pre_heating

bool Slic3r::GCodeProcessor::m_enable_pre_heating { false }

private

{ false };

Referenced by apply_config(), apply_config(), finalize(), reset(), and run_post_process().

m_end_position

AxisCoords Slic3r::GCodeProcessor::m_end_position

private

Referenced by add_object_mass(), get_current_position(), process_G1(), process_G2_G3(), process_G92(), process_gcode_line(), process_tags(), process_VG1(), reset(), and store_move_vertex().

m_exclusion_volume_path_checker

ExclusionVolumePathChecker Slic3r::GCodeProcessor::m_exclusion_volume_path_checker

private

Referenced by configure_exclusion_volume_path_check(), process_G1(), reset(), and update_exclusion_volume_path_check_result().

m_extruded_last_z

float Slic3r::GCodeProcessor::m_extruded_last_z

private

Referenced by process_G1(), and reset().

m_extruder_blocks

std::vector<ExtruderPreHeating::ExtruderUsageBlcok> Slic3r::GCodeProcessor::m_extruder_blocks

private

Referenced by reset(), run_post_process(), and run_second_pass_injection().

m_extruder_colors

ExtruderColors Slic3r::GCodeProcessor::m_extruder_colors

private

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

m_extruder_id

unsigned char Slic3r::GCodeProcessor::m_extruder_id

private

Referenced by get_extruder_id(), process_filament_change(), process_filament_change(), process_G10(), process_G11(), and reset().

m_extruder_max_nozzle_count

std::vector<int> Slic3r::GCodeProcessor::m_extruder_max_nozzle_count {1}

private

{1};

Referenced by apply_config(), apply_config(), reset(), run_second_pass_injection(), and use_multi_nozzle_change_time_model().

m_extruder_offsets

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

private

Referenced by add_object_mass(), apply_config(), apply_config(), check_multi_extruder_gcode_valid(), 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_elegoo_M6211(), process_M104(), process_M109(), reset(), and store_move_vertex().

m_extrusion_role

ExtrusionRole Slic3r::GCodeProcessor::m_extrusion_role

private

Referenced by add_object_mass(), process_craftware_tags(), process_cura_tags(), process_G1(), process_ideamaker_tags(), Slic3r::GCodeProcessor::UsedFilaments::process_role_cache(), process_tags(), process_VG1(), 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_feedrate

float Slic3r::GCodeProcessor::m_feedrate

private

Referenced by process_G1(), process_G10(), process_G11(), process_G2_G3(), process_M401(), process_M402(), process_VG1(), reset(), and store_move_vertex().

m_filament_blocks

std::vector<ExtruderPreHeating::FilamentUsageBlock> Slic3r::GCodeProcessor::m_filament_blocks

private

Referenced by reset(), run_post_process(), and run_second_pass_injection().

m_filament_id

std::vector<unsigned char> Slic3r::GCodeProcessor::m_filament_id

private

Referenced by get_filament_id(), process_filament_change(), process_filament_change(), and reset().

m_filament_maps

std::vector<int> Slic3r::GCodeProcessor::m_filament_maps

private

Referenced by apply_config(), apply_config(), ensure_nozzle_group_result(), init_filament_maps_and_nozzle_type_when_import_only_gcode(), process_elegoo_M6211(), process_filament_change(), and update_slice_warnings().

m_filament_nozzle_temp

ExtruderTemps Slic3r::GCodeProcessor::m_filament_nozzle_temp

private

Referenced by apply_config(), run_post_process(), and run_second_pass_injection().

m_filament_nozzle_temp_first_layer

ExtruderTemps Slic3r::GCodeProcessor::m_filament_nozzle_temp_first_layer

private

Referenced by apply_config(), run_post_process(), and run_second_pass_injection().

m_filament_pre_cooling_temp

std::vector<int> Slic3r::GCodeProcessor::m_filament_pre_cooling_temp { 0 }

private

{ 0 };

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

m_filament_preheat_temperature_delta

std::vector<double> Slic3r::GCodeProcessor::m_filament_preheat_temperature_delta

private

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

m_filament_types

std::vector<std::string> Slic3r::GCodeProcessor::m_filament_types

private

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

m_first_layer_height

float Slic3r::GCodeProcessor::m_first_layer_height

private

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

m_flavor

GCodeFlavor Slic3r::GCodeProcessor::m_flavor

private

Referenced by apply_config(), apply_config(), calc_vmax_junction_deviation(), calculate_time(), get_axis_max_jerk(), get_junction_deviation(), get_xyz_max_jerk(), process_cura_tags(), process_G1(), process_G1(), process_G2_G3(), process_gcode_line(), process_M1020(), process_M108(), process_M109(), process_M135(), process_M190(), process_M201(), process_M203(), process_M204(), process_M400(), process_M401(), process_M402(), process_T(), reset(), run_post_process(), simulate_st_synchronize(), and store_move_vertex().

m_flushing

bool Slic3r::GCodeProcessor::m_flushing

private

Referenced by process_G1(), process_tags(), 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_filament_change(), process_filament_change(), process_G1(), process_G10(), process_G11(), process_tags(), process_VG1(), reset(), and store_move_vertex().

m_g29_time_added

bool Slic3r::GCodeProcessor::m_g29_time_added {false}

private

{false};

Referenced by process_G29(), and reset().

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(), process_VG1(), reset(), update_position_known_from_move(), and update_position_known_from_move().

m_handle_hotend_as_extruder

bool Slic3r::GCodeProcessor::m_handle_hotend_as_extruder { false }

private

{ false };

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

m_has_filament_switcher

bool Slic3r::GCodeProcessor::m_has_filament_switcher { false }

private

{ false };

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

m_height

float Slic3r::GCodeProcessor::m_height

private

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

m_highest_bed_temp

int Slic3r::GCodeProcessor::m_highest_bed_temp

private

Referenced by process_M140(), process_M190(), reset(), and update_slice_warnings().

m_hotend_cooling_rate

std::vector<double> Slic3r::GCodeProcessor::m_hotend_cooling_rate { 2.f }

private

{ 2.f };

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

m_hotend_heating_rate

std::vector<double> Slic3r::GCodeProcessor::m_hotend_heating_rate { 2.f }

private

{ 2.f };

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

m_in_config_block

bool Slic3r::GCodeProcessor::m_in_config_block

private

Referenced by process_tags(), and reset().

m_is_XL_printer

bool Slic3r::GCodeProcessor::m_is_XL_printer = false

private

Referenced by apply_config(), and run_post_process().

m_last_default_color_id

size_t Slic3r::GCodeProcessor::m_last_default_color_id

private

Referenced by process_tags(), and reset().

m_last_filament_id

std::vector<unsigned char> Slic3r::GCodeProcessor::m_last_filament_id

private

Referenced by get_last_filament_id(), process_filament_change(), process_filament_change(), 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 add_object_mass(), process_craftware_tags(), process_cura_tags(), process_filament_change(), process_filament_change(), process_G1(), process_ideamaker_tags(), process_kissslicer_tags(), process_simplify3d_tags(), process_tags(), process_VG1(), reset(), run_post_process(), and store_move_vertex().

m_line_id

unsigned int Slic3r::GCodeProcessor::m_line_id

private

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

m_machine_config_idx

int Slic3r::GCodeProcessor::m_machine_config_idx {0}

private

{0};

Referenced by calc_junction_acceleration(), process_filament_change(), process_filament_change(), process_G1(), process_VG1(), and reset().

m_machine_end_gcode_start_line_id

unsigned int Slic3r::GCodeProcessor::m_machine_end_gcode_start_line_id { (unsigned int) (-1) }

private

{ (unsigned int) (-1) };

Referenced by reset(), run_post_process(), and run_second_pass_injection().

m_machine_frame_transform

MachineFrameTransform Slic3r::GCodeProcessor::m_machine_frame_transform

private

Referenced by apply_config(), and check_multi_extruder_gcode_valid().

m_machine_start_gcode_end_line_id

unsigned int Slic3r::GCodeProcessor::m_machine_start_gcode_end_line_id { (unsigned int) (-1) }

private

{ (unsigned int) (-1) };

Referenced by reset(), run_post_process(), and run_second_pass_injection().

m_manual_filament_change

bool Slic3r::GCodeProcessor::m_manual_filament_change { false }

private

{ false };

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

m_mass_locator

MassLocator Slic3r::GCodeProcessor::m_mass_locator

private

Referenced by add_object_mass(), reset(), and set_mass_locator().

m_measure_g29_time

bool Slic3r::GCodeProcessor::m_measure_g29_time {false}

private

{false};

Referenced by process_G29(), process_M622(), and process_M623().

m_mm3_per_mm

float Slic3r::GCodeProcessor::m_mm3_per_mm

private

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

m_nozzle_diameter

std::vector<double> Slic3r::GCodeProcessor::m_nozzle_diameter

private

Referenced by apply_config(), apply_config(), reset(), run_second_pass_injection(), and use_multi_nozzle_change_time_model().

m_nozzle_group_result

std::shared_ptr<MultiNozzleUtils::NozzleGroupResultBase> Slic3r::GCodeProcessor::m_nozzle_group_result

private

Referenced by ensure_nozzle_group_result(), get_machine_config_idx(), initialize_from_context(), process_filament_change(), and reset().

m_nozzle_status_recorder

MultiNozzleUtils::NozzleStatusRecorder Slic3r::GCodeProcessor::m_nozzle_status_recorder

private

Referenced by get_machine_config_idx(), process_filament_change(), and reset().

m_nozzle_volume

std::vector<float> Slic3r::GCodeProcessor::m_nozzle_volume

private

Referenced by apply_config(), apply_config(), process_elegoo_M6211(), process_filaments(), and reset().

m_object_label_id

int Slic3r::GCodeProcessor::m_object_label_id {-1}

private

{-1};

Referenced by process_tags(), and store_move_vertex().

m_options_z_corrector

OptionsZCorrector Slic3r::GCodeProcessor::m_options_z_corrector

private

Referenced by GCodeProcessor(), calculate_time(), 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(), process_VG1(), and reset().

m_parser

GCodeReader Slic3r::GCodeProcessor::m_parser

private

Referenced by apply_config(), apply_config(), apply_config_simplify3d(), export_config_for_render(), process_buffer(), process_file(), process_G10(), and process_G11().

m_physical_extruder_map

std::vector<int> Slic3r::GCodeProcessor::m_physical_extruder_map

private

Referenced by apply_config(), apply_config(), reset(), run_post_process(), and run_second_pass_injection().

m_preheat_steps

int Slic3r::GCodeProcessor::m_preheat_steps

private

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

m_preheat_time

float Slic3r::GCodeProcessor::m_preheat_time

private

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

m_pressure_advance

float Slic3r::GCodeProcessor::m_pressure_advance

private

Referenced by process_M572(), process_M900(), process_SET_PRESSURE_ADVANCE(), and store_move_vertex().

m_print

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

private

{ nullptr };

Referenced by run_post_process(), and set_print().

m_print_z

float Slic3r::GCodeProcessor::m_print_z {0.0f}

private

{0.0f};

Referenced by process_tags(), and store_move_vertex().

m_printer_model

std::string Slic3r::GCodeProcessor::m_printer_model

private

Referenced by apply_config(), apply_config(), process_elegoo_M6211(), and process_M6211().

m_processing_homing_move

bool Slic3r::GCodeProcessor::m_processing_homing_move { false }

private

{ false };

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

m_processing_start_custom_gcode

bool Slic3r::GCodeProcessor::m_processing_start_custom_gcode

private

Referenced by process_filament_change(), process_filament_change(), process_G1(), process_tags(), process_VG1(), reset(), and store_move_vertex().

m_producer

EProducer Slic3r::GCodeProcessor::m_producer

private

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

m_remaining_volume

std::vector<float> Slic3r::GCodeProcessor::m_remaining_volume

private

Referenced by process_elegoo_M6211(), process_filaments(), process_G1(), process_VG1(), and reset().

m_result

GCodeProcessorResult Slic3r::GCodeProcessor::m_result

private

Referenced by GCodeProcessor(), add_object_mass(), apply_config(), apply_config(), apply_config_simplify3d(), calculate_time(), check_multi_extruder_gcode_valid(), ensure_nozzle_group_result(), extract_result(), finalize(), finalize_object_masses(), get_filament_vitrification_temperature(), get_machine_config_idx(), get_result(), handle_offsets_of_second_process(), init_filament_maps_and_nozzle_type_when_import_only_gcode(), initialize(), initialize_result_moves(), process_elegoo_M6211(), process_filament_change(), process_filament_change(), process_file(), process_G1(), process_G2_G3(), process_G92(), process_M1020(), Slic3r::GCodeProcessor::UsedFilaments::process_role_cache(), process_T(), process_tags(), process_VG1(), reset(), result(), run_post_process(), run_second_pass_injection(), set_mass_locator(), simulate_st_synchronize(), store_move_vertex(), update_estimated_times_stats(), update_exclusion_volume_path_check_result(), and update_slice_warnings().

m_seams_count

int Slic3r::GCodeProcessor::m_seams_count

private

Referenced by reset(), and store_move_vertex().

m_seams_detector

SeamsDetector Slic3r::GCodeProcessor::m_seams_detector

private

Referenced by 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().

m_skip_end_gcode_delays

bool Slic3r::GCodeProcessor::m_skip_end_gcode_delays { false }

private

{ false };

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

m_skippable

bool Slic3r::GCodeProcessor::m_skippable {false}

private

{false};

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

m_skippable_blocks

std::vector<std::pair<unsigned int, unsigned int> > Slic3r::GCodeProcessor::m_skippable_blocks

private

Referenced by reset(), run_post_process(), and run_second_pass_injection().

m_skippable_type

SkipType Slic3r::GCodeProcessor::m_skippable_type {SkipType::stNone}

private

{SkipType::stNone};

Referenced by process_filament_change(), process_filament_change(), process_G1(), process_tags(), process_VG1(), reset(), and set_skippable_type().

m_start_position

AxisCoords Slic3r::GCodeProcessor::m_start_position

private

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

m_time_processor

TimeProcessor Slic3r::GCodeProcessor::m_time_processor

private

Referenced by GCodeProcessor(), apply_config(), apply_config(), calc_vmax_junction_deviation(), calculate_time(), enable_machine_envelope_processing(), finalize(), get_acceleration(), get_axis_max_acceleration(), get_axis_max_feedrate(), get_axis_max_jerk(), get_axis_max_jerk_with_jd(), get_custom_gcode_times(), get_extruder_change_time(), get_filament_load_time(), get_filament_unload_time(), get_first_layer_time(), get_junction_deviation(), get_prepare_time(), get_retract_acceleration(), get_time(), get_time_dhm(), get_travel_acceleration(), get_xyz_max_jerk(), is_stealth_time_estimator_enabled(), minimum_feedrate(), minimum_travel_feedrate(), process_custom_gcode_time(), process_elegoo_M6211(), process_filament_change(), process_filament_change(), process_G1(), process_M201(), process_M203(), process_M204(), process_M205(), process_M221(), process_M566(), process_M702(), process_SET_VELOCITY_LIMIT(), process_VG1(), reset(), run_post_process(), run_second_pass_injection(), set_acceleration(), set_retract_acceleration(), set_travel_acceleration(), simulate_st_synchronize(), store_move_vertex(), and update_estimated_times_stats().

m_travel_dist

float Slic3r::GCodeProcessor::m_travel_dist

private

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

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(), process_VG1(), and reset().

m_used_filaments

UsedFilaments Slic3r::GCodeProcessor::m_used_filaments

private

Referenced by finalize(), process_elegoo_M6211(), process_filaments(), process_G1(), process_tags(), process_VG1(), reset(), set_extrusion_role(), update_estimated_times_stats(), and update_slice_warnings().

m_virtual_flushing

bool Slic3r::GCodeProcessor::m_virtual_flushing

private

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

m_width

float Slic3r::GCodeProcessor::m_width

private

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

m_wipe_tower

bool Slic3r::GCodeProcessor::m_wipe_tower

private

Referenced by process_tags(), and reset().

m_wiping

bool Slic3r::GCodeProcessor::m_wiping

private

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

m_x_offset

double Slic3r::GCodeProcessor::m_x_offset { 0 }

private

{ 0 };

Referenced by add_object_mass(), check_multi_extruder_gcode_valid(), process_G1(), set_xy_offset(), and store_move_vertex().

m_y_offset

double Slic3r::GCodeProcessor::m_y_offset { 0 }

private

{ 0 };

Referenced by add_object_mass(), check_multi_extruder_gcode_valid(), process_G1(), set_xy_offset(), and store_move_vertex().

m_z_offset

float Slic3r::GCodeProcessor::m_z_offset

private

Referenced by add_object_mass(), apply_config(), apply_config(), check_multi_extruder_gcode_valid(), finalize(), process_G1(), reset(), and store_move_vertex().

m_zero_layer_height

float Slic3r::GCodeProcessor::m_zero_layer_height

private

Referenced by reset().

Machine_End_GCode_Start_Tag

const std::string Slic3r::GCodeProcessor::Machine_End_GCode_Start_Tag = " MACHINE_END_GCODE_START"

static

Referenced by Slic3r::GCode::_do_export(), process_tags(), and run_post_process().

Machine_Start_GCode_End_Tag

const std::string Slic3r::GCodeProcessor::Machine_Start_GCode_End_Tag = " MACHINE_START_GCODE_END"

static

Referenced by Slic3r::GCode::_do_export(), and run_post_process().

Nozzle_Change_End_Tag

const std::string Slic3r::GCodeProcessor::Nozzle_Change_End_Tag = " NOZZLE_CHANGE_END"

static

Referenced by Slic3r::WipeTower::ramming(), and run_post_process().

Nozzle_Change_Start_Tag

const std::string Slic3r::GCodeProcessor::Nozzle_Change_Start_Tag = " NOZZLE_CHANGE_START"

static

Referenced by Slic3r::WipeTower::ramming(), and run_post_process().

Output_Block_Size

size_t Slic3r::GCodeProcessor::Output_Block_Size = 65536

staticconstexpr

Referenced by Slic3r::anonymous_namespace{GCodeProcessor.cpp}::GCodeFileWriter::append().

Producers

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

staticprivate

Initial value:

= {
    
    
    { EProducer::OrcaSlicer, SLIC3R_APP_NAME },
    { EProducer::OrcaSlicer, "generated by OrcaSlicer" },
    { EProducer::OrcaSlicer, "generated by BambuStudio" },
    { EProducer::OrcaSlicer, "BambuStudio" }
    
    
    
    
    
    
    
    
}

Referenced by detect_producer().

Reserved_Tags

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

staticprivate

Referenced by contains_reserved_tag(), contains_reserved_tags(), and reserved_tag().

Reserved_Tags_compatible

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

staticprivate

Referenced by contains_reserved_tag(), contains_reserved_tags(), and reserved_tag().

s_IsBBLPrinter

bool Slic3r::GCodeProcessor::s_IsBBLPrinter = true

static

Referenced by Slic3r::WipeTowerWriter::WipeTowerWriter(), Slic3r::WipeTowerWriter2::WipeTowerWriter2(), Slic3r::_BBS_3MF_Exporter::_add_slice_info_config_file_to_archive(), contains_reserved_tag(), Slic3r::GCode::do_export(), Slic3r::Print::export_gcode_from_previous_file(), Slic3r::GUI::Plater::load_gcode(), process_file(), process_G29(), Slic3r::Print::reload_gcode_moves(), reserved_tag(), and run_post_process().

s_result_id

unsigned int Slic3r::GCodeProcessor::s_result_id = 0

staticprivate

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

Skippable_End_Tag

const std::string Slic3r::GCodeProcessor::Skippable_End_Tag = " SKIPPABLE_END"

static

Referenced by process_tags(), and run_post_process().

Skippable_Start_Tag

const std::string Slic3r::GCodeProcessor::Skippable_Start_Tag = " SKIPPABLE_START"

static

Referenced by process_tags(), and run_post_process().

Skippable_Type_Tag

const std::string Slic3r::GCodeProcessor::Skippable_Type_Tag = " SKIPTYPE: "

static

Referenced by process_tags().

Toolchange_Wipe_Tag

const std::string Slic3r::GCodeProcessor::Toolchange_Wipe_Tag = " CP_TOOLCHANGE_WIPE"

static

Referenced by run_post_process(), and Slic3r::WipeTower::toolchange_wipe_new().

VFlush_End_Tag

const std::string Slic3r::GCodeProcessor::VFlush_End_Tag = " VFLUSH_END"

staticprivate

Referenced by process_tags().

VFlush_Start_Tag

const std::string Slic3r::GCodeProcessor::VFlush_Start_Tag = " VFLUSH_START"

staticprivate

Referenced by process_tags().

Wipe_Height

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

static

Referenced by finalize().

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:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/GCodeProcessor.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/ElegooGCodeProcessorHelper.cpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/GCodeProcessor.cpp