Slic3r::BeltGCode Class Reference

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

Inheritance diagram for Slic3r::BeltGCode:

Collaboration diagram for Slic3r::BeltGCode:

Public Member Functions
void	do_export (Print *print, const char *path, GCodeProcessorResult *result=nullptr, ThumbnailsGeneratorCallback thumbnail_cb=nullptr)
void	export_layer_filaments (GCodeProcessorResult *result)
void	set_gcode_offset (double x, double y)
void	set_gcode_offset_with_imex_shift (double x, double y, double imex_x, double imex_y)
const Vec2d &	origin () const
void	set_origin (const Vec2d &pointf)
void	set_origin (const coordf_t x, const coordf_t y)
Point	last_pos () const
Vec2d	point_to_gcode (const Point &point) const
Vec3d	point_to_gcode (const Point3 &point) const
Point	gcode_to_point (const Vec2d &point) const
Vec2d	point_to_gcode_quantized (const Point &point) const
Vec3d	point_to_gcode_quantized (const Point3 &point) const
const FullPrintConfig &	config () const
const Layer *	layer () const
GCodeWriter &	writer ()
const GCodeWriter &	writer () const
PlaceholderParser &	placeholder_parser ()
const PlaceholderParser &	placeholder_parser () const
std::string	placeholder_parser_process (const std::string &name, const std::string &templ, unsigned int current_filament_id, const DynamicConfig *config_override=nullptr)
bool	enable_cooling_markers () const
std::string	extrusion_role_to_string_for_parser (const ExtrusionRole &)
float	interpolate_value_across_layers (float start_value, float end_value, float step=0.0f) const
unsigned int	layer_count () const
void	set_layer_count (unsigned int value)
void	apply_print_config (const PrintConfig &print_config)
std::string	travel_to (const Point &point, ExtrusionRole role, std::string comment, double z=DBL_MAX)
bool	needs_retraction (const Polyline &travel, ExtrusionRole role, LiftType &lift_type)
std::string	retract (bool toolchange=false, bool is_last_retraction=false, LiftType lift_type=LiftType::NormalLift, bool apply_instantly=false, ExtrusionRole role=erNone)
std::string	unretract (float extra_retract=0.f)
std::string	set_extruder (unsigned int extruder_id, double print_z, bool by_object=false, int toolchange_temp_override=-1, bool defer_temp_wait=false)
std::string	set_filament_pressure_advance (unsigned int filament_id, int tool=-1)
bool	is_BBL_Printer ()
WipeTowerType	wipe_tower_type ()
void	assign_object_label_ids (Print &print)
std::string	set_object_info (Print *print)
size_t	get_filament_config_index (int filament_id) const
size_t	get_filament_config_index (int filament_id, size_t layer_id) const
size_t	get_nozzle_config_index (int filament_id) const

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

Protected Member Functions
void	init_belt_writer (Print &print) override
void	write_belt_header (GCodeOutputStream &file, const Print &print) override
void	on_set_origin (const PrintObject *obj, const Point &inst_shift) override
virtual bool	should_disable_arc_fitting () const
void	_do_export (Print &print, GCodeOutputStream &file, ThumbnailsGeneratorCallback thumbnail_cb)
std::string	generate_skirt (const Print &print, const ExtrusionEntityCollection &skirt, const Point &offset, const float skirt_start_angle, const LayerTools &layer_tools, const Layer &layer, unsigned int extruder_id, std::vector< coordf_t > &skirt_done)
std::string	generate_object_skirt_group (const Print &print, const PrintObject &object, size_t instance_id, const LayerTools &layer_tools, const Layer &layer, unsigned int extruder_id)
std::string	generate_object_brim (const Print &print, const PrintObject &object, size_t instance_id, bool first_layer, unsigned int extruder_id, const Layer *object_layer)
LayerResult	process_belt_brim_layer (const Print &print, const std::vector< LayerToPrint > &layers, const LayerTools &layer_tools, const bool last_layer, const size_t single_object_instance_idx, const int most_used_extruder)
std::string	process_layer_change_gcode (const Print &print, coordf_t print_z, int most_used_extruder, bool has_wipe_tower)
std::string	emit_belt_brim_bands (const Print &print, const std::vector< LayerToPrint > &layers, const size_t single_object_instance_idx, const unsigned int extruder_id)
LayerResult	process_layer (const Print &print, const std::vector< LayerToPrint > &layers, const LayerTools &layer_tools, const bool last_layer, const std::vector< const PrintInstance * > *ordering, const int most_used_extruder, const size_t single_object_idx=size_t(-1), const bool prime_extruder=false)
void	process_layers (const Print &print, const ToolOrdering &tool_ordering, const std::vector< const PrintInstance * > &print_object_instances_ordering, const std::vector< std::pair< coordf_t, std::vector< LayerToPrint > > > &layers_to_print, GCodeOutputStream &output_stream)
void	process_layers (const Print &print, const ToolOrdering &tool_ordering, std::vector< LayerToPrint > layers_to_print, const size_t single_object_idx, GCodeOutputStream &output_stream, const bool prime_extruder=false)
void	check_placeholder_parser_failed ()
size_t	cur_extruder_index () const
size_t	get_extruder_id (unsigned int filament_id) const
void	update_placeholder_parser_with_variant_params ()
void	set_last_pos (const Point &pos)
void	set_last_pos (const Point3 &pos)
bool	last_pos_defined () const
void	set_extruders (const std::vector< unsigned int > &extruder_ids)
std::string	preamble ()
std::string	change_layer (coordf_t print_z)
void	mass_load_limited_machine_acceleration (const PrintStatistics &curr_print_statistics, const Print &print, double &y_acceleration_limit_res, double &accumulated_mass_res)
std::string	extrude_entity (const ExtrusionEntity &entity, const std::string &description="", double speed=-1., const std::vector< const ExtrusionEntity * > &region_perimeters={}, const WipeInwardSupport *wipe_support=nullptr)
std::string	extrude_loop (const ExtrusionLoop &loop, const std::string &description, double speed=-1., const std::vector< const ExtrusionEntity * > &region_perimeters={}, const Point *start_point=nullptr, const WipeInwardSupport *wipe_support=nullptr)
std::string	extrude_multi_path (const ExtrusionMultiPath &multipath, const std::string &description="", double speed=-1.)
std::string	extrude_path (const ExtrusionPath &path, const std::string &description="", double speed=-1.)
std::vector< InstanceToPrint >	sort_print_object_instances (std::vector< ObjectByExtruder > &objects_by_extruder, const std::vector< LayerToPrint > &layers, const std::vector< const PrintInstance * > *ordering, const size_t single_object_instance_idx)
std::string	extrude_perimeters (const Print &print, const std::vector< ObjectByExtruder::Island::Region > &by_region, bool is_first_layer, bool is_infill_first, bool unsupported_loops_only=false)
std::string	extrude_infill (const Print &print, const std::vector< ObjectByExtruder::Island::Region > &by_region, bool ironing)
std::string	extrude_support (const ExtrusionEntityCollection &support_fills, const ExtrusionRole support_extrusion_role)
void	compute_farthest_point (const std::vector< LayerToPrint > &layers, int most_used_extruder, const std::map< std::pair< const SupportLayer *, ExtrusionRole >, unsigned int > &support_filaments)
DynamicConfig	timelapse_gcode_config (const Print &print, coordf_t print_z, int most_used_extruder, const std::vector< const PrintObject * > *printed_objects, bool skip_pos_pick)
std::string	generate_timelapse_gcode (const Print &print, coordf_t print_z, int most_used_extruder, const std::set< size_t > *layer_object_label_ids, const std::vector< const PrintObject * > *printed_objects, bool skip_pos_pick=false)
LiftType	to_lift_type (ZHopType z_hop_types)
const std::string &	instance_name (const PrintInstance &instance)
std::string	_encode_label_ids_to_base64 (std::vector< size_t > ids)
std::optional< ToolchangePositionState >	capture_toolchange_position ()
void	synchronize_toolchange_position (const ToolchangePositionState &before, const std::string &emitted_gcode)
int	get_bed_temperature (const int extruder_id, const bool is_first_layer, const BedType bed_type) const
int	get_highest_bed_temperature (const bool is_first_layer, const Print &print) const
void	update_layer_related_config (int layer_id)
double	calc_max_volumetric_speed (const double layer_height, const double line_width, const std::string co_str)
std::string	_extrude (const ExtrusionPath &path, const std::string &path_description="", double speed=-1)
bool	_needSAFC (const ExtrusionPath &path)
void	print_machine_envelope (GCodeOutputStream &file, Print &print)
void	_print_first_layer_bed_temperature (GCodeOutputStream &file, Print &print, const std::string &gcode, unsigned int first_printing_extruder_id, bool wait)
void	_print_first_layer_extruder_temperatures (GCodeOutputStream &file, Print &print, const std::string &gcode, unsigned int first_printing_extruder_id, bool wait)
bool	on_first_layer () const
bool	on_first_layer (const Vec3d &point_slicing_mm) const
int	effective_layer_index_for_point (const Vec3d &point_slicing_mm) const
double	first_layer_band_mm () const
bool	belt_height_above_floor (const Vec3d &point_slicing_mm, double &height_mm) const
int	belt_layer_past_first_layer_band (const Layer *object_layer) const
int	layer_id () const
bool	object_layer_over_raft () const

Static Protected Member Functions
static std::vector< LayerToPrint >	collect_layers_to_print (const PrintObject &object, bool skip_empty_first_layer=false)
static std::vector< std::pair< coordf_t, std::vector< LayerToPrint > > >	collect_layers_to_print (const Print &print)

Protected Attributes
double	m_multi_flow_segment_path_average_mm3_per_mm = 0
bool	m_multi_flow_segment_path_pa_set = false
double	m_last_mm3_mm = 0
std::set< ObjectInstanceID >	m_objsWithBrim
SeamPlacer	m_seam_placer
std::map< unsigned int, IslandOrderCacheEntry >	m_ordering_cache
ExtrusionQualityEstimator	m_extrusion_quality_estimator
Vec2d	m_origin
FullPrintConfig	m_config
DynamicConfig	m_calib_config
double	m_scaled_resolution
GCodeWriter	m_writer
struct Slic3r::GCode::PlaceholderParserIntegration	m_placeholder_parser_integration
OozePrevention	m_ooze_prevention
Wipe	m_wipe
AvoidCrossingPerimeters	m_avoid_crossing_perimeters
ExclusionVolumeTravelAvoidance	m_exclusion_volume_travel_avoidance
RetractWhenCrossingPerimeters	m_retract_when_crossing_perimeters
TimelapsePosPicker	m_timelapse_pos_picker
bool	m_timelapse_uses_pos { false }
bool	m_timelapse_uses_clear_to_x0 { false }
FarthestPointTimelapseContext	m_farthest_point_timelapse
bool	m_enable_loop_clipping
bool	m_resonance_avoidance
bool	m_enable_cooling_markers
bool	m_enable_exclude_object
std::vector< size_t >	m_label_objects_ids
std::unordered_map< const PrintInstance *, std::string >	m_instance_names
std::array< bool, ExtrusionRole::erCount >	m_is_role_based_fan_on
std::array< int, ExtrusionRole::erCount >	m_role_based_fan_marker_layer
bool	m_enable_extrusion_role_markers
ExtrusionRole	m_last_processor_extrusion_role
unsigned int	m_layer_count
int	m_layer_index
const Layer *	m_layer
bool	m_object_layer_over_raft
ExtrusionRole	m_last_extrusion_role
ExtrusionRole	m_last_notgapfill_extrusion_role
float	m_last_height { 0.0f }
float	m_last_layer_z { 0.0f }
float	m_max_layer_z { 0.0f }
float	m_last_width { 0.0f }
double	m_last_layer_accumulated_mass { 0.0 }
Point3	m_last_pos
bool	m_last_pos_defined
std::unique_ptr< CoolingBuffer >	m_cooling_buffer
std::unique_ptr< SpiralVase >	m_spiral_vase
std::unique_ptr< PressureEqualizer >	m_pressure_equalizer
std::unique_ptr< AdaptivePAProcessor >	m_pa_processor
std::string	m_imex_parallel_mode
std::map< int, int >	m_imex_head_filament_map
std::unique_ptr< WipeTowerIntegration >	m_wipe_tower
std::unique_ptr< SmallAreaInfillFlowCompensator >	m_small_area_infill_flow_compensator
std::vector< std::vector< coordf_t > >	m_skirt_group_done
bool	m_brim_done
bool	m_second_layer_things_done
std::pair< const PrintObject *, Point >	m_last_obj_copy
int	m_timelapse_warning_code = 0
bool	m_support_traditional_timelapse = true
Print *	m_print {nullptr}
std::vector< const PrintObject * >	m_printed_objects
GCodeProcessor	m_processor
std::optional< GCodeProcessor::PositionState >	m_pending_start_gcode_position
std::unique_ptr< FanMover >	m_fan_mover
Print *	m_curr_print = nullptr
unsigned int	m_toolchange_count
coordf_t	m_nominal_z
double	m_sub_layer_flow_ratio = 0.0
double	m_sub_layer_height = 0.0
bool	m_need_change_layer_lift_z = false
int	m_start_gcode_filament = -1
std::string	m_filament_instances_code
size_t	m_cur_layer_idx {0}
ConfigIndexCache	m_filament_index_cache
ConfigIndexCache	m_nozzle_index_cache
std::optional< coordf_t >	m_belt_brim_z
const PrintObject *	m_belt_floor_object {nullptr}
bool	m_belt_in_band {false}
std::set< unsigned int >	m_initial_layer_extruders
std::vector< std::vector< unsigned int > >	m_sorted_layer_filaments

Detailed Description

Member Function Documentation

_do_export()

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

protectedinherited

{
    PROFILE_FUNC();
 
    m_print = &print;
    m_timelapse_pos_picker.init(&print,m_writer.get_xy_offset().cast<coord_t>());
    {
        // Runs the costly per-layer snapshot picker only for a template that names its results.
        const std::string &templ      = print.config().time_lapse_gcode.value;
        m_timelapse_uses_pos          = templ.find("timelapse_pos") != std::string::npos ||
                                        templ.find("has_timelapse_safe_pos") != std::string::npos;
        m_timelapse_uses_clear_to_x0  = templ.find("clear_to_x0") != std::string::npos;
    }
    // init as filament map
    update_layer_related_config(0);
 
    DoExport::init_gcode_processor(print.config(), m_processor, print.get_layered_nozzle_group_result());
    set_mass_locator(m_processor, print);
    const bool is_bbl_printers = print.is_BBL_printer();
    const bool skip_config_block = print.config().gcode_skip_config_block;
    const WipeTowerType wipe_tower_type = print.wipe_tower_type();
    m_calib_config.clear();
    // Orca: Calibration overrides are reapplied after object/region settings in _extrude().
    // Keep inward wiping from masking retraction and pressure advance artifacts.
    switch (print.calib_mode()) {
    case CalibMode::Calib_PA_Line:
    case CalibMode::Calib_PA_Pattern:
    case CalibMode::Calib_PA_Tower:
    case CalibMode::Calib_Auto_PA_Line:
    case CalibMode::Calib_Retraction_tower:
        m_calib_config.set_key_value("wipe_inward", new ConfigOptionBool(false));
        break;
    default:
        break;
    }
    // resets analyzer's tracking data
    m_last_height  = 0.f;
    m_last_layer_z = 0.f;
    m_max_layer_z  = 0.f;
    m_last_width = 0.f;
    m_last_layer_accumulated_mass = 0.0;
    m_is_role_based_fan_on.fill(false);
    m_role_based_fan_marker_layer.fill(-1);
 
    m_fan_mover.reset();
    m_ordering_cache.clear();
 
    // Belt printer: initialize belt-specific writer via virtual hook.
    this->init_belt_writer(print);
    m_writer.set_is_bbl_machine(is_bbl_printers);
 
    // G-code axis remap. Only belt printers get one (see
    // BeltTransformPipeline::axis_remap_enabled): a remap left in a profile must
    // not change a non-belt print. Sync the writer's remap state to the current
    // export UNCONDITIONALLY — even at the identity mapping (0,1,2) — so a reused
    // writer never retains a stale non-identity mapping from a prior export.
    // has_axis_remap() returns false at identity, so identity/default output stays
    // unchanged.
    {
        const bool remap = BeltTransformPipeline::axis_remap_enabled(print.config());
        int rx = remap ? int(print.config().gcode_remap_x.value) : int(RemapAxis::PosX);
        int ry = remap ? int(print.config().gcode_remap_y.value) : int(RemapAxis::PosY);
        int rz = remap ? int(print.config().gcode_remap_z.value) : int(RemapAxis::PosZ);
        m_writer.set_axis_remap(rx, ry, rz);
        BoundingBoxf bbox_bed(print.config().printable_area.values);
        m_writer.set_build_volume_max(Vec3d(bbox_bed.max.x(), bbox_bed.max.y(),
                                              print.config().printable_height.value));
    }
 
    // Belt writers only: travel-speed selection becomes per-point (see
    // GCodeWriter::uses_pointwise_travel_speed()), which must not change for
    // non-belt printers. The writer gets the same test the extrusions use, so a
    // travel is judged against the belt surface (belt_height_above_floor) exactly
    // like the path it leads to. Writer points carry the G-code origin and
    // extruder offset that point_to_gcode() added; the belt surface is described
    // in the object's own frame.
    if (print.config().belt_printer.value) {
        m_writer.set_first_layer_point_test([this](const Vec3d &point_logical) {
            const Vec2d extruder_offset = m_writer.filament() != nullptr ? EXTRUDER_CONFIG(extruder_offset) : Vec2d::Zero();
            // Undo what point_to_gcode() added (m_origin, minus the extruder offset) and
            // what the writer then took off (its XY offset, the plate origin).
            const Vec2d plate_offset = m_writer.get_xy_offset().cast<double>();
            return this->on_first_layer(Vec3d(point_logical.x() - (m_origin.x() - plate_offset.x()) + extruder_offset.x(),
                                              point_logical.y() - (m_origin.y() - plate_offset.y()) + extruder_offset.y(),
                                              point_logical.z()));
        });
    }
 
    // How many times will be change_layer() called?
    // change_layer() in turn increments the progress bar status.
    m_layer_count = 0;
    // On a belt, collect_layers_to_print() drops the layers that print nothing (an
    // object's empty lead-in), so they must not be counted here either or the layer
    // count in the file disagrees with its layer changes.
    const bool belt = print.config().belt_printer.value;
    if (print.config().print_sequence == PrintSequence::ByObject) {
        // Add each of the object's layers separately.
        for (auto object : print.objects()) {
            std::vector<coordf_t> zs;
            zs.reserve(object->layers().size() + object->support_layers().size());
            for (auto layer : object->layers())
                if (! belt || belt_object_layer_prints_something(*object, *layer))
                    zs.push_back(layer->print_z);
            for (auto layer : object->support_layers())
                if (! belt || layer->has_extrusions())
                    zs.push_back(layer->print_z);
            // Belt brim apron bands each get their own change_layer() call.
            for (const BeltBrimBand &band : object->belt_brim_prologue())
                zs.push_back(band.print_z);
            if (zs.empty())
                continue;
            std::sort(zs.begin(), zs.end());
            //BBS: merge numerically very close Z values.
            auto end_it = std::unique(zs.begin(), zs.end());
            unsigned int temp_layer_count = (unsigned int)(end_it - zs.begin());
            for (auto it = zs.begin(); it != end_it - 1; it++) {
                if (abs(*it - *(it + 1)) < EPSILON)
                    temp_layer_count--;
            }
            m_layer_count += (unsigned int)(object->instances().size() * temp_layer_count);
        }
    } else {
        // Print all objects with the same print_z together.
        std::vector<coordf_t> zs;
        for (auto object : print.objects()) {
            zs.reserve(zs.size() + object->layers().size() + object->support_layers().size());
            for (auto layer : object->layers())
                if (! belt || belt_object_layer_prints_something(*object, *layer))
                    zs.push_back(layer->print_z);
            for (auto layer : object->support_layers())
                if (! belt || layer->has_extrusions())
                    zs.push_back(layer->print_z);
            // See the ByObject branch: apron bands are real printed layers.
            for (const BeltBrimBand &band : object->belt_brim_prologue())
                zs.push_back(band.print_z);
        }
        if (!zs.empty())
        {
            std::sort(zs.begin(), zs.end());
            //BBS: merge numerically very close Z values.
            auto end_it = std::unique(zs.begin(), zs.end());
            m_layer_count = (unsigned int)(end_it - zs.begin());
            for (auto it = zs.begin(); it != end_it - 1; it++) {
                if (abs(*it - *(it + 1)) < EPSILON)
                    m_layer_count--;
            }
        }
    }
    print.throw_if_canceled();
 
    m_enable_cooling_markers = true;
    this->apply_print_config(print.config());
    m_config.apply(print.default_object_config());
    m_config.apply(print.default_region_config());
 
    //m_volumetric_speed = DoExport::autospeed_volumetric_limit(print);
    print.throw_if_canceled();
 
    if (print.config().spiral_mode.value)
        m_spiral_vase = make_unique<SpiralVase>(print.config());
 
    if (print.config().max_volumetric_extrusion_rate_slope.value > 0){
        m_pressure_equalizer = make_unique<PressureEqualizer>(print.config());
        m_enable_extrusion_role_markers = (bool)m_pressure_equalizer;
    } else
      m_enable_extrusion_role_markers = false;
 
    if (m_config.small_area_infill_flow_compensation.value && !m_config.small_area_infill_flow_compensation_model.empty())
        m_small_area_infill_flow_compensator = make_unique<SmallAreaInfillFlowCompensator>(print.config());
    
    // Prepare the helper object for replacing placeholders in custom G-code and output filename.
    m_placeholder_parser_integration.parser = print.placeholder_parser();
    m_placeholder_parser_integration.parser.update_timestamp();
    m_placeholder_parser_integration.parser.update_user_name();
    m_placeholder_parser_integration.context.rng = std::mt19937(std::chrono::high_resolution_clock::now().time_since_epoch().count());
    // Enable passing global variables between PlaceholderParser invocations.
    m_placeholder_parser_integration.context.global_config = std::make_unique<DynamicConfig>();
    print.update_object_placeholders(m_placeholder_parser_integration.parser.config_writable(), ".gcode");
 
    // Get optimal tool ordering to minimize tool switches of a multi-exruder print.
    // For a print by objects, find the 1st printing object.
    ToolOrdering tool_ordering;
    unsigned int initial_extruder_id = (unsigned int)-1;
    //BBS: first non-support filament extruder
    unsigned int initial_non_support_extruder_id = (unsigned int) -1;
    unsigned int final_extruder_id   = (unsigned int)-1;
    bool         has_wipe_tower      = false;
    print.m_statistics_by_extruder_count.clear();
    std::vector<int>                                    first_filaments;
    std::vector<int>                                    first_non_support_filaments;
    std::vector<const PrintInstance*>           print_object_instances_ordering;
    std::vector<const PrintInstance*>::const_iterator   print_object_instance_sequential_active;
    std::vector<const PrintInstance *>::const_iterator  first_has_extrude_print_object;
    //resize
    first_non_support_filaments.resize(print.config().nozzle_diameter.size(), -1);
    first_filaments.resize(print.config().nozzle_diameter.size(), -1);
    float max_additional_fan = 0.f;
    // Sequential selector prints consume the per-object plans cached by Print::process — they were
    // planned with cross-object nozzle-status threading and match the published stitched result; a
    // fresh construction here would re-plan from a different seed. Static sequential prints keep
    // the fresh per-object construction (byte-identical output).
    const auto &seq_dynamic_orderings   = print.sequential_dynamic_orderings();
    const bool  use_seq_dynamic_cache   = print.is_dynamic_group_reorder() && !seq_dynamic_orderings.empty();
    if (print.config().print_sequence == PrintSequence::ByObject) {
        // Order object instances for sequential print.
        print_object_instances_ordering = sort_object_instances_by_model_order(print);
//        print_object_instances_ordering = sort_object_instances_by_max_z(print);
        // Find the 1st printing object, find its tool ordering and the initial extruder ID.
        print_object_instance_sequential_active = print_object_instances_ordering.begin();
        first_has_extrude_print_object          = print_object_instance_sequential_active;
        bool find_fist_non_support_filament = false;
        for (; print_object_instance_sequential_active != print_object_instances_ordering.end(); ++ print_object_instance_sequential_active) {
            auto cached_ordering = use_seq_dynamic_cache ? seq_dynamic_orderings.find((*print_object_instance_sequential_active)->print_object) : seq_dynamic_orderings.end();
            if (cached_ordering != seq_dynamic_orderings.end()) {
                tool_ordering = cached_ordering->second;
            } else {
                tool_ordering = ToolOrdering(*(*print_object_instance_sequential_active)->print_object, initial_extruder_id);
                tool_ordering.sort_and_build_data(*(*print_object_instance_sequential_active)->print_object,initial_extruder_id);
            }
            float temp_max_additional_fan = tool_ordering.cal_max_additional_fan(print.config());
            if(temp_max_additional_fan > max_additional_fan )
                        max_additional_fan = temp_max_additional_fan;
            if (!find_fist_non_support_filament && tool_ordering.first_extruder() != (unsigned int) -1) {
                //BBS: try to find the non-support filament extruder if is multi color and initial_extruder is support filament
                if (initial_extruder_id == (unsigned int) -1) {
                    initial_extruder_id = tool_ordering.first_extruder();
                    first_has_extrude_print_object = print_object_instance_sequential_active;
                }
 
                find_fist_non_support_filament = tool_ordering.cal_non_support_filaments(print.config(), initial_non_support_extruder_id, first_non_support_filaments, first_filaments);
            }
        }
        if (initial_extruder_id == static_cast<unsigned int>(-1))
            // No object to print was found, cancel the G-code export.
            throw Slic3r::SlicingError(_(L("No object can be printed. It may be too small.")));
        // We don't allow switching of extruders per layer by Model::custom_gcode_per_print_z in sequential mode.
        // Use the extruder IDs collected from Regions.
        this->set_extruders(print.extruders());
 
        has_wipe_tower = print.has_wipe_tower() && tool_ordering.has_wipe_tower();
    } else {
        // Find tool ordering for all the objects at once, and the initial extruder ID.
        // If the tool ordering has been pre-calculated by Print class for wipe tower already, reuse it.
        tool_ordering = print.tool_ordering();
        tool_ordering.assign_custom_gcodes(print);
        float temp_max_additional_fan = tool_ordering.cal_max_additional_fan(print.config());
        if(temp_max_additional_fan > max_additional_fan )
                        max_additional_fan = temp_max_additional_fan;
        if (tool_ordering.all_extruders().empty())
            // No object to print was found, cancel the G-code export.
            throw Slic3r::SlicingError(_(L("No object can be printed. It may be too small.")));
        has_wipe_tower = print.has_wipe_tower() && tool_ordering.has_wipe_tower();
        // Orca: support all extruder priming
        initial_extruder_id = (wipe_tower_type == WipeTowerType::Type2 && has_wipe_tower && !print.config().single_extruder_multi_material_priming) ?
            // The priming towers will be skipped.
            tool_ordering.all_extruders().back() :
            // Don't skip the priming towers.
            tool_ordering.first_extruder();
 
        //BBS: try to find the non-support filament extruder if is multi color and initial_extruder is support filament
        if (initial_extruder_id != static_cast<unsigned int>(-1)) {
            // BBS: try to find the non-support filament extruder if is multi color and initial_extruder is support filament
            // check if has non support filaments
            tool_ordering.cal_non_support_filaments(print.config(), initial_non_support_extruder_id, first_non_support_filaments, first_filaments);
        }
 
        // In non-sequential print, the printing extruders may have been modified by the extruder switches stored in Model::custom_gcode_per_print_z.
        // Therefore initialize the printing extruders from there.
        this->set_extruders(tool_ordering.all_extruders());
        print_object_instances_ordering =
            // By default, order object instances using nearest-neighbor chaining plus
            // 2-opt and crossing-removal post-processing.
            (print.config().print_order == PrintOrder::Default ? chain_print_object_instances(print)
            // Snake: serpentine row traversal + 2-opt
            : (print.config().print_order == PrintOrder::Snake ? chain_print_object_instances_snake(print)
            // Best of all: run every strategy, pick the shortest total path
            : (print.config().print_order == PrintOrder::BestOfStrategies ? chain_print_object_instances_best_of(print)
            // Otherwise same order as the object list
            : sort_object_instances_by_model_order(print))));
 
 
 
 
    }
    if (initial_extruder_id == (unsigned int)-1) {
        // Nothing to print!
        initial_extruder_id = 0;
        initial_non_support_extruder_id = 0;
    }
 
    //could not find non support filmanet, use fisrt print filament
    if (initial_non_support_extruder_id == (unsigned int) -1)
        initial_non_support_extruder_id = initial_extruder_id;
 
    print.throw_if_canceled();
 
    // Taken before the object loop, which reassigns initial_extruder_id when printing by object.
    const int compat_first_layer_bed_temp = m_config.bed_temperature_formula == BedTempFormula::btfHighestTemp ?
                                                get_highest_bed_temperature(true, print) :
                                                get_bed_temperature(initial_extruder_id, true, print.config().curr_bed_type);
    const int compat_first_layer_nozzle_temp =
        print.config().nozzle_temperature_initial_layer.get_at(get_filament_config_index((int) initial_extruder_id));
 
    int extruder_id = get_extruder_id(initial_extruder_id);
 
    m_cooling_buffer = make_unique<CoolingBuffer>(*this);
    m_cooling_buffer->set_current_extruder(initial_extruder_id, extruder_id);
 
    // Orca: Initialise AdaptivePA processor filter
    m_pa_processor = std::make_unique<AdaptivePAProcessor>(*this);
 
    // Update output variables after the extruders were initialized.
    m_placeholder_parser_integration.init(m_writer);
 
    // Let the start-up script prime the 1st printing tool.
 
    auto match_physical_extruder_for_each_filament = [](std::vector<int> &filaments, const FullPrintConfig &config) {
        // match the filament to the physical extruder
        std::vector<int> physicial_first_filaments;
        physicial_first_filaments.resize(filaments.size());
        for (int extruder_id = 0; extruder_id < filaments.size(); extruder_id++) {
            physicial_first_filaments[config.physical_extruder_map.get_at(extruder_id)] = filaments[extruder_id];
        }
        filaments = physicial_first_filaments;
    };
    match_physical_extruder_for_each_filament(first_filaments, m_config);
    this->placeholder_parser().set("first_tools", new ConfigOptionInts(first_filaments));
    this->placeholder_parser().set("first_filaments", new ConfigOptionInts(first_filaments));
    this->placeholder_parser().set("initial_tool", initial_extruder_id);
    this->placeholder_parser().set("initial_extruder", initial_extruder_id);
    //BBS
    match_physical_extruder_for_each_filament(first_non_support_filaments, m_config);
 
    // Logical nozzle grouping for this print (null on paths that don't populate it).
    auto group_result = m_print->get_layered_nozzle_group_result();
    std::vector<int> first_non_support_hotends;
    first_non_support_hotends.reserve(first_non_support_filaments.size());
    for (int filament_id : first_non_support_filaments)
        first_non_support_hotends.push_back(filament_id < 0 ? -1 :
            first_hotend_id_for_gcode_placeholder(group_result, is_bbl_printers, filament_id, (int) get_extruder_id(filament_id)));
 
    this->placeholder_parser().set("first_non_support_tools", new ConfigOptionInts(first_non_support_filaments));
    this->placeholder_parser().set("first_non_support_filaments", new ConfigOptionInts(first_non_support_filaments));
    this->placeholder_parser().set("first_non_support_hotend", new ConfigOptionInts(first_non_support_hotends));
    this->placeholder_parser().set("initial_no_support_tool", initial_non_support_extruder_id);
    this->placeholder_parser().set("initial_no_support_extruder", initial_non_support_extruder_id);
    this->placeholder_parser().set("initial_no_support_hotend",
        first_hotend_id_for_gcode_placeholder(group_result, is_bbl_printers, (int) initial_non_support_extruder_id,
                                              (int) get_extruder_id(initial_non_support_extruder_id)));
    this->placeholder_parser().set("current_extruder", initial_extruder_id);
    this->placeholder_parser().set("current_hotend",
        first_hotend_id_for_gcode_placeholder(group_result, is_bbl_printers, (int) initial_extruder_id, extruder_id));
    this->placeholder_parser().set("current_filament_id", (int) initial_extruder_id);
    this->placeholder_parser().set("current_extruder_id", extruder_id);
    this->placeholder_parser().set("current_nozzle_id",
        first_nozzle_id_for_gcode_placeholder(group_result, (int) initial_extruder_id, extruder_id));
    // Initial filament/nozzle vocabulary
    this->placeholder_parser().set("initial_filament_id", (int) initial_extruder_id);
    this->placeholder_parser().set("initial_no_support_filament_id", (int) initial_non_support_extruder_id);
    this->placeholder_parser().set("initial_nozzle_id", first_nozzle_id_for_gcode_placeholder(group_result, (int) initial_extruder_id, extruder_id));
    this->placeholder_parser().set("nozzle_diameter_at_nozzle_id", new ConfigOptionFloats(get_nozzle_diameters_by_nozzle_id(group_result.get())));
    this->placeholder_parser().set("nozzle_volume_types", new ConfigOptionStrings(get_nozzle_volume_types_by_nozzle_id(group_result.get())));
    //Orca: set the key for compatibilty, scalar values for the initial extruder (variant-aware)
    {
        size_t fi = get_filament_config_index(initial_extruder_id);
        this->placeholder_parser().set("retraction_distance_when_cut", m_config.retraction_distances_when_cut.get_at(fi));
        this->placeholder_parser().set("long_retraction_when_cut", m_config.long_retractions_when_cut.get_at(fi));
        this->placeholder_parser().set("retraction_distance_when_ec", m_config.retraction_distances_when_ec.get_at(fi));
        this->placeholder_parser().set("long_retraction_when_ec", m_config.long_retractions_when_ec.get_at(fi));
    }
    this->placeholder_parser().set("temperature", new ConfigOptionInts(print.config().nozzle_temperature));
 
    // retraction_distances_when_cut (array), flush_volumetric_speeds, flush_temperatures and
    // filament_cooling_before_tower are set by update_placeholder_parser_with_variant_params()
    // with variant-aware remapping.
    this->placeholder_parser().set("long_retractions_when_cut",new ConfigOptionBools(m_config.long_retractions_when_cut));
    this->placeholder_parser().set("retraction_distances_when_ec", new ConfigOptionFloatsNullable(m_config.retraction_distances_when_ec));
    this->placeholder_parser().set("long_retractions_when_ec",new ConfigOptionBoolsNullable(m_config.long_retractions_when_ec));
 
    this->placeholder_parser().set("max_additional_fan", max_additional_fan);
    this->placeholder_parser().set("first_x_layer_fan_speed", new ConfigOptionFloats(m_config.first_x_layer_fan_speed));
    this->placeholder_parser().set("close_additional_fan_first_x_layers", new ConfigOptionInts(m_config.close_additional_fan_first_x_layers));
    this->placeholder_parser().set("additional_fan_full_speed_layer", new ConfigOptionInts(m_config.additional_fan_full_speed_layer));
 
    //Set variable for total layer count so it can be used in custom gcode.
    this->placeholder_parser().set("total_layer_count", m_layer_count);
    // Useful for sequential prints.
    this->placeholder_parser().set("current_object_idx", 0);
    // For the start / end G-code to do the priming and final filament pull in case there is no wipe tower provided.
    this->placeholder_parser().set("has_wipe_tower", has_wipe_tower);
 
    // Position where the nozzle waits to heat, just outside the wipe tower. The tower side is chosen
    // from the full-bed midpoint, then X is clamped to the region every extruder can reach (shared printable
    // polygon) = the full printable_area for all current single/dual printers, so existing output is unchanged.
    Vec2f wipe_tower_wait_pos       = Vec2f::Zero();
    bool  wipe_tower_wait_pos_valid = false;
    if (has_wipe_tower) {
        BoundingBoxf bbx = print.wipe_tower_data().bbx;
        bbx.translate(print.get_fake_wipe_tower().pos.cast<double>());
        BoundingBoxf printer_bed_bbx(m_config.printable_area.values);
        if (bbx.center().x() < printer_bed_bbx.center().x())
            wipe_tower_wait_pos = Vec2f(float(bbx.max.x() + 2.f), float(bbx.center().y()));
        else
            wipe_tower_wait_pos = Vec2f(float(bbx.min.x() - 2.f), float(bbx.center().y()));
        auto printer_bbx = unscaled(get_extents(print.get_extruder_shared_printable_polygon()));
        if (wipe_tower_wait_pos.x() < printer_bbx.min[0]) wipe_tower_wait_pos.x() = float(printer_bbx.min[0]);
        if (wipe_tower_wait_pos.x() > printer_bbx.max[0]) wipe_tower_wait_pos.x() = float(printer_bbx.max[0]);
        wipe_tower_wait_pos_valid = true;
    }
    this->placeholder_parser().set("wipe_tower_wait_pos_x", new ConfigOptionFloat(wipe_tower_wait_pos.x()));
    this->placeholder_parser().set("wipe_tower_wait_pos_y", new ConfigOptionFloat(wipe_tower_wait_pos.y()));
    this->placeholder_parser().set("wipe_tower_wait_pos_valid", new ConfigOptionBool(wipe_tower_wait_pos_valid));
    // Bambu Studio's names for the wait position, used by its profiles.
    this->placeholder_parser().set("wipe_tower_center_pos_x", new ConfigOptionFloat(wipe_tower_wait_pos.x()));
    this->placeholder_parser().set("wipe_tower_center_pos_y", new ConfigOptionFloat(wipe_tower_wait_pos.y()));
    this->placeholder_parser().set("wipe_tower_center_pos_valid", new ConfigOptionBool(wipe_tower_wait_pos_valid));
    this->placeholder_parser().set("has_single_extruder_multi_material_priming", wipe_tower_type == WipeTowerType::Type2 && has_wipe_tower && print.config().single_extruder_multi_material_priming);
    this->placeholder_parser().set("total_toolchanges", DoExport::resolve_total_toolchanges(print.wipe_tower_data(), print.tool_ordering()));
    this->placeholder_parser().set("num_extruders", int(print.config().nozzle_diameter.values.size()));
    this->placeholder_parser().set("retract_length", new ConfigOptionFloats(print.config().retraction_length));
 
    //Orca: support max MAXIMUM_EXTRUDER_NUMBER extruders/filaments
    std::vector<unsigned char> is_extruder_used(std::max(size_t(MAXIMUM_EXTRUDER_NUMBER), print.config().filament_diameter.size()), 0);
    for (unsigned int extruder : tool_ordering.all_extruders())
        is_extruder_used[extruder] = true;
 
    // Orca IMEX: mark the LOGICAL filament slot each active SECONDARY carriage
    // will load during the print.  is_extruder_used is logical-slot indexed
    // (consumed as `is_extruder_used[N]` in machine_start_gcode templates), but
    // get_imex_active_tools returns PHYSICAL extruder indices.  On any printer
    // with physical_extruder_map size > 1 (MMU/AFC), writing the physical index
    // into a logical-indexed array marks the wrong slot.
    //
    // The primary is intentionally SKIPPED here — its filament is already
    // covered by tool_ordering.all_extruders() above (which lists the slots the
    // objects on the plate are actually assigned to).  Marking the primary
    // again via the pem `first_filament_for_physical_head` fallback would
    // pollute is_extruder_used with the *first* slot routed to the primary's
    // physical extruder, which is generally not the slot the user assigned to
    // the printing object.  Same skip-primary pattern as the IMEX PA emission
    // path in _do_export().
    //
    // For secondaries: translate physical -> logical via the per-plate
    // imex_head_filament_map (set by the IMEX ghost picker), with
    // first_filament_for_physical_head as the fallback when no override is set.
    if (print.config().is_imex.value && !print.objects().empty()
        && initial_extruder_id != (unsigned int)-1) {
        const auto plate_head_map = parse_imex_head_filament_map(
            print.objects().front()->config().imex_head_filament_map.value);
        const ConfigOptionInts& pem = print.config().physical_extruder_map;
        // Bounds-checked, not get_at(): a clamp would suppress whichever head sits at pem[0].
        // A miss stays -1 and matches no head, so nothing is skipped -- see IMEXHelpers.hpp.
        const int primary_physical =
            ((int) initial_extruder_id >= 0 &&
             (int) initial_extruder_id < (int) pem.values.size())
                ? pem.values[(int) initial_extruder_id]
                : -1;
        // Bound by the array, not by the filament count. The array is padded to
        // MAXIMUM_EXTRUDER_NUMBER on purpose: start G-code addresses HEADS through it
        // (fdm_toolchanger_common.json gates M104 T0..T5 on it), and a parallel copy print has
        // more heads than filaments by definition. PlaceholderParser clamps an out-of-range
        // first_layer_temperature read to filament 0, which is the right temperature when every
        // head is printing the same filament. Narrowing this to the filament count leaves the
        // secondary carriages unheated.
        for (int logical : imex_secondary_logical_slots(
                get_imex_active_tools(print), primary_physical, plate_head_map, pem))
            if (logical >= 0 && logical < (int) is_extruder_used.size())
                is_extruder_used[logical] = true;
    }
 
    this->placeholder_parser().set("is_extruder_used", new ConfigOptionBools(is_extruder_used));
 
    {
        BoundingBoxf bbox_bed(print.config().printable_area.values);
        Vec2f plate_offset = m_writer.get_xy_offset();
        this->placeholder_parser().set("print_bed_min", new ConfigOptionFloats({ bbox_bed.min.x(), bbox_bed.min.y()}));
        this->placeholder_parser().set("print_bed_max", new ConfigOptionFloats({ bbox_bed.max.x(), bbox_bed.max.y()}));
        this->placeholder_parser().set("print_bed_size", new ConfigOptionFloats({ bbox_bed.size().x(), bbox_bed.size().y() }));
 
        BoundingBoxf bbox;
        auto pts = std::make_unique<ConfigOptionPoints>();
        if (print.calib_mode() == CalibMode::Calib_PA_Pattern) {
            //PA_Pattern can have any size or arrangement - not dependent on 3mf model size
            bbox = bbox_bed;
            bbox.offset(-25.0);
            // add 4 corner points of bbox into pts
            pts->values.reserve(4);
            pts->values.emplace_back(bbox.min.x(), bbox.min.y());
            pts->values.emplace_back(bbox.max.x(), bbox.min.y());
            pts->values.emplace_back(bbox.max.x(), bbox.max.y());
            pts->values.emplace_back(bbox.min.x(), bbox.max.y());
 
        } else if (print.calib_mode() == CalibMode::Calib_PA_Line) {
            // Derive X bounds from the actual calibration geometry.
            CalibPressureAdvanceLine temp_pa_line_forsize(this);
            BoundingBoxf pattern_extents = temp_pa_line_forsize.print_extents(bbox_bed);
 
            bbox = bbox_bed;
            bbox.offset(-25.0);
            bbox.min.x() = std::max(pattern_extents.min.x(), bbox.min.x());
            bbox.max.x() = std::min(pattern_extents.max.x(), bbox.max.x());
            
            pts->values.reserve(4);
            pts->values.emplace_back(bbox.min.x(), bbox.min.y());
            pts->values.emplace_back(bbox.max.x(), bbox.min.y());
            pts->values.emplace_back(bbox.max.x(), bbox.max.y());
            pts->values.emplace_back(bbox.min.x(), bbox.max.y());
 
        } else {
            // Convex hull of the 1st layer extrusions, for bed leveling and placing the initial purge line.
            // It encompasses the object extrusions, support extrusions, skirt, brim, wipe tower.
            // It does NOT encompass user extrusions generated by custom G-code,
            // therefore it does NOT encompass the initial purge line.
            // It does NOT encompass MMU/MMU2 starting (wipe) areas.
            pts->values.reserve(print.first_layer_convex_hull().size());
            for (const Point &pt : print.first_layer_convex_hull().points)
                pts->values.emplace_back(print.translate_to_print_space(pt));
            bbox = BoundingBoxf((pts->values));
        }
        this->placeholder_parser().set("first_layer_print_convex_hull", pts.release());
        this->placeholder_parser().set("first_layer_print_min", new ConfigOptionFloats({bbox.min.x(), bbox.min.y()}));
        this->placeholder_parser().set("first_layer_print_max", new ConfigOptionFloats({bbox.max.x(), bbox.max.y()}));
        this->placeholder_parser().set("first_layer_print_size", new ConfigOptionFloats({ bbox.size().x(), bbox.size().y() }));
 
        {  
            // use first layer convex_hull union with each object's bbox to check whether in head detect zone
            Polygons object_projections;
            for (auto& obj : print.objects()) {
                for (auto& instance : obj->instances()) {
                    const auto& bbox = instance.get_bounding_box();
                    Point min_p{ coord_t(scale_(bbox.min.x())),coord_t(scale_(bbox.min.y())) };
                    Point max_p{ coord_t(scale_(bbox.max.x())),coord_t(scale_(bbox.max.y())) };
                    Polygon instance_projection = {
                        {min_p.x(),min_p.y()},
                        {max_p.x(),min_p.y()},
                        {max_p.x(),max_p.y()},
                        {min_p.x(),max_p.y()}
                    };
                    object_projections.emplace_back(std::move(instance_projection));
                }
            }
            object_projections.emplace_back(print.first_layer_convex_hull());
 
            Polygons project_polys = union_(object_projections);
            Polygon  head_wrap_detect_zone;
            for (auto& point : print.config().head_wrap_detect_zone.values)
                head_wrap_detect_zone.append(scale_(point).cast<coord_t>() + scale_(plate_offset).cast<coord_t>());
 
            this->placeholder_parser().set("in_head_wrap_detect_zone", !intersection_pl(project_polys, {head_wrap_detect_zone}).empty());
        }
 
        {
            coordf_t max_print_z = 0;
            for (auto& obj : print.objects()) {
                max_print_z = std::max(max_print_z, (*std::max_element(obj->layers().begin(), obj->layers().end(), [](Layer* a, Layer* b) { return a->print_z < b->print_z; }))->print_z);
            }
            this->placeholder_parser().set("max_print_z", new ConfigOptionInt(std::ceil(max_print_z)));
        }
 
        BoundingBoxf mesh_bbox(m_config.bed_mesh_min, m_config.bed_mesh_max);
        auto         mesh_margin = m_config.adaptive_bed_mesh_margin.value;
        mesh_bbox.min            = mesh_bbox.min.cwiseMax((bbox.min.array() - mesh_margin).matrix());
        mesh_bbox.max            = mesh_bbox.max.cwiseMin((bbox.max.array() + mesh_margin).matrix());
        this->placeholder_parser().set("adaptive_bed_mesh_min", new ConfigOptionFloats({mesh_bbox.min.x(), mesh_bbox.min.y()}));
        this->placeholder_parser().set("adaptive_bed_mesh_max", new ConfigOptionFloats({mesh_bbox.max.x(), mesh_bbox.max.y()}));
 
        auto probe_dist_x  = std::max(1., m_config.bed_mesh_probe_distance.value.x());
        auto probe_dist_y  = std::max(1., m_config.bed_mesh_probe_distance.value.y());
        int  probe_count_x = std::max(3, (int) std::ceil(mesh_bbox.size().x() / probe_dist_x) + 1);
        int  probe_count_y = std::max(3, (int) std::ceil(mesh_bbox.size().y() / probe_dist_y) + 1);
        auto bed_mesh_algo = "bicubic";
        if (probe_count_x * probe_count_y <= 6) { // lagrange needs up to a total of 6 mesh points
            bed_mesh_algo = "lagrange";
        }
        else
            if(print.config().gcode_flavor == gcfKlipper){
              // bicubic needs 4 probe points per axis
              probe_count_x = std::max(probe_count_x,4);
              probe_count_y = std::max(probe_count_y,4);
            }
        this->placeholder_parser().set("bed_mesh_probe_count", new ConfigOptionInts({probe_count_x, probe_count_y}));
        this->placeholder_parser().set("bed_mesh_algo", bed_mesh_algo);
        // get center without wipe tower
        BoundingBoxf bbox_wo_wt; // bounding box without wipe tower
        for (auto &objPtr : print.objects()) {
            BBoxData data;
            bbox_wo_wt.merge(unscaled(objPtr->get_first_layer_bbox(data.area, data.layer_height, data.name)));
        }
        auto center = bbox_wo_wt.center();
        this->placeholder_parser().set("first_layer_center_no_wipe_tower", new ConfigOptionFloats{ {center.x(),center.y()}});
    }
    bool activate_chamber_temp_control = false;
    auto max_chamber_temp              = 0;
    for (const auto &extruder : m_writer.extruders()) {
        activate_chamber_temp_control |= m_config.activate_chamber_temp_control.get_at(extruder.id());
        max_chamber_temp = std::max(max_chamber_temp, m_config.chamber_temperature.get_at(extruder.id()));
    }
    {
        BedType curr_bed_type = m_config.curr_bed_type;
 
        int min_temperature_vitrification = std::numeric_limits<int>::max();
        for (const auto& extruder : m_writer.extruders())
            min_temperature_vitrification = std::min(min_temperature_vitrification, m_config.temperature_vitrification.get_at(extruder.id()));
 
 
        std::string first_layer_bed_temp_str;
        const ConfigOptionInts* first_bed_temp_opt = m_config.option<ConfigOptionInts>(get_bed_temp_1st_layer_key((BedType)curr_bed_type));
        const ConfigOptionInts* bed_temp_opt = m_config.option<ConfigOptionInts>(get_bed_temp_key((BedType)curr_bed_type));
        int target_bed_temp = 0;
        if (m_config.bed_temperature_formula == BedTempFormula::btfHighestTemp)
            target_bed_temp = get_highest_bed_temperature(true, print);
        else
            target_bed_temp = get_bed_temperature(initial_extruder_id, true, curr_bed_type);
 
        this->placeholder_parser().set("bbl_bed_temperature_gcode", new ConfigOptionBool(false));
        this->placeholder_parser().set("bed_temperature_initial_layer", new ConfigOptionInts(*first_bed_temp_opt));
        this->placeholder_parser().set("bed_temperature", new ConfigOptionInts(*bed_temp_opt));
        this->placeholder_parser().set("bed_temperature_initial_layer_single", new ConfigOptionInt(target_bed_temp));
        this->placeholder_parser().set("bed_temperature_initial_layer_vector", new ConfigOptionString());
        this->placeholder_parser().set("chamber_temperature", new ConfigOptionInts(m_config.chamber_temperature));
        this->placeholder_parser().set("overall_chamber_temperature", new ConfigOptionInt(max_chamber_temp));
        this->placeholder_parser().set("chamber_minimal_temperature", new ConfigOptionInts(m_config.chamber_minimal_temperature));
        this->placeholder_parser().set("enable_high_low_temp_mix", new ConfigOptionBool(!print.need_check_multi_filaments_compatibility()));
        this->placeholder_parser().set("min_vitrification_temperature", new ConfigOptionInt(min_temperature_vitrification));
 
        // SoftFever: support variables `first_layer_temperature` and `first_layer_bed_temperature`
        this->placeholder_parser().set("first_layer_bed_temperature", new ConfigOptionInts(*first_bed_temp_opt));
        this->placeholder_parser().set("first_layer_temperature", new ConfigOptionInts(m_config.nozzle_temperature_initial_layer));
        this->placeholder_parser().set("max_print_height",new ConfigOptionInt(m_config.printable_height));
        this->placeholder_parser().set("z_offset", new ConfigOptionFloat(m_config.z_offset));
        this->placeholder_parser().set("model_name", new ConfigOptionString(print.get_model_name()));
        this->placeholder_parser().set("plate_number", new ConfigOptionString(print.get_plate_number_formatted()));
        this->placeholder_parser().set("plate_name", new ConfigOptionString(print.get_plate_name()));
        this->placeholder_parser().set("first_layer_height", new ConfigOptionFloat(m_config.initial_layer_print_height.value));
 
        auto used_filaments = print.get_slice_used_filaments(false);
        this->placeholder_parser().set("is_all_bbl_filament", std::all_of(used_filaments.begin(), used_filaments.end(), [&](auto idx) {
            return m_config.filament_vendor.get_at(idx) == "Bambu Lab";
            }));
 
        //add during_print_exhaust_fan_speed
        std::vector<int> during_print_exhaust_fan_speed_num;
        during_print_exhaust_fan_speed_num.reserve(m_config.during_print_exhaust_fan_speed.size());
        for (const auto& item : m_config.during_print_exhaust_fan_speed.values)
            during_print_exhaust_fan_speed_num.emplace_back((int)(item / 100.0 * 255));
        this->placeholder_parser().set("during_print_exhaust_fan_speed_num", new ConfigOptionInts(during_print_exhaust_fan_speed_num));
 
        //BBS: calculate the volumetric speed of outer wall. Ignore pre-object setting and multi-filament, and just use the default setting
        float outer_wall_volumetric_speed = get_outer_wall_volumetric_speed(m_config, print, initial_non_support_extruder_id,
                                                                            (int) get_filament_config_index((int) initial_non_support_extruder_id),
                                                                            get_extruder_id(initial_non_support_extruder_id));
        this->placeholder_parser().set("outer_wall_volumetric_speed", new ConfigOptionFloat(outer_wall_volumetric_speed));
 
        auto first_layer_filaments = print.get_slice_used_filaments(true);
        bool has_tpu_in_first_layer = std::any_of(first_layer_filaments.begin(), first_layer_filaments.end(), [&](unsigned int idx) { return m_config.filament_type.get_at(idx) == "TPU"; });
        this->placeholder_parser().set("has_tpu_in_first_layer", new ConfigOptionBool(has_tpu_in_first_layer));
 
        if (print.calib_params().mode == CalibMode::Calib_PA_Line) {
            this->placeholder_parser().set("scan_first_layer", new ConfigOptionBool(false));
        }
    }
    {                                                                         // hold chamber temp for flat print: Flag
        double print_area_sum_threshold = 40000.0, pring_hight_threshold = 0.3; // thresholds in mm^2 and mm as units
 
        double   area_sum_temp  = 0.0;
        coordf_t max_hight_temp = -1.0;
        for (ObjectID print_object_ID_t : print.print_object_ids()) {
            const PrintObject *print_object = print.get_object(print_object_ID_t);
            // object hight
            if (!print_object->layers().empty() && print_object->layers().back()->print_z > max_hight_temp) max_hight_temp = print_object->layers().back()->print_z;
            // object area
            if (!print_object->layers().empty() && print_object->layers().front()->print_z < print.config().initial_layer_print_height + EPSILON &&
                !print_object->layers().front()->lslices.empty()) {
                ExPolygons temp_Expolys = print_object->layers().front()->lslices;
                for (ExPolygon &temp_Expoly : temp_Expolys) { area_sum_temp += temp_Expoly.area(); }
            }
            // suport area
            if (!print_object->support_layers().empty() && print_object->support_layers().front()->print_z < print.config().initial_layer_print_height + EPSILON &&
                !print_object->support_layers().front()->support_islands.empty()) {
                ExPolygons temp_Expolys = print_object->support_layers().front()->support_islands;
                for (ExPolygon &temp_Expoly : temp_Expolys) { area_sum_temp += temp_Expoly.area(); }
            }
            // brim area
            if (print.m_brimMap.find(print_object_ID_t) != print.m_brimMap.end() && !print.m_brimMap.at(print_object_ID_t).entities.empty()) { // contain brim
                for (const ExtrusionEntity *entities_temp : print.m_brimMap.at(print_object_ID_t).entities) {
                    Polygons temp_Expolys;
                    entities_temp->polygons_covered_by_spacing(temp_Expolys, 0.0f);
                    for (Polygon &temp_Expoly : temp_Expolys) { area_sum_temp += temp_Expoly.area(); }
                }
            }
        }
        // wipe tower area
        if (has_wipe_tower && print.wipe_tower_data().wipe_tower_mesh_data) {
            Polygon temp_Expoly = print.wipe_tower_data().wipe_tower_mesh_data->bottom;
            area_sum_temp += temp_Expoly.area();
        }
        bool hold_chamber_temp_for_flat_print = max_hight_temp > 0 && max_hight_temp < pring_hight_threshold && area_sum_temp > print_area_sum_threshold * 1.0e10;
        this->placeholder_parser().set("hold_chamber_temp_for_flat_print", new ConfigOptionBool(hold_chamber_temp_for_flat_print));
    }
 
    this->placeholder_parser().set_deferred("print_time_total_sec", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Total_Sec_Placeholder));
    this->placeholder_parser().set_deferred("print_time_day", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Day_Placeholder));
    this->placeholder_parser().set_deferred("print_time_hour", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Hour_Placeholder));
    this->placeholder_parser().set_deferred("print_time_minute", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Minute_Placeholder));
    this->placeholder_parser().set_deferred("print_time_sec", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Sec_Placeholder));
    this->placeholder_parser().set_deferred("used_filament_length", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Used_Filament_Length_Placeholder));
    // The final print statistics are known only after the whole G-code is generated, so they are filled in during post-processing too.
    // The running extruded_* totals are left alone; profiles use them as numbers.
    this->placeholder_parser().set_deferred("used_filament", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Used_Filament_Length_Placeholder));
    this->placeholder_parser().set_deferred("print_time", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Normal_Print_Time_Placeholder));
    this->placeholder_parser().set_deferred("normal_print_time", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Normal_Print_Time_Placeholder));
    this->placeholder_parser().set_deferred("silent_print_time", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Silent_Print_Time_Placeholder));
    this->placeholder_parser().set_deferred("total_weight", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Weight_Placeholder));
    this->placeholder_parser().set_deferred("total_cost", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Cost_Placeholder));
    this->placeholder_parser().set_deferred("total_wipe_tower_cost", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Wipe_Tower_Cost_Placeholder));
    this->placeholder_parser().set_deferred("total_wipe_tower_filament", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Wipe_Tower_Filament_Placeholder));
 
    // Sync variant-mapped params into placeholder_parser before processing start gcode
    update_placeholder_parser_with_variant_params();
 
    // IDEX/IQEX: set {imex_mode}, {imex_mode_index}, {imex_mode_gcode} placeholders before
    // any G-code script is processed so they are available in machine_start_gcode,
    // filament_start_gcode, filament_end_gcode, change_filament_gcode, etc.
    // {imex_mode_names} and {imex_mode_gcodes} array placeholders are already accessible
    // via the printer config (e.g. {imex_mode_names[0]}, {imex_mode_gcodes[1]}).
    std::string imex_active_mode;
    int         imex_active_mode_index = 0;
    std::string imex_active_mode_gcode;
    m_imex_parallel_mode.clear();
    m_imex_head_filament_map.clear();
    if (print.config().is_imex.value && !print.objects().empty()) {
        const std::string& raw = print.objects().front()->config().imex_parallel_mode.value;
        imex_active_mode = raw.empty() ? kImexPrimaryMode : raw;
        m_imex_head_filament_map = parse_imex_head_filament_map(
            print.objects().front()->config().imex_head_filament_map.value);
        // Look `name` up in the printer's mode table, filling in its index, script and
        // tool roster. False means the name matches no row, i.e. the mode is unresolved.
        // find_imex_mode() owns the "which row, and what if a sibling array is short"
        // rule for every IMEX consumer; see IMEXHelpers.hpp.
        std::string imex_active_mode_tools;
        auto resolve_mode = [&](const std::string& name) {
            const ImexMode mode = find_imex_mode(print.config(), name);
            if (!mode.found())
                return false;
            imex_active_mode_index = mode.index;
            imex_active_mode_gcode = mode.gcode;
            imex_active_mode_tools = mode.active_tools;
            return true;
        };
        // An unresolved mode name falls back to Primary rather than being carried into the
        // parallel-mode paths. `imex_parallel_mode` is a plain string stored on the plate and
        // matched against the printer's `imex_mode_names` by value, so it goes stale whenever
        // the two drift apart -- a mode renamed or deleted after a plate was set to it, or a
        // project shared between printer presets that name their modes differently.
        //
        // Without the fallback the exporter took every "not Primary" branch while every lookup
        // keyed on the mode name came back empty, and wrote a file that is wrong rather than
        // merely unconfigured: the 1st->2nd layer temperature branch is mutually exclusive with
        // the standard one, so an empty active-tool roster meant NO head got its transition and
        // all of them held nozzle_temperature_initial_layer for the whole print; and
        // imex_suppresses_bare_toolchange() dropped the initial T<n> on the assumption that a
        // mode script would select the tool, while the mode script -- also looked up by name --
        // did not exist. Print::validate()'s IMEX rules did not catch it either: they resolve
        // the same name to an empty tools string, which yields no declared primary and skips
        // the guard. Primary is the one interpretation that is always well-formed: single
        // carriage, ordinary temperatures, ordinary tool changes.
        //
        // Warned rather than silent, and warned rather than blocked. Silent is not an option:
        // the plate still labels itself with the stale mode and draws no zones (PartPlate's
        // zone builder returns early on the same unresolved state), so a user who asked for two
        // parts in copy mode would get one with nothing anywhere saying why. Blocking is not an
        // option either -- opening someone else's 3MF on a differently-named preset is a
        // legitimate way to arrive here, and the Primary interpretation prints correctly, so
        // refusing to slice would be a regression for a case that has a good answer.
        //
        // The second trigger below is the ragged-table case, and it lands here rather than
        // anywhere else because the damage is identical: the mode's name resolves, but the
        // printer's `imex_mode_active_tools` is too short to reach its row (or the row is
        // explicitly empty), so the roster every branch above keys on comes back empty and
        // the export takes the parallel path with nothing in it. Nothing used to report
        // that -- half the lookup sites in the tree turned a short tools array into "mode
        // not found" and the other half did not, and this one did not. One rule now, in
        // find_imex_mode(), and one warning, here.
        const bool imex_mode_resolved = resolve_mode(imex_active_mode);
        if (imex_active_mode != kImexPrimaryMode && (!imex_mode_resolved || imex_active_mode_tools.empty())) {
            print.active_step_add_warning(
                PrintStateBase::WarningLevel::NON_CRITICAL,
                imex_mode_resolved
                    ? Slic3r::format(_(L("The IDEX/IQEX mode \"%1%\" has no tools assigned on the selected printer. "
                                         "Printing in Primary mode instead. Assign the mode's tools in Printer "
                                         "Settings, or pick another mode from the plate's IDEX/IQEX button.")),
                                     imex_active_mode)
                    : Slic3r::format(_(L("This plate is set to the IDEX/IQEX mode \"%1%\", which the selected printer "
                                         "does not define. Printing in Primary mode instead. Pick a mode from the "
                                         "plate's IDEX/IQEX button, or restore the mode in Printer Settings.")),
                                     imex_active_mode));
            imex_active_mode       = kImexPrimaryMode;
            imex_active_mode_index = 0;
            imex_active_mode_gcode.clear();
            imex_active_mode_tools.clear();
            // Primary is a real row in the table (always the first one), so it may carry its own
            // setup script; resolve it the same way any other selected mode would be.
            resolve_mode(imex_active_mode);
        }
        m_imex_parallel_mode = imex_active_mode;
    }
    this->placeholder_parser().set("imex_mode",       imex_active_mode);
    this->placeholder_parser().set("imex_mode_index", imex_active_mode_index);
    this->placeholder_parser().set("imex_mode_gcode", imex_active_mode_gcode);
 
    // IDEX/IQEX: process mode G-code BEFORE machine_start_gcode so that any
    // {global abc = 1} declarations in the mode script are visible to machine_start_gcode.
    // The processed result is buffered here and written to the file after temp setup below.
    std::string imex_processed_gcode;
    if (!imex_active_mode_gcode.empty())
        imex_processed_gcode = this->placeholder_parser_process(
            "imex_mode_gcode", imex_active_mode_gcode, initial_extruder_id);
    // Expand the file header only after the start-up placeholders and writer state are ready.
    // Use the regular custom G-code path so invalid placeholders report the template name.
    if (!print.config().file_start_gcode.value.empty())
        file.writeln(this->placeholder_parser_process("file_start_gcode", print.config().file_start_gcode.value, initial_extruder_id));
 
    // Orca: Don't output Header block if BTT thumbnail is identified in the list
    // Get the thumbnails value as a string
    std::string thumbnails_value = print.config().option<ConfigOptionString>("thumbnails")->value;
    // search string for the BTT_TFT label
    bool has_BTT_thumbnail = (thumbnails_value.find("BTT_TFT") != std::string::npos);
 
    if(!has_BTT_thumbnail){
        file.write_format("; HEADER_BLOCK_START\n");
        // Write information on the generator.
        file.write_format("; generated by %s on %s\n", Slic3r::header_slic3r_generated().c_str(), Slic3r::Utils::local_timestamp().c_str());
        if (is_bbl_printers)
            file.write_format(";%s\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Estimated_Printing_Time_Placeholder).c_str());
        //BBS: total layer number
        file.write_format(";%s\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Layer_Number_Placeholder).c_str());
        //Orca: extra check for bbl printer
        if (is_bbl_printers) {
            if (print.calib_params().mode == CalibMode::Calib_None) { // Don't support skipping in cali mode
                // list all label_object_id with sorted order here
                m_enable_exclude_object = true;
                m_label_objects_ids.clear();
                m_label_objects_ids.reserve(print.num_object_instances());
                for (const PrintObject *print_object : print.objects())
                    for (const PrintInstance &print_instance : print_object->instances())
                        m_label_objects_ids.push_back(print_instance.model_instance->get_labeled_id());
 
                std::sort(m_label_objects_ids.begin(), m_label_objects_ids.end());
 
                std::string objects_id_list = "; model label id: ";
                for (auto it = m_label_objects_ids.begin(); it != m_label_objects_ids.end(); it++)
                    objects_id_list += (std::to_string(*it) + (it != m_label_objects_ids.end() - 1 ? "," : "\n"));
                file.writeln(objects_id_list);
            } else {
                m_enable_exclude_object = false;
                m_label_objects_ids.clear();
            }
    }
 
    {
        std::string filament_density_list = "; filament_density: ";
        (filament_density_list+=m_config.filament_density.serialize()) +='\n';
        file.writeln(filament_density_list);
 
        std::string filament_diameter_list = "; filament_diameter: ";
        (filament_diameter_list += m_config.filament_diameter.serialize()) += '\n';
        file.writeln(filament_diameter_list);
 
        coordf_t max_height_z = -1;
        for (const auto& object : print.objects())
            max_height_z = std::max(object->layers().back()->print_z, max_height_z);
 
        std::ostringstream max_height_z_tip;
        max_height_z_tip<<"; max_z_height: " << std::fixed << std::setprecision(2) << max_height_z << '\n';
        file.writeln(max_height_z_tip.str());
    }
 
    {
        auto used_filaments = print.get_slice_used_filaments(false);
        std::ostringstream out;
        out << "; filament: ";
        for (size_t idx = 0; idx < used_filaments.size(); ++idx) {
            if (idx != 0)
                out << ',';
            out << used_filaments[idx] + 1;
        }
        file.writeln(out.str());
    }
 
    file.write_format("; HEADER_BLOCK_END\n\n");
    }
 
      // BBS: write global config at the beginning of gcode file because printer
      // need these config information
      // Append full config, delimited by two 'phony' configuration keys
      // CONFIG_BLOCK_START and CONFIG_BLOCK_END. The delimiters are structured
      // as configuration key / value pairs to be parsable by older versions of
      // PrusaSlicer G-code viewer.
    {
        if (is_bbl_printers && !skip_config_block) {
            file.write("; CONFIG_BLOCK_START\n");
            std::string full_config;
            append_full_config(print, full_config);
            if (!full_config.empty())
                file.write(full_config);
 
            // SoftFever: write compatiple image
            file.write_format("; first_layer_bed_temperature = %d\n", compat_first_layer_bed_temp);
            file.write_format("; first_layer_temperature = %d\n", compat_first_layer_nozzle_temp);
            file.write("; CONFIG_BLOCK_END\n\n");
        } else if (thumbnail_cb != nullptr) {
            // generate the thumbnails
            auto [thumbnails, errors] = GCodeThumbnails::make_and_check_thumbnail_list(print.full_print_config());
 
            if (errors != enum_bitmask<ThumbnailError>()) {
                std::string error_str = _(L("Invalid thumbnails value:"));
                error_str += GCodeThumbnails::get_error_string(errors);
                throw Slic3r::ExportError(error_str);
            }
 
            if (!thumbnails.empty())
                GCodeThumbnails::export_thumbnails_to_file(
                    thumbnail_cb, print.get_plate_index(), thumbnails, [&file](const char* sz) { file.write(sz); }, [&print]() { print.throw_if_canceled(); });
        }
    }
 
    // Belt printer: the tilt and transform settings the G-code viewer reads back. They
    // are comments outside the config block, so they go after the thumbnails that a
    // BTT TFT firmware needs first, and are written whether or not that header block is.
    this->write_belt_header(file, print);
 
    // Write some terse information on the slicing parameters.
    const PrintObject *first_object         = print.objects().front();
    const double       layer_height         = first_object->config().layer_height.value;
    const double       initial_layer_print_height   = print.config().initial_layer_print_height.value;
    for (size_t region_id = 0; region_id < print.num_print_regions(); ++ region_id) {
        const PrintRegion &region = print.get_print_region(region_id);
        file.write_format("; external perimeters extrusion width = %.2fmm\n", region.flow(*first_object, frExternalPerimeter, layer_height).width());
        file.write_format("; perimeters extrusion width = %.2fmm\n",          region.flow(*first_object, frPerimeter,         layer_height).width());
        file.write_format("; infill extrusion width = %.2fmm\n",              region.flow(*first_object, frInfill,            layer_height).width());
        file.write_format("; solid infill extrusion width = %.2fmm\n",        region.flow(*first_object, frSolidInfill,       layer_height).width());
        file.write_format("; top infill extrusion width = %.2fmm\n",          region.flow(*first_object, frTopSolidInfill,    layer_height).width());
        if (print.has_support_material())
            file.write_format("; support material extrusion width = %.2fmm\n", support_material_flow(first_object).width());
        if (print.config().initial_layer_line_width.value > 0)
            file.write_format("; first layer extrusion width = %.2fmm\n",   region.flow(*first_object, frPerimeter, initial_layer_print_height, true).width());
        file.write_format("\n");
    }
 
    file.write_format("; EXECUTABLE_BLOCK_START\n");
 
    // Set for every printer, as the object label comments use these ids too.
    assign_object_label_ids(print);
    // SoftFever
    if( m_enable_exclude_object)
        file.write(set_object_info(&print));
 
    // adds tags for time estimators
    file.write_format(";%s\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::First_Line_M73_Placeholder).c_str());
 
    // Emit machine envelope limits for the Marlin firmware.
    this->print_machine_envelope(file, print);
 
    // Disable fan.
    if (m_config.auxiliary_fan.value && print.config().close_fan_the_first_x_layers.get_at(initial_extruder_id)) {
        file.write(m_writer.set_fan(0));
        //BBS: disable additional fan
        file.write(m_writer.set_additional_fan(0));
    }
 
    std::string machine_start_gcode = this->placeholder_parser_process("machine_start_gcode", print.config().machine_start_gcode.value, initial_extruder_id);
    if (print.config().gcode_flavor != gcfKlipper) {
        // Set bed temperature if the start G-code does not contain any bed temp control G-codes.
        this->_print_first_layer_bed_temperature(file, print, machine_start_gcode, initial_extruder_id, true);
        // Set extruder(s) temperature before and after start G-code.
        this->_print_first_layer_extruder_temperatures(file, print, machine_start_gcode, initial_extruder_id, false);
    }
 
    // adds tag for processor
    file.write_format(";%s%s\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role).c_str(), ExtrusionEntity::role_to_string(erCustom).c_str());
 
    // Orca: set chamber temperature at the beginning of gcode file
    if (activate_chamber_temp_control && max_chamber_temp > 0){
        int temp_out =0;
        if(!custom_gcode_sets_temperature(machine_start_gcode,141,191,false,temp_out))
            file.write(m_writer.set_chamber_temperature(max_chamber_temp, true)); // set chamber_temperature
    }
 
    // Write IMEX mode G-code first (processed above), then machine_start_gcode.
    if (!imex_processed_gcode.empty())
        file.writeln(imex_processed_gcode);
 
    // Write the custom start G-code
    file.writeln(machine_start_gcode);
    // Mark the end of the machine start g-code so the GCodeProcessor usage-block builder knows where user
    // g-code ends and can start attributing filament/extruder usage. Gated on enable_pre_heating: only the
    // injector fleet (H2D/X2D/H2D-Pro/H2C) emits it; the byte-frozen fleet (X1/P1/A1/H2S, flag false) never
    // does, so their g-code is byte-identical. Without this marker handle_filament_change early-returns and
    // no blocks are built, so this line is what actually activates the pre-heat injector.
    if (m_config.enable_pre_heating.value)
        file.write_format(";%s\n", GCodeProcessor::Machine_Start_GCode_End_Tag.c_str());
 
    //BBS: gcode writer doesn't know where the real position of extruder is after inserting custom gcode
    m_writer.set_current_position_clear(false);
    m_start_gcode_filament = GCodeProcessor::get_gcode_last_filament(machine_start_gcode);
 
    if (is_bbl_printers) {
        m_writer.init_extruder(initial_non_support_extruder_id);
        // add the missing filament start gcode in machine start gcode
        {
            DynamicConfig config;
            config.set_key_value("filament_extruder_id", new ConfigOptionInt((int)(initial_non_support_extruder_id)));
            config.set_key_value("current_filament_id", new ConfigOptionInt((int)(initial_non_support_extruder_id)));
            config.set_key_value("current_extruder_id", new ConfigOptionInt((int) get_extruder_id(initial_non_support_extruder_id)));
            config.set_key_value("current_nozzle_id", new ConfigOptionInt(first_nozzle_id_for_gcode_placeholder(group_result, (int) initial_non_support_extruder_id, (int) get_extruder_id(initial_non_support_extruder_id))));
            config.set_key_value("nozzle_diameter_at_nozzle_id", new ConfigOptionFloats(get_nozzle_diameters_by_nozzle_id(group_result.get())));
            config.set_key_value("nozzle_volume_types", new ConfigOptionStrings(get_nozzle_volume_types_by_nozzle_id(group_result.get())));
            config.set_key_value("layer_num", new ConfigOptionInt(m_layer_index));
            config.set_key_value("layer_z", new ConfigOptionFloat(m_writer.get_position().z() - m_config.z_offset.value));
            config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
            std::string filament_start_gcode = this->placeholder_parser_process("filament_start_gcode", print.config().filament_start_gcode.get_at(initial_non_support_extruder_id), initial_non_support_extruder_id,&config);
            file.writeln(filament_start_gcode);
            // Mark the first filament used in print. Multi-nozzle printers (H2C) get ";VT%d H%d" where
            // H = dynamic ? nozzle_id : -1; existing single-nozzle printers keep the bare ";VT%d" so their
            // g-code stays byte-identical.
            if (is_multi_nozzle_printer(m_config)) {
                int initial_nozzle_id = -1;
                if (group_result && group_result->is_support_dynamic_nozzle_map()) {
                    auto initial_nozzle = group_result->get_first_nozzle_for_filament(initial_extruder_id);
                    initial_nozzle_id = initial_nozzle ? initial_nozzle->group_id : -1;
                }
                file.write_format(";VT%d H%d\n", initial_extruder_id, initial_nozzle_id);
            } else {
                file.write_format(";VT%d\n", initial_extruder_id);
            }
        }
        // Orca: add missing PA settings for initial filament
        file.write(set_filament_pressure_advance(initial_non_support_extruder_id));
    }
 
    //flush FanMover buffer to avoid modifying the start gcode if it's manual.
    if (!machine_start_gcode.empty() && this->m_fan_mover.get() != nullptr)
        file.write(this->m_fan_mover.get()->process_gcode("", true));
 
    // Process filament-specific gcode.
   /* if (has_wipe_tower) {
        // Wipe tower will control the extruder switching, it will call the filament_start_gcode.
    } else {
            DynamicConfig config;
            config.set_key_value("filament_extruder_id", new ConfigOptionInt(int(initial_extruder_id)));
            file.writeln(this->placeholder_parser_process("filament_start_gcode", print.config().filament_start_gcode.values[initial_extruder_id], initial_extruder_id, &config));
    }
*/
    if (is_bbl_printers) {
        this->_print_first_layer_extruder_temperatures(file, print, machine_start_gcode, initial_extruder_id, true);
    }
 
    // Orca: when air filtration is supported, check if it needs to be activated during printing and set the exhaust fan speed accordingly
    if (m_config.support_air_filtration.value) {
        bool activate_air_filtration_during_print = false;
        int  during_print_exhaust_fan_speed = 0;
 
        // Orca: when activate_air_filtration is set on any extruder, find and set the highest during_print_exhaust_fan_speed
        for (const auto &extruder : m_writer.extruders()) {
            size_t fi = get_filament_config_index((int)extruder.id());
            if (m_config.activate_air_filtration.get_at(fi) && m_config.activate_air_filtration_during_print.get_at(fi)) {
                activate_air_filtration_during_print = true;
                during_print_exhaust_fan_speed = std::max(during_print_exhaust_fan_speed,
                                                        m_config.during_print_exhaust_fan_speed.get_at(fi));
            }
        }
 
        if (activate_air_filtration_during_print)
            file.write(m_writer.set_exhaust_fan(during_print_exhaust_fan_speed));
    }
 
    print.throw_if_canceled();
 
    // Set other general things.
    file.write(this->preamble());
 
    // Calculate wiping points if needed
    DoExport::init_ooze_prevention(print, m_ooze_prevention);
    print.throw_if_canceled();
 
    // Collect custom seam data from all objects.
    std::function<void(void)> throw_if_canceled_func = [&print]() { print.throw_if_canceled(); };
    m_seam_placer.init(print, throw_if_canceled_func);
    // Precise Seam: init() only prepares its warning; issue it here, inside the active export step.
    if (!m_seam_placer.precise_seam_warning().empty())
        print.active_step_add_warning(PrintStateBase::WarningLevel::NON_CRITICAL,
                                      m_seam_placer.precise_seam_warning(),
                                      PrintStateBase::SlicingPreciseSeamWarning);
 
    // BBS: get path for change filament
    if (m_writer.multiple_extruders) {
        std::vector<Vec2d> points = get_path_of_change_filament(print);
        if (points.size() == 3) {
            travel_point_1 = points[0];
            travel_point_2 = points[1];
            travel_point_3 = points[2];
        }
    }
 
    // Orca: support extruder priming
    if (wipe_tower_type != WipeTowerType::Type2 || ! (has_wipe_tower && print.config().single_extruder_multi_material_priming))
    {
        // Set initial extruder only after custom start G-code.
        // Ugly hack: Do not set the initial extruder if the extruder is primed using the MMU priming towers at the edge of the print bed.
        file.write(this->set_extruder(initial_extruder_id, 0.));
 
        // IMEX parallel modes only: emit PA for all secondary active tools.
        // In primary mode, regular tool-change PA handles each tool as it becomes active.
        // In parallel modes no tool changes occur, so every carriage must be addressed
        // explicitly here before printing starts.
        if (!m_imex_parallel_mode.empty() && m_imex_parallel_mode != kImexPrimaryMode
            && !m_config.physical_extruder_map.values.empty()) {
            // initial_physical: pem-translate the print's initial logical extruder so the
            // loop can skip the primary head (which emitted PA via the normal path).
            // Then pem-invert each active physical head back to its first routed filament
            // for the PA setting lookup. Guarded on non-empty pem above.
            // Bounds-checked, not get_at() -- see the note on imex_pem_tool_for in
            // IMEXHelpers.hpp. A clamped initial_physical would skip whichever active head
            // equals pem[0], leaving it with no PA at all.
            const int initial_physical =
                ((int) initial_extruder_id >= 0 &&
                 (int) initial_extruder_id < (int) m_config.physical_extruder_map.values.size())
                    ? m_config.physical_extruder_map.values[(int) initial_extruder_id]
                    : -1;
            // enable_pressure_advance and pressure_advance are indexed by COLUMN, not by
            // filament slot. filament_diameter is one entry per slot and is never
            // variant-expanded, so it is the slot-space bound; translate the slot to its column
            // with get_filament_config_index(), as the second-layer temperature loop below does.
            const int num_pa_filament_slots = (int) print.config().filament_diameter.values.size();
            for (int tool_idx : get_imex_active_tools(print)) {
                // Unlike the second-layer temperature loop, the primary is skipped here:
                // set_extruder() above already emitted its PA with the pem tool qualifier.
                if (tool_idx == initial_physical) continue;
                const int logical = resolve_filament_for_head(
                    m_imex_head_filament_map, m_config.physical_extruder_map, tool_idx);
                // resolve_filament_for_head() answers in pem's index space -- one entry per
                // NOZZLE -- while these two options are indexed per FILAMENT SLOT. The spaces
                // diverge when the printer has more nozzles than the project has filaments, and
                // get_at() would clamp a past-the-end index to filament 0 and pin its PA onto a
                // secondary carriage. Same guard the second-layer temperature loop uses.
                if (logical < 0 || logical >= num_pa_filament_slots) continue;
                const size_t pa_fi = get_filament_config_index(logical);
                if (!print.config().enable_pressure_advance.get_at(pa_fi)) continue;
                file.write(m_writer.set_pressure_advance(
                    print.config().pressure_advance.get_at(pa_fi),
                    tool_idx));
            }
        }
    }
 
    // Direct output writes are parsed synchronously. Preserve the startup
    // endpoint before the generator establishes its first model-space point,
    // so that first travel can be planned from the position the G-code actually
    // left the machine at rather than the default last_pos value.
    GCodeProcessor::PositionState startup_position = m_processor.get_current_position();
    const Vec2f plate_offset = m_writer.get_xy_offset();
    startup_position.position.x() += plate_offset.x();
    startup_position.position.y() += plate_offset.y();
    m_pending_start_gcode_position = !m_last_pos_defined && startup_position.has_known_xy() ?
        std::optional<GCodeProcessor::PositionState>(startup_position) : std::nullopt;
 
    this->m_objsWithBrim.clear();
    m_brim_done = false;
 
    // Orca: Track brims by instance. When a combined brim is printed, all of
    // its instances are marked done together.
    for (const Print::SkirtBrimGroup& group : print.skirt_brim_groups()) {
        for (const Print::SkirtBrimGroup::Brim& brim : group.brims) {
            if (brim.brim.empty())
                continue;
            for (const ObjectInstanceID& instance : brim.instances)
                this->m_objsWithBrim.insert(instance);
        }
    }
    if (this->m_objsWithBrim.empty()) m_brim_done = true;
 
    // SoftFever: calib
    if (print.calib_params().mode == CalibMode::Calib_PA_Line) {
        std::string gcode;
        gcode += ";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Layer_Change) + "\n";
        if ((NOZZLE_CONFIG(outer_wall_acceleration) > 0 && NOZZLE_CONFIG(outer_wall_acceleration) > 0)) {
            gcode += m_writer.set_print_acceleration((unsigned int)floor(NOZZLE_CONFIG(outer_wall_acceleration) + 0.5));
        }
 
        if (NOZZLE_CONFIG(outer_wall_jerk) > 0) {
            double jerk = NOZZLE_CONFIG(outer_wall_jerk);
            gcode += m_writer.set_jerk_xy(jerk);
        }
 
        auto params = print.calib_params();
 
        CalibPressureAdvanceLine pa_test(this);
 
        auto fast_speed = CalibPressureAdvance::find_optimal_PA_speed(print.full_print_config(), pa_test.line_width(), pa_test.height_layer());
        auto slow_speed = std::max(10.0, fast_speed / 10.0);
        if (fast_speed < slow_speed + 5)
            fast_speed = slow_speed + 5;
 
        pa_test.set_speed(fast_speed, slow_speed);
        pa_test.draw_numbers() = print.calib_params().print_numbers;
 
        // ORCA-Belt: the PA line test draws directly on the build surface in
        // logical bed coordinates — on a belt printer that surface is the
        // belt plane, not the slicing plane.
        const bool belt_world_coords = print.config().belt_printer.value;
        if (belt_world_coords)
            install_belt_kinematics(m_writer, print.config(), /*world_coordinates=*/true);
        gcode += pa_test.generate_test(params.start, params.step, std::llround(std::ceil((params.end - params.start) / params.step)) + 1);
        if (belt_world_coords)
            install_belt_kinematics(m_writer, print.config(), /*world_coordinates=*/false);
 
        file.write(gcode);
    } else {
        //BBS: open spaghetti detector
        if (is_bbl_printers) {
            // if (print.config().spaghetti_detector.value)
            file.write("M981 S1 P20000 ;open spaghetti detector\n");
        }
 
        // Do all objects for each layer.
        if (print.config().print_sequence == PrintSequence::ByObject && !has_wipe_tower) {
            size_t finished_objects = 0;
            print_object_instance_sequential_active = first_has_extrude_print_object;
            const PrintObject *prev_object = (*print_object_instance_sequential_active)->print_object;
            for (; print_object_instance_sequential_active != print_object_instances_ordering.end(); ++ print_object_instance_sequential_active) {
                const PrintObject &object = *(*print_object_instance_sequential_active)->print_object;
                if (&object != prev_object || tool_ordering.first_extruder() != final_extruder_id) {
                    auto cached_ordering = use_seq_dynamic_cache ? seq_dynamic_orderings.find(&object) : seq_dynamic_orderings.end();
                    if (cached_ordering != seq_dynamic_orderings.end()) {
                        // Never re-plan a selector object mid-export: the cached plan is what the
                        // published stitched result was built from.
                        tool_ordering = cached_ordering->second;
                    } else {
                        tool_ordering = ToolOrdering(object, final_extruder_id);
                        tool_ordering.sort_and_build_data(object, final_extruder_id);
                    }
                    unsigned int new_extruder_id = tool_ordering.first_extruder();
                    if (new_extruder_id == (unsigned int)-1)
                        // Skip this object.
                        continue;
                    initial_extruder_id = new_extruder_id;
                    final_extruder_id   = tool_ordering.last_extruder();
                    assert(final_extruder_id != (unsigned int)-1);
                }
                print.throw_if_canceled();
                this->set_origin(unscale((*print_object_instance_sequential_active)->shift));
                this->on_set_origin((*print_object_instance_sequential_active)->print_object,
                                    (*print_object_instance_sequential_active)->shift);
 
                // BBS: prime extruder if extruder change happens before this object instance
                bool prime_extruder = false;
                if (finished_objects > 0) {
                    // Move to the origin position for the copy we're going to print.
                    // This happens before Z goes down to layer 0 again, so that no collision happens hopefully.
                    m_enable_cooling_markers = false; // we're not filtering these moves through CoolingBuffer
                    m_avoid_crossing_perimeters.use_external_mp_once();
                    // BBS. change tool before moving to origin point.
                    if (m_writer.need_toolchange(initial_extruder_id)) {
                        const PrintObjectConfig& object_config = object.config();
                        coordf_t initial_layer_print_height = print.config().initial_layer_print_height.value;
 
                        if (m_enable_exclude_object && print.config().support_object_skip_flush.value) {
                            m_filament_instances_code = _encode_label_ids_to_base64({(*print_object_instance_sequential_active)->model_instance->get_labeled_id()});
                        }
 
                        file.write(this->set_extruder(initial_extruder_id, initial_layer_print_height, true));
                        prime_extruder = true;
                    } else {
                        file.write(this->retract());
                    }
                    file.write(m_writer.travel_to_z(m_max_layer_z + m_writer.config.z_hop.get_at(get_filament_config_index((int)initial_extruder_id))));
                    file.write(this->travel_to(Point(0, 0), erNone, "move to origin position for next object"));
                    m_enable_cooling_markers = true;
                    // Disable motion planner when traveling to first object point.
                    m_avoid_crossing_perimeters.disable_once();
                    // Ff we are printing the bottom layer of an object, and we have already finished
                    // another one, set first layer temperatures. This happens before the Z move
                    // is triggered, so machine has more time to reach such temperatures.
                    this->placeholder_parser().set("current_object_idx", int(finished_objects));
                    std::string printing_by_object_gcode = this->placeholder_parser_process("printing_by_object_gcode", print.config().printing_by_object_gcode.value, initial_extruder_id);
                    // Set first layer bed and extruder temperatures, don't wait for it to reach the temperature.
                    this->_print_first_layer_bed_temperature(file, print, printing_by_object_gcode, initial_extruder_id, false);
                    this->_print_first_layer_extruder_temperatures(file, print, printing_by_object_gcode, initial_extruder_id, false);
                    file.writeln(printing_by_object_gcode);
                }
                // Reset the cooling buffer internal state (the current position, feed rate, accelerations).
                m_cooling_buffer->set_current_extruder(initial_extruder_id, get_extruder_id(initial_extruder_id));
                m_cooling_buffer->reset(this->writer().get_position());
                // The belt first-layer band is tracked per object as well: if the previous
                // object ended inside the band, this one has to open its own.
                m_belt_in_band = false;
                // Process all layers of a single object instance (sequential mode) with a parallel pipeline:
                // Generate G-code, run the filters (vase mode, cooling buffer), run the G-code analyser
                // and export G-code into file.
                tool_ordering.cal_most_used_extruder(print.config());
                m_printed_objects.emplace_back(&object);
                this->process_layers(print, tool_ordering, collect_layers_to_print(object, print.config().belt_printer.value), *print_object_instance_sequential_active - object.instances().data(), file,
                                     prime_extruder);
                {
                    // save the flush statitics stored in tool ordering by object
                    print.m_statistics_by_extruder_count.stats_by_single_extruder += tool_ordering.get_filament_change_stats(ToolOrdering::FilamentChangeMode::SingleExt);
                    print.m_statistics_by_extruder_count.stats_by_multi_extruder_best += tool_ordering.get_filament_change_stats(ToolOrdering::FilamentChangeMode::MultiExtBest);
                    print.m_statistics_by_extruder_count.stats_by_multi_extruder_curr += tool_ordering.get_filament_change_stats(ToolOrdering::FilamentChangeMode::MultiExtCurr);
                    // save sorted filament sequences
                    const auto& layer_tools = tool_ordering.layer_tools();
                    for (const auto& lt : layer_tools)
                        m_sorted_layer_filaments.emplace_back(lt.extruders);
                }
 
                // Orca: disable power loss recovery if it was enabled earlier
                {
                    const auto plr_mode = print.config().enable_power_loss_recovery.value;
                    if (m_second_layer_things_done && plr_mode == PowerLossRecoveryMode::Enable) {
                        file.write(m_writer.enable_power_loss_recovery(PowerLossRecoveryMode::Disable));
                    }
                }
                ++ finished_objects;
                // Flag indicating whether the nozzle temperature changes from 1st to 2nd layer were performed.
                // Reset it when starting another object from 1st layer.
                m_second_layer_things_done = false;
                prev_object = &object;
            }
        } else {
            // Sort layers by Z.
            // All extrusion moves with the same top layer height are extruded uninterrupted.
            std::vector<std::pair<coordf_t, std::vector<LayerToPrint>>> layers_to_print = collect_layers_to_print(print);
            // Prusa Multi-Material wipe tower.
            if (has_wipe_tower && ! layers_to_print.empty()) {
                m_wipe_tower.reset(new WipeTowerIntegration(print.config(), print.get_plate_index(), print.get_plate_origin(), *print.wipe_tower_data().priming.get(),
                                                            print.wipe_tower_data().tool_changes, *print.wipe_tower_data().final_purge.get(), print.get_slice_used_filaments(false)));
                m_wipe_tower->set_wipe_tower_depth(print.get_wipe_tower_depth());
                m_wipe_tower->set_wipe_tower_bbx(print.get_wipe_tower_bbx());
                m_wipe_tower->set_rib_offset(print.get_rib_offset());
                //BBS
                file.write(m_writer.travel_to_z(initial_layer_print_height + m_config.z_offset.value, "Move to the first layer height"));
 
                if (wipe_tower_type == WipeTowerType::Type2 && print.config().single_extruder_multi_material_priming) {
                    file.write(m_wipe_tower->prime(*this));
                    // Verify, whether the print overaps the priming extrusions.
                    BoundingBoxf bbox_print(get_print_extrusions_extents(print));
                    coordf_t twolayers_printz = ((layers_to_print.size() == 1) ? layers_to_print.front() : layers_to_print[1]).first + EPSILON;
                    for (const PrintObject *print_object : print.objects())
                        bbox_print.merge(get_print_object_extrusions_extents(*print_object, twolayers_printz));
                    bbox_print.merge(get_wipe_tower_extrusions_extents(print, twolayers_printz));
                    BoundingBoxf bbox_prime(get_wipe_tower_priming_extrusions_extents(print));
                    bbox_prime.offset(0.5f);
                    bool overlap = bbox_prime.overlap(bbox_print);
 
                    if (print.config().gcode_flavor == gcfMarlinLegacy || print.config().gcode_flavor == gcfMarlinFirmware) {
                        file.write(this->retract());
                        file.write("M300 S800 P500\n"); // Beep for 500ms, tone 800Hz.
                        if (overlap) {
                            // Wait for the user to remove the priming extrusions.
                            file.write("M1 Remove priming towers and click button.\n");
                        } else {
                            // Just wait for a bit to let the user check, that the priming succeeded.
                            //TODO Add a message explaining what the printer is waiting for. This needs a firmware fix.
                            file.write("M1 S10\n");
                        }
                    }
                    else {
                        // This is not Marlin, M1 command is probably not supported.
                        if (overlap) {
                           print.active_step_add_warning(PrintStateBase::WarningLevel::CRITICAL,
                               _(L("Your print is very close to the priming regions. "
                                 "Make sure there is no collision.")));
                        } else {
                           // Just continue printing, no action necessary.
                        }
                    }
                }
                print.throw_if_canceled();
            }
 
            tool_ordering.cal_most_used_extruder(print.config());
 
            // Process all layers of all objects (non-sequential mode) with a parallel pipeline:
            // Generate G-code, run the filters (vase mode, cooling buffer), run the G-code analyser
            // and export G-code into file.
            this->process_layers(print, tool_ordering, print_object_instances_ordering, layers_to_print, file);
            {
                //save the flush statitics stored in tool ordering
                print.m_statistics_by_extruder_count.stats_by_single_extruder = tool_ordering.get_filament_change_stats(ToolOrdering::FilamentChangeMode::SingleExt);
                print.m_statistics_by_extruder_count.stats_by_multi_extruder_best = tool_ordering.get_filament_change_stats(ToolOrdering::FilamentChangeMode::MultiExtBest);
                print.m_statistics_by_extruder_count.stats_by_multi_extruder_curr = tool_ordering.get_filament_change_stats(ToolOrdering::FilamentChangeMode::MultiExtCurr);
                // save sorted filament sequences
                const auto& layer_tools = tool_ordering.layer_tools();
                for (const auto& lt : layer_tools)
                    m_sorted_layer_filaments.emplace_back(lt.extruders);
            }
 
            // Orca: disable power loss recovery
            if (m_second_layer_things_done && print.config().enable_power_loss_recovery.value == PowerLossRecoveryMode::Enable) {
                file.write(m_writer.enable_power_loss_recovery(PowerLossRecoveryMode::Disable));
            }
            if (m_wipe_tower)
                // Purge the extruder, pull out the active filament.
                file.write(m_wipe_tower->finalize(*this));
        }
    }
    //BBS: the last retraction
    // Write end commands to file.
    file.write(this->retract(false, true));
 
    // if needed, write the gcode_label_objects_end
    {
        std::string gcode;
        m_writer.add_object_change_labels(gcode);
        file.write(gcode);
    }
 
    file.write(m_writer.set_fan(0));
    //BBS: make sure the additional fan is closed when end
    if(m_config.auxiliary_fan.value)
        file.write(m_writer.set_additional_fan(0));
    if (is_bbl_printers) {
        //BBS: close spaghetti detector
        //Note: M981 is also used to tell xcam the last layer is finished, so we need always send it even if spaghetti option is disabled.
        //if (print.config().spaghetti_detector.value)
        file.write("M981 S0 P20000 ; close spaghetti detector\n");
    }
 
    // adds tag for processor
    file.write_format(";%s%s\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role).c_str(), ExtrusionEntity::role_to_string(erCustom).c_str());
 
    // Mark the start of the machine end g-code so the usage-block builder closes its open blocks here and
    // ignores filament changes inside the end g-code. Same enable_pre_heating gate as the start marker →
    // byte-frozen fleet unaffected.
    if (m_config.enable_pre_heating.value)
        file.write_format(";%s\n", GCodeProcessor::Machine_End_GCode_Start_Tag.c_str());
 
    // Process filament-specific gcode in extruder order.
    {
        DynamicConfig config;
        config.set_key_value("layer_num", new ConfigOptionInt(m_layer_index));
        //BBS
        config.set_key_value("layer_z",   new ConfigOptionFloat(m_writer.get_position()(2) - m_config.z_offset.value));
        config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
        config.set_key_value("nozzle_diameter_at_nozzle_id", new ConfigOptionFloats(get_nozzle_diameters_by_nozzle_id(group_result.get())));
        config.set_key_value("nozzle_volume_types", new ConfigOptionStrings(get_nozzle_volume_types_by_nozzle_id(group_result.get())));
 
        if (print.config().single_extruder_multi_material) {
            // Process the filament_end_gcode for the active filament only.
            int extruder_id = m_writer.filament()->id();
            config.set_key_value("filament_extruder_id", new ConfigOptionInt(extruder_id));
            config.set_key_value("current_filament_id", new ConfigOptionInt(extruder_id));
            config.set_key_value("current_extruder_id", new ConfigOptionInt((int) get_extruder_id(extruder_id)));
            config.set_key_value("current_nozzle_id", new ConfigOptionInt(nozzle_id_for_gcode_placeholder(group_result, extruder_id, (int) get_extruder_id(extruder_id), m_layer_index)));
            file.writeln(this->placeholder_parser_process("filament_end_gcode", print.config().filament_end_gcode.get_at(extruder_id), extruder_id, &config));
        } else {
            for (const std::string &end_gcode : print.config().filament_end_gcode.values) {
                int extruder_id = (unsigned int)(&end_gcode - &print.config().filament_end_gcode.values.front());
                config.set_key_value("filament_extruder_id", new ConfigOptionInt(extruder_id));
                config.set_key_value("current_filament_id", new ConfigOptionInt(extruder_id));
                config.set_key_value("current_extruder_id", new ConfigOptionInt((int) get_extruder_id(extruder_id)));
                config.set_key_value("current_nozzle_id", new ConfigOptionInt(nozzle_id_for_gcode_placeholder(group_result, extruder_id, (int) get_extruder_id(extruder_id), m_layer_index)));
                file.writeln(this->placeholder_parser_process("filament_end_gcode", end_gcode, extruder_id, &config));
            }
        }
        file.writeln(this->placeholder_parser_process("machine_end_gcode", print.config().machine_end_gcode, m_writer.filament()->id(), &config));
    }
    file.write(m_writer.update_progress(m_layer_count, m_layer_count, true)); // 100%
    file.write(m_writer.postamble());
 
    if (activate_chamber_temp_control && max_chamber_temp > 0)
        file.write(m_writer.set_chamber_temperature(0, false));  //close chamber_temperature
 
    // Orca: when air filtration is supported, check if it needs to be activated after print completion and set the exhaust fan speed accordingly
    if (m_config.support_air_filtration.value) {
        bool activate_air_filtration_on_completion = false;
        int complete_print_exhaust_fan_speed = 0;
 
        // Orca: when activate_air_filtration is set on any extruder, find and set the highest complete_print_exhaust_fan_speed
        for (const auto& extruder : m_writer.extruders()) {
            size_t fi = get_filament_config_index((int)extruder.id());
            if (m_config.activate_air_filtration.get_at(fi) && m_config.activate_air_filtration_on_completion.get_at(fi)) {
                activate_air_filtration_on_completion = true;
                complete_print_exhaust_fan_speed = std::max(complete_print_exhaust_fan_speed, m_config.complete_print_exhaust_fan_speed.get_at(fi));
            }
        }
 
        if (activate_air_filtration_on_completion)
            file.write(m_writer.set_exhaust_fan(complete_print_exhaust_fan_speed));
    }
 
    // adds tags for time estimators
    file.write_format(";%s\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Last_Line_M73_Placeholder).c_str());
    file.write_format("; EXECUTABLE_BLOCK_END\n\n");
 
    print.throw_if_canceled();
 
    // Some firmwares only scan the last N lines for the time estimate, so the stats are written
    // after the config block.
    if (!is_bbl_printers && !skip_config_block) {
        file.write("; CONFIG_BLOCK_START\n");
        std::string full_config;
        append_full_config(print, full_config);
        if (!full_config.empty())
          file.write(full_config);
 
        // SoftFever: write compatiple info
        file.write_format("; first_layer_bed_temperature = %d\n", compat_first_layer_bed_temp);
        file.write_format("; bed_shape = %s\n", print.full_print_config().opt_serialize("printable_area").c_str());
        file.write_format("; first_layer_temperature = %d\n", compat_first_layer_nozzle_temp);
        file.write_format("; first_layer_height = %.3f\n", print.config().initial_layer_print_height.value);
 
          //SF TODO
//        file.write_format("; variable_layer_height = %d\n", print.ad.adaptive_layer_height ? 1 : 0);
 
        file.write("; CONFIG_BLOCK_END\n\n");
    }
 
    // Get filament stats.
    file.write(DoExport::update_print_stats_and_format_filament_stats(
      // Const inputs
        has_wipe_tower, print.wipe_tower_data(),
        m_writer.extruders(),
        // Modifies
        print.m_print_statistics,
        // Const input (tool-change fallback for non-wipe-tower prints)
        print.tool_ordering()));
    print.m_print_statistics.initial_tool = initial_extruder_id;
    print.m_print_statistics.initial_no_support_tool = initial_non_support_extruder_id;
    if (!is_bbl_printers) {
        file.write_format("; total filament used [g] = %.2lf\n",
            print.m_print_statistics.total_weight);
        file.write_format("; total filament cost = %.2lf\n",
            print.m_print_statistics.total_cost);
        if (print.m_print_statistics.total_toolchanges > 0)
            file.write_format("; total filament change = %i\n",
                print.m_print_statistics.total_toolchanges);
        file.write_format("; total layers count = %i\n", m_layer_count);
        file.write_format(
            ";%s\n",
            GCodeProcessor::reserved_tag(
                GCodeProcessor::ETags::Estimated_Printing_Time_Placeholder)
            .c_str());
      file.write("\n");
    }
    file.write("\n");
 
    print.throw_if_canceled();
}

References _, _encode_label_ids_to_base64(), _print_first_layer_bed_temperature(), _print_first_layer_extruder_temperatures(), Slic3r::activate_air_filtration_on_completion(), Slic3r::activate_chamber_temp_control(), Slic3r::PrintBaseWithState< PrintStepEnum, COUNT >::active_step_add_warning(), Slic3r::ImexMode::active_tools, Slic3r::ToolOrdering::all_extruders(), Slic3r::MultiPoint::append(), append_full_config(), apply_print_config(), Slic3r::BBoxData::area, Slic3r::Polygon::area(), Slic3r::ToolOrdering::assign_custom_gcodes(), assign_object_label_ids(), Slic3r::BeltTransformPipeline::axis_remap_enabled(), Slic3r::ConstVectorOfPtrsAdaptor< T >::back(), Slic3r::WipeTowerData::bbx, Slic3r::belt_object_layer_prints_something(), Slic3r::BestOfStrategies, Slic3r::Print::SkirtBrimGroup::Brim::brim, Slic3r::btfHighestTemp, Slic3r::ByObject, Slic3r::ToolOrdering::cal_max_additional_fan(), Slic3r::ToolOrdering::cal_most_used_extruder(), Slic3r::ToolOrdering::cal_non_support_filaments(), Slic3r::Calib_Auto_PA_Line, Slic3r::Print::calib_mode(), Slic3r::Calib_None, Slic3r::Calib_PA_Line, Slic3r::Calib_PA_Pattern, Slic3r::Calib_PA_Tower, Slic3r::Print::calib_params(), Slic3r::Calib_Retraction_tower, Slic3r::cast(), Slic3r::BoundingBoxBase< PointType, APointsType >::center(), Slic3r::center(), Slic3r::chain_print_object_instances(), Slic3r::chain_print_object_instances_best_of(), Slic3r::chain_print_object_instances_snake(), Slic3r::StatisticsByExtruderCount::clear(), collect_layers_to_print(), Slic3r::complete_print_exhaust_fan_speed(), config(), Slic3r::Print::config(), Slic3r::PrintObject::config(), Slic3r::ConfigOptionFloat, Slic3r::ConfigOptionString, count, Slic3r::PrintStateBase::CRITICAL, Slic3r::curr_bed_type(), Slic3r::custom_gcode_sets_temperature(), Slic3r::Default, Slic3r::Print::default_object_config(), Slic3r::Print::default_region_config(), Slic3r::Disable, Slic3r::CalibPressureAdvanceLine::draw_numbers(), Slic3r::ConstVectorOfPtrsAdaptor< T >::empty(), Slic3r::ExtrusionEntityCollection::empty(), Slic3r::Enable, EPSILON, Slic3r::erCustom, Slic3r::erNone, Slic3r::GCodeProcessor::Estimated_Printing_Time_Placeholder, Slic3r::GCodeThumbnails::export_thumbnails_to_file(), EXTRUDER_CONFIG, Slic3r::extruder_offset(), Slic3r::Print::extruders(), Slic3r::WipeTowerData::final_purge, Slic3r::find_imex_mode(), Slic3r::CalibPressureAdvance::find_optimal_PA_speed(), Slic3r::ToolOrdering::first_extruder(), Slic3r::first_hotend_id_for_gcode_placeholder(), Slic3r::Print::first_layer_convex_hull(), Slic3r::GCodeProcessor::First_Line_M73_Placeholder, Slic3r::first_nozzle_id_for_gcode_placeholder(), Slic3r::PrintRegion::flow(), Slic3r::format(), Slic3r::ImexMode::found(), Slic3r::frExternalPerimeter, Slic3r::frInfill, Slic3r::ConstVectorOfPtrsAdaptor< T >::front(), Slic3r::frPerimeter, Slic3r::frSolidInfill, Slic3r::frTopSolidInfill, Slic3r::PrintBase::full_print_config(), Slic3r::gcfKlipper, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::ImexMode::gcode, Slic3r::CalibPressureAdvanceLine::generate_test(), Slic3r::get_bed_temp_1st_layer_key(), Slic3r::get_bed_temp_key(), get_bed_temperature(), Slic3r::GCodeThumbnails::get_error_string(), Slic3r::get_extents(), get_extruder_id(), Slic3r::Print::get_extruder_shared_printable_polygon(), Slic3r::Print::get_fake_wipe_tower(), Slic3r::ToolOrdering::get_filament_change_stats(), get_filament_config_index(), Slic3r::GCodeProcessor::get_gcode_last_filament(), get_highest_bed_temperature(), Slic3r::get_imex_active_tools(), Slic3r::Print::get_layered_nozzle_group_result(), Slic3r::Print::get_model_name(), Slic3r::get_nozzle_diameters_by_nozzle_id(), Slic3r::get_nozzle_volume_types_by_nozzle_id(), Slic3r::Print::get_object(), Slic3r::get_outer_wall_volumetric_speed(), Slic3r::get_path_of_change_filament(), Slic3r::PrintBase::get_plate_index(), Slic3r::PrintBase::get_plate_name(), Slic3r::Print::get_plate_number_formatted(), Slic3r::Print::get_plate_origin(), Slic3r::get_print_extrusions_extents(), Slic3r::get_print_object_extrusions_extents(), Slic3r::Print::get_print_region(), Slic3r::Print::get_rib_offset(), Slic3r::Print::get_slice_used_filaments(), Slic3r::Print::get_wipe_tower_bbx(), Slic3r::Print::get_wipe_tower_depth(), Slic3r::get_wipe_tower_extrusions_extents(), Slic3r::get_wipe_tower_priming_extrusions_extents(), Slic3r::GCodeProcessor::PositionState::has_known_xy(), Slic3r::Print::has_support_material(), Slic3r::Print::has_wipe_tower(), Slic3r::ToolOrdering::has_wipe_tower(), Slic3r::header_slic3r_generated(), Slic3r::CalibPressureAdvanceLine::height_layer(), Slic3r::imex_secondary_logical_slots(), Slic3r::ImexMode::index, init_belt_writer(), Slic3r::DoExport::init_gcode_processor(), Slic3r::DoExport::init_ooze_prevention(), Slic3r::initial_layer_print_height(), Slic3r::PrintStatistics::initial_no_support_tool, Slic3r::PrintStatistics::initial_tool, Slic3r::install_belt_kinematics(), Slic3r::Print::SkirtBrimGroup::Brim::instances, Slic3r::intersection_pl(), Slic3r::Print::is_BBL_printer(), Slic3r::Print::is_dynamic_group_reorder(), Slic3r::is_multi_nozzle_printer(), Slic3r::kImexPrimaryMode, L, Slic3r::ToolOrdering::last_extruder(), Slic3r::GCodeProcessor::Last_Line_M73_Placeholder, layer(), Slic3r::GCodeProcessor::Layer_Change, Slic3r::BBoxData::layer_height, Slic3r::layer_height(), Slic3r::ToolOrdering::layer_tools(), Slic3r::PrintObject::layers(), Slic3r::CalibPressureAdvanceLine::line_width(), Slic3r::Utils::local_timestamp(), Slic3r::Layer::lslices, m_avoid_crossing_perimeters, m_belt_in_band, m_brim_done, Slic3r::Print::m_brimMap, m_calib_config, m_config, m_cooling_buffer, m_enable_cooling_markers, m_enable_exclude_object, m_enable_extrusion_role_markers, m_fan_mover, m_filament_instances_code, m_imex_head_filament_map, m_imex_parallel_mode, m_is_role_based_fan_on, m_label_objects_ids, m_last_height, m_last_layer_accumulated_mass, m_last_layer_z, m_last_pos_defined, m_last_width, m_layer_count, m_layer_index, m_max_layer_z, m_objsWithBrim, m_ooze_prevention, m_ordering_cache, m_origin, m_pa_processor, m_pending_start_gcode_position, m_placeholder_parser_integration, m_pressure_equalizer, m_print, Slic3r::Print::m_print_statistics, m_printed_objects, m_processor, m_role_based_fan_marker_layer, m_seam_placer, m_second_layer_things_done, m_small_area_infill_flow_compensator, m_sorted_layer_filaments, m_spiral_vase, m_start_gcode_filament, Slic3r::Print::m_statistics_by_extruder_count, m_timelapse_pos_picker, m_timelapse_uses_clear_to_x0, m_timelapse_uses_pos, m_wipe_tower, m_writer, Slic3r::GCodeProcessor::Machine_End_GCode_Start_Tag, Slic3r::machine_start_gcode(), Slic3r::GCodeProcessor::Machine_Start_GCode_End_Tag, Slic3r::GCodeThumbnails::make_and_check_thumbnail_list(), Slic3r::make_unique(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, MAXIMUM_EXTRUDER_NUMBER, Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::Calib_Params::mode, Slic3r::ToolOrdering::MultiExtBest, Slic3r::ToolOrdering::MultiExtCurr, Slic3r::BBoxData::name, Slic3r::Print::need_check_multi_filaments_compatibility(), Slic3r::PrintStateBase::NON_CRITICAL, Slic3r::GCodeProcessor::Normal_Print_Time_Placeholder, NOZZLE_CONFIG, Slic3r::nozzle_id_for_gcode_placeholder(), Slic3r::Print::num_object_instances(), Slic3r::Print::num_print_regions(), Slic3r::Print::objects(), Slic3r::BoundingBoxBase< PointType, APointsType >::offset(), on_first_layer(), on_set_origin(), Slic3r::ConfigBase::opt_serialize(), Slic3r::BoundingBoxBase< PointType, APointsType >::overlap(), Slic3r::parse_imex_head_filament_map(), placeholder_parser(), Slic3r::PrintBase::placeholder_parser(), placeholder_parser_process(), Slic3r::MultiPoint::points, Slic3r::FakeWipeTower::pos, Slic3r::GCodeProcessor::PositionState::position, Slic3r::PosX, Slic3r::PosY, Slic3r::PosZ, preamble(), Slic3r::WipeTowerData::priming, Print, Slic3r::CalibPressureAdvanceLine::print_extents(), print_machine_envelope(), Slic3r::Calib_Params::print_numbers, Slic3r::Print::print_object_ids(), Slic3r::GCodeProcessor::Print_Time_Day_Placeholder, Slic3r::GCodeProcessor::Print_Time_Hour_Placeholder, Slic3r::GCodeProcessor::Print_Time_Minute_Placeholder, Slic3r::GCodeProcessor::Print_Time_Sec_Placeholder, Slic3r::GCodeProcessor::Print_Time_Total_Sec_Placeholder, Slic3r::Layer::print_z, Slic3r::PrintObjectConfig, process_layers(), Slic3r::GCodeProcessor::reserved_tag(), Slic3r::resolve_filament_for_head(), Slic3r::DoExport::resolve_total_toolchanges(), retract(), Slic3r::GCodeProcessor::Role, Slic3r::ExtrusionEntity::role_to_string(), scale_, Slic3r::Print::sequential_dynamic_orderings(), Slic3r::PlaceholderParser::set(), Slic3r::PlaceholderParser::set_deferred(), set_extruder(), set_extruders(), set_filament_pressure_advance(), Slic3r::set_mass_locator(), set_object_info(), set_origin(), Slic3r::CalibPressureAdvanceLine::set_speed(), Slic3r::GCodeProcessor::Silent_Print_Time_Placeholder, Slic3r::single_extruder_multi_material_priming(), Slic3r::ToolOrdering::SingleExt, Slic3r::BoundingBoxBase< PointType, APointsType >::size(), Slic3r::MultiPoint::size(), Slic3r::Print::skirt_brim_groups(), Slic3r::PrintStateBase::SlicingPreciseSeamWarning, Slic3r::Snake, Slic3r::ToolOrdering::sort_and_build_data(), Slic3r::sort_object_instances_by_model_order(), Slic3r::StatisticsByExtruderCount::stats_by_multi_extruder_best, Slic3r::StatisticsByExtruderCount::stats_by_multi_extruder_curr, Slic3r::StatisticsByExtruderCount::stats_by_single_extruder, Slic3r::SupportLayer::support_islands, Slic3r::PrintObject::support_layers(), Slic3r::support_material_flow(), Slic3r::PrintBase::throw_if_canceled(), Slic3r::WipeTowerData::tool_changes, Slic3r::Print::tool_ordering(), Slic3r::PrintStatistics::total_cost, Slic3r::GCodeProcessor::Total_Cost_Placeholder, Slic3r::GCodeProcessor::Total_Layer_Number_Placeholder, Slic3r::PrintStatistics::total_toolchanges, Slic3r::PrintStatistics::total_weight, Slic3r::GCodeProcessor::Total_Weight_Placeholder, Slic3r::GCodeProcessor::Total_Wipe_Tower_Cost_Placeholder, Slic3r::GCodeProcessor::Total_Wipe_Tower_Filament_Placeholder, Slic3r::BoundingBoxBase< PointType, APointsType >::translate(), Slic3r::Print::translate_to_print_space(), Slic3r::travel_point_1, Slic3r::travel_point_2, Slic3r::travel_point_3, travel_to(), Slic3r::Type2, Slic3r::union_(), Slic3r::unscale(), Slic3r::unscaled(), update_layer_related_config(), Slic3r::PrintBase::update_object_placeholders(), update_placeholder_parser_with_variant_params(), Slic3r::DoExport::update_print_stats_and_format_filament_stats(), Slic3r::GCodeProcessor::Used_Filament_Length_Placeholder, Slic3r::ConfigOptionVector< int >::values, Slic3r::Flow::width(), Slic3r::Print::wipe_tower_data(), Slic3r::WipeTowerData::wipe_tower_mesh_data, wipe_tower_type(), Slic3r::Print::wipe_tower_type(), WipeTowerIntegration, Slic3r::GCode::GCodeOutputStream::write(), write_belt_header(), Slic3r::GCode::GCodeOutputStream::write_format(), Slic3r::GCode::GCodeOutputStream::writeln(), and writer().

Referenced by do_export().

Here is the caller graph for this function:

_encode_label_ids_to_base64()

std::string Slic3r::GCode::_encode_label_ids_to_base64 ( std::vector< size_t > ids )

protectedinherited

{
    assert(m_label_objects_ids.size() < 64);
 
    uint64_t bitset = 0;
    for (size_t id : ids) {
        auto index = std::lower_bound(m_label_objects_ids.begin(), m_label_objects_ids.end(), id);
        if (index != m_label_objects_ids.end() && *index == id)
            bitset |= (1ull << (index - m_label_objects_ids.begin()));
        else
            throw Slic3r::LogicError("Unknown label object id!");
    }
    if (bitset == 0)
        throw Slic3r::LogicError("Label object id error!");
 
    return encodeBase64(bitset);
}

References Slic3r::encodeBase64(), and m_label_objects_ids.

Referenced by _do_export(), and generate_timelapse_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

_extrude()

std::string Slic3r::GCode::_extrude ( const ExtrusionPath & path, const std::string & path_description = "", double speed = -1 )

protectedinherited

{
    std::string gcode;
 
    const std::string  bridge_description = is_bridge(path.role()) ? path_description + " (bridge)" : std::string();
    const std::string &description        = bridge_description.empty() ? path_description : bridge_description;
 
    // First-layer plane evaluation: compute the path's slicing-frame point
    // once and reuse for every per-path call site below.  When the plane
    // evaluator is inactive (non-belt printers, or belt printers without
    // a Z-axis shear) `path_on_first_layer` falls back to the legacy
    // layer-id check, so behavior is bit-identical to the pre-feature path.
    // A belt brim apron band has no Layer of its own, so it publishes its Z
    // through m_belt_brim_z instead; without that the plane would be probed at
    // Z=0 and the apron mis-classified for fan and speed.
    const Vec3d path_point_mm{
        unscale<double>(path.first_point().x()),
        unscale<double>(path.first_point().y()),
        m_layer ? m_layer->print_z : (m_belt_brim_z ? *m_belt_brim_z : 0.0)
    };
    const bool path_on_first_layer = this->on_first_layer(path_point_mm);
 
    const ExtrusionPathSloped* sloped = dynamic_cast<const ExtrusionPathSloped*>(&path);
 
    const auto get_sloped_z = [&sloped, this](double z_ratio) {
        const auto height = sloped->height;
        return lerp(m_nominal_z - height, m_nominal_z, z_ratio);
    };
 
    bool slope_need_z_travel = false;
    if (sloped != nullptr && !sloped->is_flat()) {
        auto target_z = get_sloped_z(sloped->slope_begin.z_ratio);
        slope_need_z_travel = m_writer.will_move_z(target_z);
    }
    // Move to first point of extrusion path
    // path is 2D. But in slope lift case, lift z is done in travel_to function.
    // Add m_need_change_layer_lift_z when change_layer in case of no lift if m_last_pos is equal to path.first_point() by chance
    Point first_point = path.first_point();
    if (!m_last_pos_defined || m_last_pos.to_point() != first_point || m_need_change_layer_lift_z ||
        slope_need_z_travel) {
        const bool _last_pos_undefined = !m_last_pos_defined;
 
        double z = DBL_MAX;
        if (sloped != nullptr) {
            z =  get_sloped_z(sloped->slope_begin.z_ratio);
        } else if (path.z_contoured && !path.polyline.lines().empty()) {
            z = unscale_(path.polyline.lines().begin()->a.z()) + m_nominal_z;
        }
 
        gcode += this->travel_to(first_point, path.role(), "move to first " + description + " point", z);
 
        // Orca: ensure Z matches planned layer height
        if (!slope_need_z_travel && (_last_pos_undefined || m_need_change_layer_lift_z)) {
            const std::string z_sync_comment = _last_pos_undefined ?
                "ensure Z matches planned layer height" : ""; // no comment for normal layer-Z lift
            gcode += this->writer().travel_to_z(m_nominal_z, z_sync_comment, true);
        }
        m_need_change_layer_lift_z = false;
    }
 
    if (path.z_contoured && !path.polyline.lines().empty()) {
        double current_z = m_writer.get_position().z();
        double first_z = unscale_(path.polyline.lines().begin()->a.z()) + m_nominal_z;
        if (GCodeFormatter::quantize_xyz(first_z, m_config.high_precision_gcode.value) !=
            GCodeFormatter::quantize_xyz(current_z, m_config.high_precision_gcode.value)) {
            gcode += m_writer.travel_to_z(first_z, "set Z for contouring", true);
        }
    }
    if (!path.z_contoured && sloped == nullptr) {
        double current_z = m_writer.get_position().z();
        if (GCodeFormatter::quantize_xyz(current_z, m_config.high_precision_gcode.value) !=
            GCodeFormatter::quantize_xyz(m_nominal_z, m_config.high_precision_gcode.value)) {
            gcode += this->writer().travel_to_z(m_nominal_z, "reset Z after contouring", true);
        }
    }
 
    // if needed, write the gcode_label_objects_end then gcode_label_objects_start
    // should be already done by travel_to, but just in case
    m_writer.add_object_change_labels(gcode);
 
    // compensate retraction
    gcode += this->unretract();
    m_config.apply(m_calib_config);
 
    // Orca: optimize for Klipper, set acceleration and jerk in one command
    unsigned int acceleration_i = 0;
    double jerk = 0;
    // adjust acceleration
    const size_t nozzle = get_nozzle_config_index(m_writer.filament()->id());
    if (m_config.default_acceleration.get_at(nozzle) > 0) {
        const ExtrusionRole role = path.role();
        const double bridge_acceleration = is_bridge(role) ?
            m_config.bridge_acceleration.get_at(nozzle).get_abs_value(m_config.outer_wall_acceleration.get_at(nozzle)) : 0.;
        const double sparse_infill_acceleration = role == erInternalInfill ?
            m_config.sparse_infill_acceleration.get_at(nozzle).get_abs_value(m_config.default_acceleration.get_at(nozzle)) : 0.;
        const double internal_solid_infill_acceleration = role == erSolidInfill ?
            m_config.internal_solid_infill_acceleration.get_at(nozzle).get_abs_value(m_config.default_acceleration.get_at(nozzle)) : 0.;
        double acceleration;
        if (path_on_first_layer && m_config.initial_layer_acceleration.get_at(nozzle) > 0) {
            acceleration = m_config.initial_layer_acceleration.get_at(nozzle);
#if 0
        } else if (this->object_layer_over_raft() && m_config.first_layer_acceleration_over_raft.value > 0) {
            acceleration = m_config.first_layer_acceleration_over_raft.value;
#endif
        } else if (bridge_acceleration > 0) {
            acceleration = bridge_acceleration;
        } else if (sparse_infill_acceleration > 0) {
            acceleration = sparse_infill_acceleration;
        } else if (internal_solid_infill_acceleration > 0) {
            acceleration = internal_solid_infill_acceleration;
        } else if (m_config.outer_wall_acceleration.get_at(nozzle) > 0 && is_external_perimeter(role)) {
            acceleration = m_config.outer_wall_acceleration.get_at(nozzle);
        } else if (m_config.inner_wall_acceleration.get_at(nozzle) > 0 && is_internal_perimeter(role)) {
            acceleration = m_config.inner_wall_acceleration.get_at(nozzle);
        } else if (m_config.top_surface_acceleration.get_at(nozzle) > 0 && is_top_surface(role)) {
            acceleration = m_config.top_surface_acceleration.get_at(nozzle);
        } else {
            acceleration = m_config.default_acceleration.get_at(nozzle);
        }
        acceleration_i = (unsigned int)floor(acceleration + 0.5);
    }
 
    // adjust X Y jerk
    if (NOZZLE_CONFIG(default_jerk) > 0) {
        if (path_on_first_layer && NOZZLE_CONFIG(initial_layer_jerk) > 0) {
            jerk = NOZZLE_CONFIG(initial_layer_jerk);
        } else if (NOZZLE_CONFIG(outer_wall_jerk) > 0 && is_external_perimeter(path.role())) {
             jerk = NOZZLE_CONFIG(outer_wall_jerk);
        } else if (NOZZLE_CONFIG(inner_wall_jerk) > 0 && is_internal_perimeter(path.role())) {
            jerk = NOZZLE_CONFIG(inner_wall_jerk);
        } else if (NOZZLE_CONFIG(top_surface_jerk) > 0 && is_top_surface(path.role())) {
            jerk = NOZZLE_CONFIG(top_surface_jerk);
        } else if (NOZZLE_CONFIG(infill_jerk) > 0 && is_infill(path.role())) {
            jerk = NOZZLE_CONFIG(infill_jerk);
        }
        else {
            jerk = NOZZLE_CONFIG(default_jerk);
        }
    }
 
    if (m_writer.get_gcode_flavor() == gcfKlipper) {
        gcode += m_writer.set_accel_and_jerk(acceleration_i, jerk);
 
    } else {
        gcode += m_writer.set_print_acceleration(acceleration_i);
        gcode += m_writer.set_jerk_xy(jerk);
    }
 
    // calculate effective extrusion length per distance unit (e_per_mm)
    double filament_flow_ratio = FILAMENT_CONFIG(filament_flow_ratio);
    // We set _mm3_per_mm to effectove flow = Geometric volume * print flow ratio * filament flow ratio * role-based-flow-ratios
    auto _mm3_per_mm = path.mm3_per_mm * this->config().print_flow_ratio;
    _mm3_per_mm *= filament_flow_ratio;
 
    if (path.role() == erTopSolidInfill) {
        _mm3_per_mm *= NOZZLE_CONFIG(top_solid_infill_flow_ratio);
    } else if (path.role() == erBottomSurface) {
        _mm3_per_mm *= m_config.bottom_solid_infill_flow_ratio;
    } else if (path.role() == erInternalBridgeInfill) {
        _mm3_per_mm *= m_config.internal_bridge_flow;
    } else if (path.role() == erBrim) {
        _mm3_per_mm *= m_config.brim_flow_ratio;
    } else if (sloped) {
        _mm3_per_mm *= m_config.scarf_joint_flow_ratio;
    }
 
    if (m_config.set_other_flow_ratios) {
        if (path.role() == erExternalPerimeter) {
            _mm3_per_mm *= m_config.outer_wall_flow_ratio;
        } else if (path.role() == erPerimeter) {
            _mm3_per_mm *= m_config.inner_wall_flow_ratio;
        } else if (path.role() == erOverhangPerimeter) {
            _mm3_per_mm *= m_config.overhang_flow_ratio;
        } else if (path.role() == erInternalInfill) {
            _mm3_per_mm *= m_config.sparse_infill_flow_ratio;
        } else if (path.role() == erSolidInfill) {
            _mm3_per_mm *= m_config.internal_solid_infill_flow_ratio;
        } else if (path.role() == erGapFill) {
            _mm3_per_mm *= m_config.gap_fill_flow_ratio;
        } else if (path.role() == erSupportMaterial) { // Should this condition also cover erSupportTransition?
            _mm3_per_mm *= m_config.support_flow_ratio;
        } else if (path.role() == erSupportMaterialInterface) {
            _mm3_per_mm *= m_config.support_interface_flow_ratio;
        }
 
        // Additionally, adjust the value if we are on the first layer (except for brims and skirts)
        if (path_on_first_layer && (path.role() != erBrim && path.role() != erSkirt)) {
            _mm3_per_mm *= m_config.first_layer_flow_ratio;
        }
    }
 
    // Mixed-color sublayer: this path belongs to one sub-layer of a split layer, so scale the
    // flow down to that sub-layer's share of the nominal layer height and report the sub-height
    // as the effective extrusion height. Inert (ratio == 0) outside the sublayer emission block.
    float effective_height = path.height;
    if (m_sub_layer_flow_ratio > 0.0) {
        _mm3_per_mm *= m_sub_layer_flow_ratio;
        effective_height = static_cast<float>(m_sub_layer_height);
    }
 
    // _mm3_per_mm already includes the filament flow ratio, so convert it with the bare cross-section
    // rather than e_per_mm3(), which would apply the ratio a second time.
    double e_per_mm = _mm3_per_mm / m_writer.filament()->filament_crossection();
 
    // set speed
    if (speed == -1) {
        if (path.role() == erPerimeter) {
            speed = NOZZLE_CONFIG(inner_wall_speed);
            if (sloped) {
                speed = std::min(speed, m_config.scarf_joint_speed.get_abs_value(speed));
            }
        } else if (path.role() == erExternalPerimeter) {
            speed = NOZZLE_CONFIG(outer_wall_speed);
            if (sloped) {
                speed = std::min(speed, m_config.scarf_joint_speed.get_abs_value(speed));
            }
        } else if(path.role() == erInternalBridgeInfill) {
            speed = m_config.internal_bridge_speed.get_at(nozzle).get_abs_value(m_config.bridge_speed.get_at(nozzle));
        } else if (path.role() == erOverhangPerimeter || path.role() == erSupportTransition || path.role() == erBridgeInfill) {
            speed = NOZZLE_CONFIG(bridge_speed);
        } else if (path.role() == erInternalInfill) {
            speed = NOZZLE_CONFIG(sparse_infill_speed);
        } else if (path.role() == erSolidInfill) {
            speed = NOZZLE_CONFIG(internal_solid_infill_speed);
        } else if (path.role() == erTopSolidInfill) {
            speed = NOZZLE_CONFIG(top_surface_speed);
        } else if (path.role() == erIroning) {
            const size_t filament_idx = get_filament_config_index(m_writer.filament()->id());
            speed = m_config.filament_ironing_speed.is_nil(filament_idx)
                ? m_config.ironing_speed.value
                : m_config.filament_ironing_speed.get_at(filament_idx);
        } else if (path.role() == erBottomSurface) {
            speed = NOZZLE_CONFIG(initial_layer_infill_speed);
        } else if (path.role() == erGapFill) {
            speed = NOZZLE_CONFIG(gap_infill_speed);
        } else if (path.role() == erSupportMaterial) {
            speed = NOZZLE_CONFIG(support_speed);
        } else if (path.role() == erSupportMaterialInterface) {
            speed = NOZZLE_CONFIG(support_interface_speed);
        } else {
            throw Slic3r::InvalidArgument("Invalid speed");
        }
    }
    //BBS: if not set the speed, then use the filament_max_volumetric_speed directly
    double filament_max_volumetric_speed = FILAMENT_CONFIG(filament_max_volumetric_speed);
    if (FILAMENT_CONFIG(filament_adaptive_volumetric_speed)){
        double fitted_value = calc_max_volumetric_speed(path.height, path.width, FILAMENT_CONFIG(volumetric_speed_coefficients));
        filament_max_volumetric_speed = std::min(filament_max_volumetric_speed, fitted_value);
    }
 
    if (speed == 0)
        speed = filament_max_volumetric_speed / _mm3_per_mm;
    // Use the belt-aware effective layer index when on a belt printer so
    // the speed fade tracks perpendicular distance from the plane on
    // belt printers; otherwise this falls back to the slicing layer id.
    const int _layer = this->effective_layer_index_for_point(path_point_mm);
    // Belt printers: a tilted layer runs from the belt to the top of the part, so the
    // "first layers" the fan stays off for are a band along the belt. Mark where the
    // extrusion enters and leaves it, per segment, for the cooling buffer.
    const bool belt_band_tags   = m_enable_cooling_markers && m_config.belt_printer.value;
    const int  belt_band_layers = belt_band_tags ? m_config.close_fan_the_first_x_layers.get_at(m_writer.filament()->id()) : 0;
    auto tag_belt_band = [this, &gcode, belt_band_tags, belt_band_layers, z = path_point_mm.z()](coord_t x, coord_t y) {
        if (! belt_band_tags)
            return;
        const bool in_band = this->effective_layer_index_for_point(Vec3d(unscale<double>(x), unscale<double>(y), z)) < belt_band_layers;
        if (in_band != m_belt_in_band) {
            gcode += in_band ? ";_BELT_BAND_START\n" : ";_BELT_BAND_END\n";
            m_belt_in_band = in_band;
        }
    };
    if (path_on_first_layer || object_layer_over_raft()) {
        //BBS: for solid infill of first layer, speed can be higher as long as
        //wall lines have be attached
        if (path.role() != erBottomSurface) {
            const bool use_first_layer_speed = is_perimeter(path.role()) || path.role() == erBrim;
            speed = use_first_layer_speed ? NOZZLE_CONFIG(initial_layer_speed) :
                                            NOZZLE_CONFIG(initial_layer_infill_speed);
        }
    } else if (m_config.slow_down_layers > 1 && m_config.raft_layers == 0) {
        if (_layer > 0 && _layer < m_config.slow_down_layers) {
            const auto first_layer_speed =
                is_perimeter(path.role())
                    ? NOZZLE_CONFIG(initial_layer_speed)
                    : NOZZLE_CONFIG(initial_layer_infill_speed);
            if (first_layer_speed < speed) {
                speed = std::min(
                    speed,
                    Slic3r::lerp(first_layer_speed, speed,
                                (double) (_layer) / m_config.slow_down_layers));
            }
        }
    } else if (m_config.slow_down_layers > 1 && m_config.raft_layers > 0 ) {
        
        if (_layer > m_config.raft_layers && (_layer - m_config.raft_layers) < m_config.slow_down_layers) {
            const auto first_layer_speed 
                = is_perimeter(path.role()) ? NOZZLE_CONFIG(initial_layer_speed) :
                                                                       NOZZLE_CONFIG(initial_layer_infill_speed);
            if (first_layer_speed < speed) {
                speed = std::min(speed, Slic3r::lerp(first_layer_speed, speed,
                                                     (double) (_layer - m_config.raft_layers) / m_config.slow_down_layers));
            }
        }
    }
    // Override skirt speed if set
    if (path.role() == erSkirt) {
        const double skirt_speed = m_config.skirt_speed.value;
        if (skirt_speed > 0.0)
        speed = skirt_speed;
    }
    //BBS: remove this config
    //else if (this->object_layer_over_raft())
    //    speed = m_config.get_abs_value("first_layer_speed_over_raft", speed);
    //if (m_config.max_volumetric_speed.value > 0) {
    //    // cap speed with max_volumetric_speed anyway (even if user is not using autospeed)
    //    speed = std::min(
    //        speed,
    //        m_config.max_volumetric_speed.value / _mm3_per_mm
    //    );
    //}
    if (FILAMENT_CONFIG(filament_max_volumetric_speed) > 0) {
        // cap speed with max_volumetric_speed anyway (even if user is not using autospeed)
        speed = std::min(speed, FILAMENT_CONFIG(filament_max_volumetric_speed) / _mm3_per_mm);
    }
    // ORCA: resonance‑avoidance on short external perimeters
{
    double ref_speed = speed;  // stash the pre‑cap speed
    if (path.role() == erExternalPerimeter
        && m_config.resonance_avoidance.value) {
 
        // if our original speed was above “max”, disable RA for this loop
        if (ref_speed > m_config.max_resonance_avoidance_speed.value) {
            m_resonance_avoidance = false;
        }
 
        // re‑apply volumetric cap
        if (FILAMENT_CONFIG(filament_max_volumetric_speed) > 0) {
            speed = std::min(
                speed,
                FILAMENT_CONFIG(filament_max_volumetric_speed) / _mm3_per_mm
            );
        }
 
            // if still in avoidance mode and under "max", adjust speed:
            // - speeds in lower half of range: clamp down to "min"
            // - speeds in upper half of range: boost up to "max"
        if (m_resonance_avoidance && speed < m_config.max_resonance_avoidance_speed.value) {
            if (speed < m_config.min_resonance_avoidance_speed.value +
                            ((m_config.max_resonance_avoidance_speed.value - m_config.min_resonance_avoidance_speed.value) / 2)) {
                speed = std::min(speed, m_config.min_resonance_avoidance_speed.value);
            } else {
                speed = m_config.max_resonance_avoidance_speed.value;
            }
        }
 
        // reset flag for next segment
        m_resonance_avoidance = true;
    }
}
    
    bool requires_segmented_extrusion = false;
    // A uniform fan state can be represented by the normal path-wide marker. Only a
    // transition within the path requires point-by-point emission.
    bool path_overhang_fan_active = false;
    std::vector<ProcessedPoint> new_points {};
 
    const bool need_overhang_detection = NOZZLE_CONFIG(enable_overhang_speed) ||
        (FILAMENT_CONFIG(enable_overhang_bridge_fan) && m_enable_cooling_markers);
 
    if (need_overhang_detection && !path_on_first_layer && !object_layer_over_raft() &&
        (is_bridge(path.role()) || is_perimeter(path.role()))) {
            bool is_external = is_external_perimeter(path.role());
            double ref_speed   = is_external ? NOZZLE_CONFIG(outer_wall_speed) : NOZZLE_CONFIG(inner_wall_speed);
            if (ref_speed == 0)
                ref_speed = FILAMENT_CONFIG(filament_max_volumetric_speed) / _mm3_per_mm;
 
            if (FILAMENT_CONFIG(filament_max_volumetric_speed) > 0) {
                ref_speed = std::min(ref_speed, FILAMENT_CONFIG(filament_max_volumetric_speed) / _mm3_per_mm);
            }
            if (sloped) {
                ref_speed = std::min(ref_speed, m_config.scarf_joint_speed.get_abs_value(ref_speed));
            }
            
            ConfigOptionPercents         overhang_overlap_levels({90, 75, 50, 25, 13, 0});
 
            // ORCA: Lets the path be split where the overhang fan switches, not only where the speed changes.
            // Bridges and overhang perimeters are cooled regardless of overlap.
            float fan_overlap_threshold = -1.f;
            if (FILAMENT_CONFIG(enable_overhang_bridge_fan) && m_enable_cooling_markers && path.role() != erBridgeInfill &&
                path.role() != erOverhangPerimeter)
                fan_overlap_threshold = overhang_fan_overlap_threshold(FILAMENT_CONFIG(overhang_fan_threshold));
 
            if (NOZZLE_CONFIG(slowdown_for_curled_perimeters)){
                ConfigOptionFloatsOrPercents dynamic_overhang_speeds(
                    {FloatOrPercent{100, true},
                     (NOZZLE_CONFIG(overhang_1_4_speed).get_abs_value(ref_speed) < 0.5) ?
                         FloatOrPercent{100, true} :
                         FloatOrPercent{NOZZLE_CONFIG(overhang_1_4_speed).get_abs_value(ref_speed) * 100 / ref_speed, true},
                     (NOZZLE_CONFIG(overhang_2_4_speed).get_abs_value(ref_speed) < 0.5) ?
                         FloatOrPercent{100, true} :
                         FloatOrPercent{NOZZLE_CONFIG(overhang_2_4_speed).get_abs_value(ref_speed) * 100 / ref_speed, true},
                     (NOZZLE_CONFIG(overhang_3_4_speed).get_abs_value(ref_speed) < 0.5) ?
                         FloatOrPercent{100, true} :
                         FloatOrPercent{NOZZLE_CONFIG(overhang_3_4_speed).get_abs_value(ref_speed) * 100 / ref_speed, true},
                     (NOZZLE_CONFIG(overhang_4_4_speed).get_abs_value(ref_speed) < 0.5) ?
                         FloatOrPercent{100, true} :
                         FloatOrPercent{NOZZLE_CONFIG(overhang_4_4_speed).get_abs_value(ref_speed) * 100 / ref_speed, true},
                     (NOZZLE_CONFIG(overhang_4_4_speed).get_abs_value(ref_speed) < 0.5) ?
                         FloatOrPercent{100, true} :
                         FloatOrPercent{NOZZLE_CONFIG(overhang_4_4_speed).get_abs_value(ref_speed) * 100 / ref_speed, true}});
 
                new_points = m_extrusion_quality_estimator.estimate_extrusion_quality(path, overhang_overlap_levels, dynamic_overhang_speeds,
                                                                              ref_speed, speed, NOZZLE_CONFIG(slowdown_for_curled_perimeters),
                                                                              fan_overlap_threshold);
          }else{
                ConfigOptionFloatsOrPercents dynamic_overhang_speeds(
                                                                     {FloatOrPercent{100, true},
                     (NOZZLE_CONFIG(overhang_1_4_speed).get_abs_value(ref_speed) < 0.5) ?
                         FloatOrPercent{100, true} :
                         FloatOrPercent{NOZZLE_CONFIG(overhang_1_4_speed).get_abs_value(ref_speed) * 100 / ref_speed, true},
                     (NOZZLE_CONFIG(overhang_2_4_speed).get_abs_value(ref_speed) < 0.5) ?
                         FloatOrPercent{100, true} :
                         FloatOrPercent{NOZZLE_CONFIG(overhang_2_4_speed).get_abs_value(ref_speed) * 100 / ref_speed, true},
                     (NOZZLE_CONFIG(overhang_3_4_speed).get_abs_value(ref_speed) < 0.5) ?
                         FloatOrPercent{100, true} :
                         FloatOrPercent{NOZZLE_CONFIG(overhang_3_4_speed).get_abs_value(ref_speed) * 100 / ref_speed, true},
                      (NOZZLE_CONFIG(overhang_4_4_speed).get_abs_value(ref_speed) < 0.5) ?
                            FloatOrPercent{100, true} :
                            FloatOrPercent{NOZZLE_CONFIG(overhang_4_4_speed).get_abs_value(ref_speed) * 100 / ref_speed, true},
                     FloatOrPercent{NOZZLE_CONFIG(bridge_speed) * 100 / ref_speed, true}});
 
                new_points = m_extrusion_quality_estimator.estimate_extrusion_quality(path, overhang_overlap_levels, dynamic_overhang_speeds,
                                                                              ref_speed, speed, NOZZLE_CONFIG(slowdown_for_curled_perimeters),
                                                                              fan_overlap_threshold);
            }
            if (!NOZZLE_CONFIG(enable_overhang_speed))
                for (ProcessedPoint &point : new_points)
                    point.speed = speed;
            requires_segmented_extrusion = std::any_of(new_points.begin(), new_points.end(),
                [speed](const ProcessedPoint &point) { return fabs(double(point.speed) - speed) > 1; }); // Ignore small speed variations (under 1mm/sec)
            if (FILAMENT_CONFIG(enable_overhang_bridge_fan) && m_enable_cooling_markers && fan_overlap_threshold >= 0.f &&
                !new_points.empty()) {
                path_overhang_fan_active = new_points.front().overlap <= fan_overlap_threshold;
                // An overhang-fan state change needs separate extrusion moves so the cooling buffer can insert
                // the corresponding fan command between them.
                requires_segmented_extrusion = requires_segmented_extrusion ||
                    std::adjacent_find(new_points.begin(), new_points.end(), [fan_overlap_threshold](const ProcessedPoint &previous,
                                                                                                      const ProcessedPoint &current) {
                        return (previous.overlap <= fan_overlap_threshold) != (current.overlap <= fan_overlap_threshold);
                    }) != new_points.end();
            }
    }
 
    double F = speed * 60;  // convert mm/sec to mm/min
    
    // Orca: Dynamic PA
    // If adaptive PA is enabled, by default evaluate PA on all extrusion moves
    // The PA settings and the PA_CHANGE tags use the filament config index of the filament's extruder variant
    const unsigned int pa_config_index = (unsigned int) get_filament_config_index(m_writer.filament()->id());
    const bool adaptive_pa = m_config.adaptive_pressure_advance.get_at(pa_config_index) && m_config.enable_pressure_advance.get_at(pa_config_index);
    const bool adaptive_pa_overhangs = adaptive_pa && m_config.adaptive_pressure_advance_overhangs.get_at(pa_config_index);
    bool is_pa_calib = m_curr_print->calib_mode() == CalibMode::Calib_PA_Line ||
                       m_curr_print->calib_mode() == CalibMode::Calib_PA_Pattern ||
                       m_curr_print->calib_mode() == CalibMode::Calib_PA_Tower;
    bool evaluate_adaptive_pa = false;
    bool role_change = (m_last_extrusion_role != path.role());
    if (!is_pa_calib && adaptive_pa) {
        evaluate_adaptive_pa = true;
        // If we have already emmited a PA change because the m_multi_flow_segment_path_pa_set is set
        // skip re-issuing the PA change tag.
        if (m_multi_flow_segment_path_pa_set && evaluate_adaptive_pa)
            evaluate_adaptive_pa = false;
        // TODO: Explore forcing evaluation of PA if a role change is happening mid extrusion.
        // TODO: This would enable adapting PA for overhang perimeters as they are part of the current loop
        // TODO: The issue with simply enabling PA evaluation on a role change is that the speed change
        // TODO: is issued before the overhang perimeter role change is triggered
        // TODO: because for some reason (maybe path segmentation upstream?) there is a short path extruded
        // TODO: with the overhang speed and flow before the role change is flagged in the path.role() function.
        if(role_change)
            evaluate_adaptive_pa = true;
    }
    // Orca: End of dynamic PA trigger flag segment
    
    //Orca: process custom gcode for extrusion role change
    if (path.role() != m_last_extrusion_role) {
        const auto current_filament_id = m_writer.filament()->id();
        const std::string& machine_role_change_gcode  = m_config.change_extrusion_role_gcode.value;
        const std::string& filament_role_change_gcode = m_config.filament_change_extrusion_role_gcode.get_at(current_filament_id);
        const std::string& process_role_change_gcode  = m_config.process_change_extrusion_role_gcode.value;
 
        if (!machine_role_change_gcode.empty() || !filament_role_change_gcode.empty() || !process_role_change_gcode.empty()) {
            DynamicConfig config;
            config.set_key_value("extrusion_role", new ConfigOptionString(extrusion_role_to_string_for_parser(path.role())));
            config.set_key_value("last_extrusion_role", new ConfigOptionString(extrusion_role_to_string_for_parser(m_last_extrusion_role)));
            config.set_key_value("layer_num", new ConfigOptionInt(m_layer_index + 1));
            config.set_key_value("layer_z", new ConfigOptionFloat(m_layer == nullptr ? m_last_height : m_layer->print_z));
 
            const auto append_role_gcode = [this, current_filament_id, &config, &gcode](const std::string& key, const std::string& templ) {
                if (templ.empty())
                    return;
                gcode += this->placeholder_parser_process(key, templ, current_filament_id, &config) + "\n";
            };
 
            append_role_gcode("change_extrusion_role_gcode", machine_role_change_gcode);
            append_role_gcode("filament_change_extrusion_role_gcode", filament_role_change_gcode);
            append_role_gcode("process_change_extrusion_role_gcode", process_role_change_gcode);
        }
    }
 
    // extrude arc or line
    if (m_enable_extrusion_role_markers) {
        if (path.role() != m_last_extrusion_role) {
            char buf[32];
            sprintf(buf, ";_EXTRUSION_ROLE:%d\n", int(path.role()));
            gcode += buf;
      }
    }
 
    m_last_extrusion_role = path.role();
 
    // adds processor tags and updates processor tracking data
    // PrusaMultiMaterial::Writer may generate GCodeProcessor::Height_Tag lines without updating m_last_height
    // so, if the last role was erWipeTower we force export of GCodeProcessor::Height_Tag lines
    bool last_was_wipe_tower = (m_last_processor_extrusion_role == erWipeTower);
    char buf[64];
    assert(is_decimal_separator_point());
 
    if (path.role() != m_last_processor_extrusion_role) {
        m_last_processor_extrusion_role = path.role();
        sprintf(buf, ";%s%s\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role).c_str(), ExtrusionEntity::role_to_string(m_last_processor_extrusion_role).c_str());
        gcode += buf;
    }
 
    if (last_was_wipe_tower || m_last_width != path.width) {
        m_last_width = path.width;
        sprintf(buf, ";%s%g\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Width).c_str(), m_last_width);
        gcode += buf;
    }
 
    if (last_was_wipe_tower || std::abs(m_last_height - effective_height) > EPSILON) {
        m_last_height = effective_height;
        sprintf(buf, ";%s%g\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height).c_str(), m_last_height);
        gcode += buf;
    }
    
    // Orca: Dynamic PA
    // Post processor flag generation code segment when option to emit only at role changes is enabled
    // Variables published to the post processor:
    // 1) Tag to trigger a PA evaluation (because a role change was identified and the user has requested dynamic PA adjustments)
    // 2) Current filament config index (to identify the PA model for the currently used filament and its extruder variant)
    // 3) mm3_per_mm value (to then multiply by the final model print speed after slowdown for cooling is applied)
    // 4) the current acceleration (to pass to the model for evaluation)
    // 5) whether this is an external perimeter (for future use)
    // 6) whether this segment is triggered because of a role change (to aid in calculation of average speed for the role)
    // This tag simplifies the creation of the gcode post processor while also keeping the feature decoupled from other tags.
    if (evaluate_adaptive_pa) {
        bool isOverhangPerimeter = (path.role() == erOverhangPerimeter);
        if (m_multi_flow_segment_path_average_mm3_per_mm > 0) {
            sprintf(buf, ";%sT%u MM3MM:%g ACCEL:%u BR:%d RC:%d OV:%d\n",
                    GCodeProcessor::reserved_tag(GCodeProcessor::ETags::PA_Change).c_str(),
                    pa_config_index,
                    m_multi_flow_segment_path_average_mm3_per_mm,
                    acceleration_i,
                    ((path.role() == erBridgeInfill) ||(path.role() == erOverhangPerimeter)),
                    role_change,
                    isOverhangPerimeter);
            gcode += buf;
        } else if(_mm3_per_mm >0 ){ // Triggered when extruding a single segment path (like a line).
                                    // Check if mm3_mm value is greater than zero as the wipe before external perimeter
                                    // is a zero mm3_mm path to force de-retraction to happen and we dont want
                                    // to issue a zero flow PA change command for this
            sprintf(buf, ";%sT%u MM3MM:%g ACCEL:%u BR:%d RC:%d OV:%d\n",
                    GCodeProcessor::reserved_tag(GCodeProcessor::ETags::PA_Change).c_str(),
                    pa_config_index,
                    _mm3_per_mm,
                    acceleration_i,
                    ((path.role() == erBridgeInfill) ||(path.role() == erOverhangPerimeter)),
                    role_change,
                    isOverhangPerimeter);
            gcode += buf;
        }
    }
 
 
    auto overhang_fan_threshold = FILAMENT_CONFIG(overhang_fan_threshold);
    auto enable_overhang_bridge_fan = FILAMENT_CONFIG(enable_overhang_bridge_fan);
 
    if (enable_overhang_bridge_fan &&
        (path.role() == erBridgeInfill || path.role() == erOverhangPerimeter ||
         (overhang_fan_threshold == Overhang_threshold_none && is_external_perimeter(path.role()))))
        path_overhang_fan_active = true;
 
    //    { "0%", Overhang_threshold_none },
    //    { "10%", Overhang_threshold_1_4 },
    //    { "25%", Overhang_threshold_2_4 },
    //    { "50%", Overhang_threshold_3_4 },
    //    { "75%", Overhang_threshold_4_4 },
    //    { "95%", Overhang_threshold_bridge }
    std::string comment;
    if (m_enable_cooling_markers) {
        comment = ";_EXTRUDE_SET_SPEED";
        if (is_external_perimeter(path.role()))
            comment += ";_EXTERNAL_PERIMETER";
    }
 
    // Change fan speed based on current extrusion role
    auto append_role_based_fan_marker = [this, &gcode](const ExtrusionRole role, const std::string_view& marker_prefix, const bool fan_on) {
        assert(m_enable_cooling_markers);
 
        if (fan_on) {
            // Orca: CoolingBuffer consumes role fan markers per layer, so continuing
            // role-based fan regions need a fresh START marker on each new layer.
            if (!m_is_role_based_fan_on[role] || m_role_based_fan_marker_layer[role] != m_layer_index) {
                gcode += ";";
                gcode += marker_prefix;
                gcode += "_FAN_START\n";
                m_is_role_based_fan_on[role] = true;
                m_role_based_fan_marker_layer[role] = m_layer_index;
            }
        } else {
            if (m_is_role_based_fan_on[role]) {
                gcode += ";";
                gcode += marker_prefix;
                gcode += "_FAN_END\n";
                m_is_role_based_fan_on[role] = false;
                m_role_based_fan_marker_layer[role] = -1;
            }
        }
    };
    auto apply_role_based_fan_speed = [
        &path, &append_role_based_fan_marker,
        supp_interface_fan_speed = FILAMENT_CONFIG(support_material_interface_fan_speed),
        ironing_fan_speed        = FILAMENT_CONFIG(ironing_fan_speed)
    ] {
        append_role_based_fan_marker(erSupportMaterialInterface, "_SUPP_INTERFACE"sv,
                                     supp_interface_fan_speed >= 0 && path.role() == erSupportMaterialInterface);
        append_role_based_fan_marker(erIroning, "_IRONING"sv,
                                     ironing_fan_speed >= 0 && path.role() == erIroning);
    };
 
    // Farthest-point timelapse inline hook. When the photo head reaches (within 0.5 mm of) the
    // farthest-from-camera point while extruding, take the snapshot in place (skip_pos_pick → M971 inline
    // photo, no travel). Early-returns unless the subsystem is enabled AND the farthest point is on the
    // photo head, so it is a no-op for every printer that leaves the toggle off.
    auto check_and_insert_timelapse = [this, &gcode](const Point &endpoint_scaled) {
        if (!m_farthest_point_timelapse.enabled || !m_farthest_point_timelapse.farthest_is_photo_head || m_farthest_point_timelapse.inserted_this_layer)
            return;
        // Inline M971 only when current extruder is the photo head; other nozzles may pass through nearby
        // coordinates but their physical position differs.
        if (!m_writer.filament() || get_extruder_id(m_writer.filament()->id()) != m_farthest_point_timelapse.most_used_extruder)
            return;
        // Compare in the global print frame to match farthest_gcode_pos, which is unscale(farthest_point)
        // without the per-extruder nozzle offset. Using point_to_gcode() here would subtract extruder_offset
        // on this side only, leaving a constant mismatch that could prevent the inline photo from ever
        // triggering on machines with a non-zero photo-head extruder_offset.
        Vec2d endpoint_mm = unscale(endpoint_scaled) + m_origin;
        if ((endpoint_mm - m_farthest_point_timelapse.farthest_gcode_pos).norm() >= 0.5)
            return;
        if (!m_print || !m_layer)
            return;
        std::string timelapse_gcode = generate_timelapse_gcode(*m_print, m_layer->print_z, m_farthest_point_timelapse.most_used_extruder,
                                                               &m_farthest_point_timelapse.layer_object_label_ids, &m_printed_objects, true);
        if (!timelapse_gcode.empty()) {
            gcode += timelapse_gcode;
            m_farthest_point_timelapse.inserted_this_layer = true;
        }
    };
 
    if (!requires_segmented_extrusion) {
        // F is mm per minute.
        if( (std::abs(writer().get_current_speed() - F) > EPSILON) || (std::abs(_mm3_per_mm - m_last_mm3_mm) > EPSILON) ){
            // ORCA: Adaptive PA code segment when adjusting PA within the same feature
            // There is a speed change coming out of an overhang region
            // or a flow change, so emit the flag to evaluate PA for the upcomming extrusion
            // Emit tag before new speed is set so the post processor reads the next speed immediately and uses it.
            // Dont emit tag if it has just already been emitted from a role change above
            if(_mm3_per_mm >0 && adaptive_pa_overhangs && !evaluate_adaptive_pa){
                if(writer().get_current_speed() > F){ // Ramping down speed - use overhang logic where the minimum speed is used between current and upcoming extrusion
                    if(m_config.gcode_comments){
                        sprintf(buf, "; Ramp down-non-variable\n");
                        gcode += buf;
                    }
                    sprintf(buf, ";%sT%u MM3MM:%g ACCEL:%u BR:%d RC:%d OV:%d\n",
                            GCodeProcessor::reserved_tag(GCodeProcessor::ETags::PA_Change).c_str(),
                            pa_config_index,
                            _mm3_per_mm,
                            acceleration_i,
                            ((path.role() == erBridgeInfill) ||(path.role() == erOverhangPerimeter)),
                            1, // Force a dummy "role change" & "overhang perimeter" for the post processor, as, while technically it is not a role change,
                            // the properties of the extrusion in the overhang are different so it behaves similarly to a role
                            // change for the Adaptive PA post processor.
                            1);
                }else{ // Ramping up speed - use baseline logic where max speed is used between current and upcoming extrusion
                    if(m_config.gcode_comments){ 
                        sprintf(buf, "; Ramp up-non-variable\n");
                        gcode += buf;
                    }
                    sprintf(buf, ";%sT%u MM3MM:%g ACCEL:%u BR:%d RC:%d OV:%d\n",
                            GCodeProcessor::reserved_tag(GCodeProcessor::ETags::PA_Change).c_str(),
                            pa_config_index,
                            _mm3_per_mm,
                            acceleration_i,
                            ((path.role() == erBridgeInfill) ||(path.role() == erOverhangPerimeter)),
                            1, // Force a dummy "role change" & "overhang perimeter" for the post processor, as, while technically it is not a role change,
                            // the properties of the extrusion in the overhang are different so it is technically similar to a role
                            // change for the Adaptive PA post processor.
                            0);
                }
                gcode += buf;
                m_last_mm3_mm = _mm3_per_mm;
            }
            // ORCA: End of adaptive PA code segment
        }
        
        m_writer.set_speed(gcode, F, "", comment);
        {
            if (m_enable_cooling_markers) {
                if (enable_overhang_bridge_fan) {
                    append_role_based_fan_marker(erOverhangPerimeter, "_OVERHANG"sv, path_overhang_fan_active);
 
                    // ORCA: Add support for separate internal bridge fan speed control
                    append_role_based_fan_marker(erInternalBridgeInfill, "_INTERNAL_BRIDGE"sv, path.role() == erInternalBridgeInfill);
                }
 
                apply_role_based_fan_speed();
            }
            // BBS: use G1 if not enable arc fitting or has no arc fitting result or in spiral_mode mode or we are doing sloped extrusion
            // Attention: G2 and G3 is not supported in spiral_mode mode
            if (m_config.enable_arc_fitting.value == ArcFittingMode::Disabled || path.polyline.fitting_result.empty() || m_config.spiral_mode || sloped != nullptr || path.z_contoured || this->should_disable_arc_fitting()) {
                double path_length = 0.;
                double total_length = sloped == nullptr ? 0. : path.polyline.length() * SCALING_FACTOR;
                double saved_z      = m_writer.get_position().z();
 
                for (const Line3& line : path.polyline.lines()) {
                    std::string flow_description;
                    const double line_length = line.length() * SCALING_FACTOR;
                    if (line_length < EPSILON)
                        continue;
                    path_length += line_length;
                    auto dE = e_per_mm * line_length;
                    if (_needSAFC(path)) {
                        auto oldE = dE;
                        dE = m_small_area_infill_flow_compensator->modify_flow(line_length, dE, path.role());
 
                        if (m_config.gcode_comments && oldE > 0 && oldE != dE) {
                            flow_description = description + Slic3r::format(" | Old Flow Value: %0.5f Length: %0.5f",oldE, line_length);
                        }
                    }
                    tag_belt_band((line.a.x() + line.b.x()) / 2, (line.a.y() + line.b.y()) / 2);
                    if (path.z_contoured) {
                        // ZAA: Z anti-aliased extrusion with variable Z per point
                        Vec2d dest2d = this->point_to_gcode(line.b.to_point());
                        coordf_t z_diff = unscale_(line.b.z());
 
                        double extrusion_ratio = 1;
                        if (path.role() != erIroning) {
                            extrusion_ratio = (path.height + z_diff) / path.height;
                        }
 
                        double e = dE * extrusion_ratio;
 
                        double z = m_nominal_z + z_diff;
                        if (z < 0.1) {
                            throw RuntimeError("GCode: very low z");
                        }
                        m_writer.extrude_to_xyz(gcode, Vec3d(dest2d.x(), dest2d.y(), z), e,
                                                flow_description.empty() ? description : flow_description);
 
                    } else if (sloped == nullptr) {
                        // Normal extrusion
                        m_writer.extrude_to_xy(gcode,
                            this->point_to_gcode(line.b.to_point()),
                            dE,
                            flow_description.empty() ? description : flow_description, path.is_force_no_extrusion());
                    } else {
                        // Sloped extrusion
                        const auto [z_ratio, e_ratio] = sloped->interpolate(path_length / total_length);
                        Vec2d dest2d = this->point_to_gcode(line.b.to_point());
                        Vec3d dest3d(dest2d(0), dest2d(1), get_sloped_z(z_ratio));
                        m_writer.extrude_to_xyz(gcode,
                            dest3d,
                            dE * e_ratio,
                            flow_description.empty() ? description : flow_description, path.is_force_no_extrusion());
                    }
                    check_and_insert_timelapse(line.b.to_point()); // Inline farthest-point snapshot
                }
            } else {
                // BBS: start to generate gcode from arc fitting data which includes line and arc
                const std::vector<PathFittingData>& fitting_result = path.polyline.fitting_result;
                for (size_t fitting_index = 0; fitting_index < fitting_result.size(); fitting_index++) {
                    std::string flow_description;
                    switch (fitting_result[fitting_index].path_type) {
                    case EMovePathType::Linear_move: {
                        size_t start_index = fitting_result[fitting_index].start_point_index;
                        size_t end_index = fitting_result[fitting_index].end_point_index;
                        for (size_t point_index = start_index + 1; point_index < end_index + 1; point_index++) {
                            flow_description.clear();
                            const Line line = Line(path.polyline.points[point_index - 1].to_point(), path.polyline.points[point_index].to_point());
                            const double line_length = line.length() * SCALING_FACTOR;
                            if (line_length < EPSILON)
                                continue;
                            auto dE = e_per_mm * line_length;
                            if (_needSAFC(path)) {
                                auto oldE = dE;
                                dE = m_small_area_infill_flow_compensator->modify_flow(line_length, dE, path.role());
 
                                if (m_config.gcode_comments && oldE > 0 && oldE != dE) {
                                    flow_description = description + Slic3r::format(" | Old Flow Value: %0.5f Length: %0.5f",oldE, line_length);
                                }
                            }
                            m_writer.extrude_to_xy(gcode,
                                this->point_to_gcode(line.b),
                                dE,
                                flow_description.empty() ? description : flow_description, path.is_force_no_extrusion());
                            check_and_insert_timelapse(line.b); // Inline farthest-point snapshot
                        }
                        break;
                    }
                    case EMovePathType::Arc_move_cw:
                    case EMovePathType::Arc_move_ccw: {
                        const ArcSegment& arc = fitting_result[fitting_index].arc_data;
                        const double arc_length = fitting_result[fitting_index].arc_data.length * SCALING_FACTOR;
                        if (arc_length < EPSILON)
                            continue;
                        const Vec2d center_offset = this->point_to_gcode(arc.center) - this->point_to_gcode(arc.start_point);
                        auto dE = e_per_mm * arc_length;
                        if (_needSAFC(path)) {
                            auto oldE = dE;
                            dE = m_small_area_infill_flow_compensator->modify_flow(arc_length, dE, path.role());
 
                            if (m_config.gcode_comments && oldE > 0 && oldE != dE) {
                                flow_description = description + Slic3r::format(" | Old Flow Value: %0.5f Length: %0.5f",oldE, arc_length);
                            }
                        }
                        m_writer.extrude_arc_to_xy(gcode,
                            this->point_to_gcode(arc.end_point),
                            center_offset,
                            dE,
                            arc.direction == ArcDirection::Arc_Dir_CCW,
                            flow_description.empty() ? description : flow_description, path.is_force_no_extrusion());
                        check_and_insert_timelapse(arc.end_point); // Inline farthest-point snapshot
                        break;
                    }
                    default:
                        // BBS: should never happen that a empty path_type has been stored
                        assert(0);
                        break;
                    }
                }
            }
        }
    } else {
        double last_set_speed = new_points[0].speed * 60.0;
 
        double total_length = 0;
        if (sloped != nullptr) {
            // Calculate total extrusion length
            Points3 p;
            p.reserve(new_points.size());
            std::transform(new_points.begin(), new_points.end(), std::back_inserter(p), [](const ProcessedPoint& pp) { return pp.p; });
            Polyline3 l(p);
            total_length = l.length() * SCALING_FACTOR;
        }
        m_writer.set_speed(gcode, last_set_speed, "", comment);
        Vec3d prev            = this->point_to_gcode_quantized(new_points[0].p);
        bool pre_fan_enabled = false;
        bool cur_fan_enabled = false;
        if( m_enable_cooling_markers && enable_overhang_bridge_fan)
            pre_fan_enabled = overhang_fan_active(new_points[0].overlap, overhang_fan_threshold, path.role());
        
        if(path.role() == erInternalBridgeInfill) // ORCA: Add support for separate internal bridge fan speed control
            pre_fan_enabled = true;
 
        double path_length = 0.;
        for (size_t i = 1; i < new_points.size(); i++) {
            std::string flow_description;
            const ProcessedPoint &processed_point = new_points[i];
            const ProcessedPoint &pre_processed_point = new_points[i-1];
            Vec3d                 p                   = this->point_to_gcode_quantized(processed_point.p);
            tag_belt_band((pre_processed_point.p.x() + processed_point.p.x()) / 2, (pre_processed_point.p.y() + processed_point.p.y()) / 2);
            if (m_enable_cooling_markers) {
                if (enable_overhang_bridge_fan) {
                    cur_fan_enabled = overhang_fan_active(processed_point.overlap, overhang_fan_threshold, path.role());
                    append_role_based_fan_marker(erOverhangPerimeter, "_OVERHANG"sv, pre_fan_enabled && cur_fan_enabled);
                    pre_fan_enabled = cur_fan_enabled;
 
                    // ORCA: Add support for separate internal bridge fan speed control
                    append_role_based_fan_marker(erInternalBridgeInfill, "_INTERNAL_BRIDGE"sv, path.role() == erInternalBridgeInfill);
                }
 
                apply_role_based_fan_speed();
            }
 
            const double line_length = (p - prev).norm();
            if(line_length < EPSILON)
                continue;
            path_length += line_length;
            double new_speed = pre_processed_point.speed * 60.0;
            
            if ((std::abs(last_set_speed - new_speed) > EPSILON) || (std::abs(_mm3_per_mm - m_last_mm3_mm) > EPSILON)) {
                // ORCA: Adaptive PA code segment when adjusting PA within the same feature
                // There is a speed change or flow change so emit the flag to evaluate PA for the upcomming extrusion
                // Emit tag before new speed is set so the post processor reads the next speed immediately and uses it.
                if(_mm3_per_mm >0 && adaptive_pa_overhangs){
                    if(last_set_speed > new_speed){ // Ramping down speed - use overhang logic where the minimum speed is used between current and upcoming extrusion
                        if(m_config.gcode_comments) {
                            sprintf(buf, "; Ramp up-variable\n");
                            gcode += buf;
                        }
                        sprintf(buf, ";%sT%u MM3MM:%g ACCEL:%u BR:%d RC:%d OV:%d\n",
                                GCodeProcessor::reserved_tag(GCodeProcessor::ETags::PA_Change).c_str(),
                                pa_config_index,
                                _mm3_per_mm,
                                acceleration_i,
                                ((path.role() == erBridgeInfill) ||(path.role() == erOverhangPerimeter)),
                                1, // Force a dummy "role change" & "overhang perimeter" for the post processor, as, while technically it is not a role change,
                                // the properties of the extrusion in the overhang are different so it is technically similar to a role
                                // change for the Adaptive PA post processor.
                                1);
                    }else{ // Ramping up speed - use baseline logic where max speed is used between current and upcoming extrusion
                        if(m_config.gcode_comments) {
                            sprintf(buf, "; Ramp down-variable\n");
                            gcode += buf;
                        }
                        sprintf(buf, ";%sT%u MM3MM:%g ACCEL:%u BR:%d RC:%d OV:%d\n",
                                GCodeProcessor::reserved_tag(GCodeProcessor::ETags::PA_Change).c_str(),
                                pa_config_index,
                                _mm3_per_mm,
                                acceleration_i,
                                ((path.role() == erBridgeInfill) ||(path.role() == erOverhangPerimeter)),
                                1, // Force a dummy "role change" & "overhang perimeter" for the post processor, as, while technically it is not a role change,
                                // the properties of the extrusion in the overhang are different so it is technically similar to a role
                                // change for the Adaptive PA post processor.
                                0);
                    }
                    gcode += buf;
                    m_last_mm3_mm = _mm3_per_mm;
                }
            }// ORCA: End of adaptive PA code segment
            
            // Ignore small speed variations - emit speed change if the delta between current and new is greater than 60mm/min / 1mm/sec
            // Reset speed to F if delta to F is less than 1mm/sec
            if ((std::abs(last_set_speed - new_speed) > 60)) {
                m_writer.set_speed(gcode, new_speed, "", comment);
                last_set_speed = new_speed;
            } else if ((std::abs(F - new_speed) <= 60)) {
                m_writer.set_speed(gcode, F, "", comment);
                last_set_speed = F;
            }
            auto dE = e_per_mm * line_length;
            if (_needSAFC(path)) {
                auto oldE = dE;
                dE = m_small_area_infill_flow_compensator->modify_flow(line_length, dE, path.role());
 
                if (m_config.gcode_comments && oldE > 0 && oldE != dE) {
                    flow_description = description + Slic3r::format(" | Old Flow Value: %0.5f Length: %0.5f",oldE, line_length);
                }
            }
            if (path.z_contoured) {
                Vec2d    dest2d = p.head<2>();
                coordf_t z_diff = unscale_(processed_point.p.z());
 
                double extrusion_ratio = 1;
                if (path.role() != erIroning) {
                    extrusion_ratio = (path.height + z_diff) / path.height;
                }
 
                double e = dE * extrusion_ratio;
 
                double z = m_nominal_z + z_diff;
                if (z < 0.1) {
                    throw RuntimeError("GCode: very low z");
                }
                m_writer.extrude_to_xyz(gcode, Vec3d(dest2d.x(), dest2d.y(), z), e,
                                        flow_description.empty() ? description : flow_description);
            } else if (sloped == nullptr) {
                // Normal extrusion
                m_writer.extrude_to_xy(gcode, p.head<2>(), dE, flow_description.empty() ? description : flow_description);
            } else {
                // Sloped extrusion
                const auto [z_ratio, e_ratio] = sloped->interpolate(path_length / total_length);
                Vec3d dest3d(p(0), p(1), get_sloped_z(z_ratio));
                m_writer.extrude_to_xyz(gcode, dest3d, dE * e_ratio, flow_description.empty() ? description : flow_description);
            }
 
            // Inline farthest-point snapshot on the segmented emission path. Inert unless the
            // farthest-point subsystem is on, matching the other paths.
            check_and_insert_timelapse(processed_point.p.to_point());
 
            prev = p;
 
        }
    }
    if (m_enable_cooling_markers) {
            gcode += ";_EXTRUDE_END\n";
    }
 
    if (path.role() != ExtrusionRole::erGapFill) {
      m_last_notgapfill_extrusion_role = path.role();
    }
 
    this->set_last_pos(path.last_point());
    return gcode;
}

References _needSAFC(), Slic3r::Arc_Dir_CCW, Slic3r::Arc_move_ccw, Slic3r::Arc_move_cw, Slic3r::Line::b, calc_max_volumetric_speed(), Slic3r::Calib_PA_Line, Slic3r::Calib_PA_Pattern, Slic3r::Calib_PA_Tower, Slic3r::Circle::center, config(), Slic3r::ConfigOptionFloat, Slic3r::ConfigOptionString, Slic3r::Disabled, effective_layer_index_for_point(), Slic3r::enable_overhang_speed(), Slic3r::ArcSegment::end_point, EPSILON, Slic3r::erBottomSurface, Slic3r::erBridgeInfill, Slic3r::erBrim, Slic3r::erExternalPerimeter, Slic3r::erGapFill, Slic3r::erInternalBridgeInfill, Slic3r::erInternalInfill, Slic3r::erIroning, Slic3r::erOverhangPerimeter, Slic3r::erPerimeter, Slic3r::erSkirt, Slic3r::erSolidInfill, Slic3r::erSupportMaterial, Slic3r::erSupportMaterialInterface, Slic3r::erSupportTransition, Slic3r::erTopSolidInfill, Slic3r::erWipeTower, extrusion_role_to_string_for_parser(), Slic3r::F, Slic3r::filament_adaptive_volumetric_speed(), FILAMENT_CONFIG, Slic3r::filament_flow_ratio(), Slic3r::ExtrusionPath::first_point(), Slic3r::Polyline3::fitting_result, Slic3r::format(), Slic3r::gcfKlipper, generate_timelapse_gcode(), get_extruder_id(), get_filament_config_index(), get_nozzle_config_index(), Slic3r::GCodeProcessor::Height, Slic3r::ExtrusionPath::height, Slic3r::initial_layer_infill_speed(), Slic3r::inner_wall_speed(), Slic3r::internal_solid_infill_speed(), Slic3r::ExtrusionPathSloped::interpolate(), Slic3r::ironing_fan_speed(), Slic3r::is_bridge(), Slic3r::is_decimal_separator_point(), Slic3r::is_external_perimeter(), Slic3r::ExtrusionPathSloped::is_flat(), Slic3r::ExtrusionPath::is_force_no_extrusion(), Slic3r::is_infill(), Slic3r::is_internal_perimeter(), Slic3r::is_perimeter(), Slic3r::is_top_surface(), Slic3r::ExtrusionPath::last_point(), Slic3r::Line::length(), Slic3r::MultiPoint3::length(), Slic3r::lerp(), Slic3r::Linear_move, Slic3r::Polyline3::lines(), m_belt_brim_z, m_belt_in_band, m_calib_config, m_config, m_curr_print, m_enable_cooling_markers, m_enable_extrusion_role_markers, m_extrusion_quality_estimator, m_farthest_point_timelapse, m_is_role_based_fan_on, m_last_extrusion_role, m_last_height, m_last_mm3_mm, m_last_notgapfill_extrusion_role, m_last_pos, m_last_pos_defined, m_last_processor_extrusion_role, m_last_width, m_layer, m_layer_index, m_multi_flow_segment_path_average_mm3_per_mm, m_multi_flow_segment_path_pa_set, m_need_change_layer_lift_z, m_nominal_z, m_origin, m_print, m_printed_objects, m_resonance_avoidance, m_role_based_fan_marker_layer, m_small_area_infill_flow_compensator, m_sub_layer_flow_ratio, m_sub_layer_height, m_writer, Slic3r::ExtrusionPath::mm3_per_mm, NOZZLE_CONFIG, object_layer_over_raft(), on_first_layer(), Slic3r::outer_wall_speed(), Slic3r::overhang_2_4_speed(), Slic3r::overhang_4_4_speed(), Slic3r::overhang_fan_active(), Slic3r::overhang_fan_overlap_threshold(), Slic3r::Overhang_threshold_none, Slic3r::ProcessedPoint::overlap, Slic3r::ProcessedPoint::p, Slic3r::GCodeProcessor::PA_Change, placeholder_parser_process(), point_to_gcode(), point_to_gcode_quantized(), Slic3r::MultiPoint3::points, Slic3r::ExtrusionPath::polyline, Slic3r::GCodeFormatter::quantize_xyz(), Slic3r::GCodeProcessor::reserved_tag(), Slic3r::GCodeProcessor::Role, Slic3r::ExtrusionPath::role(), Slic3r::ExtrusionEntity::role_to_string(), SCALING_FACTOR, set_last_pos(), Slic3r::ExtrusionPathSloped::slope_begin, Slic3r::slowdown_for_curled_perimeters(), Slic3r::sparse_infill_speed(), Slic3r::ProcessedPoint::speed, Slic3r::ArcSegment::start_point, Slic3r::support_material_interface_fan_speed(), Slic3r::Point3::to_point(), Slic3r::top_solid_infill_flow_ratio(), Slic3r::total_length(), travel_to(), Slic3r::GCodeWriter::travel_to_z(), unretract(), Slic3r::unscale(), unscale_, Slic3r::GCodeProcessor::Width, Slic3r::ExtrusionPath::width, writer(), Slic3r::ExtrusionPath::z_contoured, and Slic3r::ExtrusionPathSloped::Slope::z_ratio.

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

Here is the caller graph for this function:

_needSAFC()

bool Slic3r::GCode::_needSAFC ( const ExtrusionPath & path )

protectedinherited

{
    if (!m_small_area_infill_flow_compensator || !m_config.small_area_infill_flow_compensation.value)
        return false;
 
    static const InfillPattern supported_patterns[] = {
        InfillPattern::ipRectilinear,
        InfillPattern::ipAlignedRectilinear,
        InfillPattern::ipMonotonic,
        InfillPattern::ipMonotonicLine,
    };
 
    return std::any_of(std::begin(supported_patterns), std::end(supported_patterns), [&](const InfillPattern pattern) {
        return (this->on_first_layer() && this->config().bottom_surface_pattern == pattern) ||
               (path.role() == erSolidInfill && this->config().internal_solid_infill_pattern == pattern) ||
               (path.role() == erTopSolidInfill && this->config().top_surface_pattern == pattern);
    });
}

References config(), Slic3r::erSolidInfill, Slic3r::erTopSolidInfill, Slic3r::internal_solid_infill_pattern(), Slic3r::ipAlignedRectilinear, Slic3r::ipMonotonic, Slic3r::ipMonotonicLine, Slic3r::ipRectilinear, m_config, m_small_area_infill_flow_compensator, on_first_layer(), Slic3r::ExtrusionPath::role(), and Slic3r::top_surface_pattern().

Referenced by _extrude().

Here is the call graph for this function:

Here is the caller graph for this function:

_print_first_layer_bed_temperature()

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

protectedinherited

{
    // Initial bed temperature based on the first extruder.
    // BBS
    std::vector<int> temps_per_bed;
    int bed_temp = 0;
    if (m_config.bed_temperature_formula.value == BedTempFormula::btfHighestTemp) {
        bed_temp = get_highest_bed_temperature(true, print);
    }
    else {
        bed_temp = get_bed_temperature(first_printing_extruder_id, true, print.config().curr_bed_type);
    }
    // Is the bed temperature set by the provided custom G-code?
    int  temp_by_gcode     = -1;
    bool temp_set_by_gcode = custom_gcode_sets_temperature(gcode, 140, 190, false, temp_by_gcode);
    // BBS
#if 0
    if (temp_set_by_gcode && temp_by_gcode >= 0 && temp_by_gcode < 1000)
        temp = temp_by_gcode;
#endif
 
    // Always call m_writer.set_bed_temperature() so it will set the internal "current" state of the bed temp as if
    // the custom start G-code emited these.
    std::string set_temp_gcode = m_writer.set_bed_temperature(bed_temp, wait);
    if (! temp_set_by_gcode)
        file.write(set_temp_gcode);
}

References Slic3r::btfHighestTemp, Slic3r::Print::config(), Slic3r::custom_gcode_sets_temperature(), get_bed_temperature(), get_highest_bed_temperature(), m_config, m_writer, Print, and Slic3r::GCode::GCodeOutputStream::write().

Referenced by _do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

_print_first_layer_extruder_temperatures()

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

protectedinherited

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

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

Referenced by _do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

append_full_config()

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

staticinherited

{
    DynamicPrintConfig cfg = print.full_print_config();
    { // correct the flush_volumes_matrix with flush_multiplier values
        // Fast purge mode uses flush_multiplier_fast; Default is inert.
        std::vector<double> temp_cfg_flush_multiplier = (print.config().prime_volume_mode == PrimeVolumeMode::pvmFast)
                                                            ? cfg.option<ConfigOptionFloats>("flush_multiplier_fast")->values
                                                            : cfg.option<ConfigOptionFloats>("flush_multiplier")->values;
        std::vector<double> temp_flush_volumes_matrix = cfg.option<ConfigOptionFloats>("flush_volumes_matrix")->values;
        auto                temp_filament_color       = cfg.option<ConfigOptionStrings>("filament_colour")->values;
        size_t              heads_count_tmp           = temp_cfg_flush_multiplier.size(),
               matrix_value_count                     = temp_flush_volumes_matrix.size() / temp_cfg_flush_multiplier.size(),
               filament_count_tmp                     = temp_filament_color.size();
        if (filament_count_tmp * filament_count_tmp * heads_count_tmp == temp_flush_volumes_matrix.size()) {
            for (size_t idx = 0; idx < heads_count_tmp; ++idx) {
                double temp_cfg_flush_multiplier_idx = temp_cfg_flush_multiplier[idx];
                size_t temp_begin_t = idx * matrix_value_count, temp_end_t = (idx + 1) * matrix_value_count;
                std::transform(temp_flush_volumes_matrix.begin() + temp_begin_t, temp_flush_volumes_matrix.begin() + temp_end_t,
                               temp_flush_volumes_matrix.begin() + temp_begin_t,
                               [temp_cfg_flush_multiplier_idx](double inputx) { return std::round(inputx * temp_cfg_flush_multiplier_idx); });
            }
            cfg.option<ConfigOptionFloats>("flush_volumes_matrix")->values = temp_flush_volumes_matrix;
        } else if (filament_count_tmp == 1) {
        } // Not applicable to flush matrix situations
        else { // flush_volumes_matrix value count error?
            throw Slic3r::SlicingError(_(L("Flush volumes matrix do not match to the correct size!")));
        }
    }
    // filament_map_2 (the per-filament (extruder x volume-type) slot map) is computed during apply /
    // write-back and lives in the applied print config only; the pre-expansion snapshot this dump is
    // built from still carries the registered default. Copy the real values so the header line is
    // diagnostic (nothing parses it back).
    cfg.option<ConfigOptionInts>("filament_map_2", true)->values = print.config().filament_map_2.values;
    // Sorted list of config keys, which shall not be stored into the G-code. Initializer list.
    static const std::set<std::string_view> banned_keys( {
        // filament_extruder_compatibility is a device-side (blacklist) compatibility hint read from the
        // loaded presets, never consumed by slicing or firmware. Keep it out of the G-code config block so
        // the config key stays inert to g-code (byte-identical output).
        "filament_extruder_compatibility"sv,
        // The fast-purge / prime-volume-mode keys are new static-member registrations. Excluding them from
        // the config block keeps registration byte-identical for the shipping fleet (default
        // prime_volume_mode==Default leaves the slicing body unchanged; only the config-dump would otherwise
        // gain lines). They only affect output on the pvmFast / pvmSaving branch.
        "prime_volume_mode"sv,
        "flush_multiplier_fast"sv,
        "filament_flush_temp_fast"sv,
        "support_fast_purge_mode"sv,
        // deretract_speed_extruder_change is a device/firmware-facing machine-profile key with no slicer
        // consumer. Banning it from the g-code config dump keeps the H2D/A2L/X2D/P2S leaves that carry it
        // byte-identical, while still registering it as a known, validated config key.
        "deretract_speed_extruder_change"sv,
        // farthest_point_timelapse is a newly-registered printer key (corexy-only timelapse refinement).
        // Excluding it from the config block keeps the config-dump byte-identical for the whole shipping
        // fleet — otherwise every printer's dump would gain a `= 0` line vs the previous baseline, and
        // H2C/H2D would gain a non-timelapse `= 1` line. The key is read at slice time from m_config, so
        // banning it from the dump has no effect on the feature; the only H2C/H2D delta is the M9711/M971
        // snapshot reposition.
        "farthest_point_timelapse"sv,
        // The IMEX (IDEX/IQEX parallel printing) keys are newly-registered printer/process keys whose
        // defaults are non-nil, so leaving them in the dump would add fourteen `; imex_* = <default>`
        // lines to every printer's config block — an ordinary single-nozzle machine included. Excluding
        // them keeps the config-dump byte-identical for the whole shipping fleet; the IMEX printers pay
        // the same price the timelapse/prime-volume keys above already pay, and the active mode is still
        // visible in the body of their g-code through the injected imex_mode_gcodes macro. Every key is
        // read at slice time from m_config (get_imex_active_tools / find_imex_mode / the zone layout
        // helpers) and never parsed back out of the dump, so banning them costs the feature nothing:
        // the g-code viewer's overlay reads the loaded presets, not the config block, and the two
        // per-plate process keys round-trip through the 3MF's model_settings.config plate metadata
        // (bbs_3mf.cpp IMEX_PARALLEL_MODE_ATTR / IMEX_HEAD_FILAMENT_MAP_ATTR), not through this dump.
        "is_imex"sv,
        "imex_firmware_managed_zones"sv,
        "imex_gantry_count"sv,
        "imex_tools_per_gantry"sv,
        "imex_tool_layout"sv,
        "imex_nozzle_clearance_x"sv,
        "imex_nozzle_clearance_y"sv,
        "imex_carriage_margin"sv,
        "imex_viz_theme"sv,
        "imex_mode_names"sv,
        "imex_mode_active_tools"sv,
        "imex_mode_gcodes"sv,
        "imex_parallel_mode"sv,
        "imex_head_filament_map"sv,
        "compatible_printers"sv,
        "compatible_prints"sv,
        "filament_colour_type"sv,
        "print_host"sv,
        "print_host_webui"sv,
        "printhost_apikey"sv,
        "printhost_cafile"sv,
        "printhost_user"sv,
        "printhost_password"sv,
        "printhost_port"sv
    });
    auto is_banned = [](const std::string &key) {
        return banned_keys.find(key) != banned_keys.end();
    };
    std::ostringstream ss;
    for (const std::string& key : cfg.keys()) {
        if (!is_banned(key) && !cfg.option(key)->is_nil()) {
            if (key == "wipe_tower_x" || key == "wipe_tower_y") {
                ss << std::fixed << std::setprecision(3) << "; " << key << " = " << dynamic_cast<const ConfigOptionFloats*>(cfg.option(key))->get_at(print.get_plate_index()) << "\n";
            }
            if(key == "extruder_colour")
                ss << "; " << key << " = " << cfg.opt_serialize("filament_colour") << "\n";
            else
                ss << "; " << key << " = " << cfg.opt_serialize(key) << "\n";
        }
    }
    str += ss.str();
}

References _, Slic3r::Print::config(), Slic3r::PrintBase::full_print_config(), Slic3r::PrintBase::get_plate_index(), Slic3r::ConfigOption::is_nil(), Slic3r::DynamicConfig::keys(), L, Slic3r::ConfigBase::opt_serialize(), Slic3r::ConfigBase::option(), Print, Slic3r::pvmFast, and Slic3r::ConfigOptionVector< double >::size().

Referenced by _do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_print_config()

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

inherited

{
    m_writer.apply_print_config(print_config);
    m_config.apply(print_config);
    m_scaled_resolution = scaled<double>(print_config.resolution.value);
    m_enable_exclude_object = m_config.exclude_object;
 
#if ORCA_CHECK_GCODE_PLACEHOLDERS
    // If the gcode value is empty, set a value so that the check code within the parser is run
    for (auto opt : std::initializer_list<ConfigOptionString*>{
             &m_config.machine_start_gcode,
             &m_config.machine_end_gcode,
             &m_config.before_layer_change_gcode,
             &m_config.layer_change_gcode,
             &m_config.time_lapse_gcode,
             &m_config.change_filament_gcode,
             &m_config.change_extrusion_role_gcode,
             &m_config.process_change_extrusion_role_gcode,
             &m_config.printing_by_object_gcode,
             &m_config.machine_pause_gcode,
             &m_config.template_custom_gcode,
         }) {
        if (opt->empty())
            opt->set(new ConfigOptionString(";VALUE FOR TESTING"));
    }
    for (auto opt : std::initializer_list<ConfigOptionStrings*>{
             &m_config.filament_start_gcode,
             &m_config.filament_end_gcode,
             &m_config.filament_change_extrusion_role_gcode
         }) {
        if (opt->empty())
            for (int i = 0; i < opt->size(); ++i)
                opt->set_at(new ConfigOptionString(";VALUE FOR TESTING"), i, 0);
    }
#endif
}

References Slic3r::ConfigOptionString, m_config, m_enable_exclude_object, m_scaled_resolution, m_writer, and Slic3r::scaled().

Referenced by _do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

assign_object_label_ids()

void Slic3r::GCode::assign_object_label_ids ( Print & print )

inherited

{
    m_instance_names.clear();
    size_t object_id = 0;
    size_t unique_id = 0;
    for (PrintObject *object : print.objects()) {
        object->set_id(object_id++);
        size_t inst_id = 0;
        for (PrintInstance &inst : object->instances()) {
            inst.id        = inst_id++;
            inst.unique_id = unique_id++;
        }
    }
}

References m_instance_names, Slic3r::Print::objects(), and Print.

Referenced by _do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

belt_height_above_floor()

bool Slic3r::GCode::belt_height_above_floor ( const Vec3d & point_slicing_mm, double & height_mm ) const

protectedinherited

{
    // The owning object, which is what carries the belt description.  During
    // object-brim and coincident-apron emission m_layer still points at whichever
    // object was visited last (or at nothing at all), so those paths publish the
    // owner explicitly -- otherwise a brim's speed would depend on plate order.
    const PrintObject *object = m_belt_floor_object != nullptr ? m_belt_floor_object
                              : (m_layer != nullptr ? m_layer->object() : nullptr);
    if (object == nullptr)
        return false;
    const SlicingParameters &sp = object->slicing_parameters();
    // Deliberately NOT BeltFloorContext: its init() folds in
    // belt_support_floor_offset, a support-generator diagnostic. Letting that
    // option move the model's first-layer speed band would be a surprising
    // coupling -- a negative value would switch the slowdown off entirely.
    // The belt surface itself is just shear * u + z_shift.
    if (std::abs(sp.belt_floor_shear_factor) < EPSILON)
        return false;
    const double u = sp.belt_floor_from_axis == 0 ? point_slicing_mm.x() : point_slicing_mm.y();
    const double floor_z = sp.belt_floor_shear_factor * u + sp.belt_floor_z_shift;
    // Measured along the slicing Z, not perpendicular to the belt: layers are
    // horizontal slabs in the sliced frame, so the slab holding the material that
    // rests on the belt at this point is the one within one layer height of it.
    // A perpendicular measure would shrink the band by 1/cos(tilt).
    height_mm = point_slicing_mm.z() - floor_z;
    return true;
}

References Slic3r::SlicingParameters::belt_floor_from_axis, Slic3r::SlicingParameters::belt_floor_shear_factor, Slic3r::SlicingParameters::belt_floor_z_shift, EPSILON, m_belt_floor_object, and m_layer.

Referenced by belt_layer_past_first_layer_band(), effective_layer_index_for_point(), and on_first_layer().

Here is the caller graph for this function:

belt_layer_past_first_layer_band()

int Slic3r::GCode::belt_layer_past_first_layer_band ( const Layer * object_layer ) const

protectedinherited

{
    if (object_layer == nullptr)
        return -1;
    // The belt surface is linear in the sliced XY, so a bbox's lowest point above
    // it is at one of its corners.
    double min_height = std::numeric_limits<double>::max();
    bool   known      = false;
    for (const BoundingBox &bb : object_layer->lslices_bboxes) {
        const double xs[2] = { unscale<double>(bb.min.x()), unscale<double>(bb.max.x()) };
        const double ys[2] = { unscale<double>(bb.min.y()), unscale<double>(bb.max.y()) };
        for (double x : xs)
            for (double y : ys) {
                double h;
                if (! this->belt_height_above_floor(Vec3d(x, y, object_layer->print_z), h))
                    return -1;
                known      = true;
                min_height = std::min(min_height, h);
            }
    }
    if (! known)
        return -1;
    return min_height >= this->first_layer_band_mm() - EPSILON ? 1 : 0;
}

References belt_height_above_floor(), EPSILON, first_layer_band_mm(), Slic3r::Layer::lslices_bboxes, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::Layer::print_z, and Slic3r::unscale().

Referenced by process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_max_volumetric_speed()

double Slic3r::GCode::calc_max_volumetric_speed ( const double layer_height, const double line_width, const std::string co_str )

protectedinherited

{
    std::vector<double> cs;
    std::stringstream   ss(co_str);
    std::string         token;
 
    while (std::getline(ss, token, ' ')) {
        try {
            cs.push_back(std::stod(token));
        } catch (...) {
            std::cerr << "Transformation failed: " << token << std::endl;
        }
    }
    if (cs.size() != 6 || std::all_of(cs.begin(), cs.end(), [](double v) { return v == 0; })) return std::numeric_limits<double>::max();
 
    const double x = layer_height;
    const double y = line_width;
 
    double res = cs[0] * x * x + cs[1] * y * y + cs[2] * x * y + cs[3] * x + cs[4] * y + cs[5];
    return res;
}

References Slic3r::layer_height().

Referenced by _extrude().

Here is the call graph for this function:

Here is the caller graph for this function:

capture_toolchange_position()

std::optional< GCode::ToolchangePositionState > Slic3r::GCode::capture_toolchange_position ( )

protectedinherited

{
    if (m_exclusion_volume_travel_avoidance.empty() || !m_last_pos_defined || m_writer.filament() == nullptr)
        return std::nullopt;
 
    const Vec2d plate_offset = m_writer.get_xy_offset().cast<double>();
    return ToolchangePositionState{
        this->point_to_gcode(m_last_pos.to_point()) - plate_offset
    };
}

References m_exclusion_volume_travel_avoidance, m_last_pos, m_last_pos_defined, m_writer, and point_to_gcode().

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

Here is the call graph for this function:

Here is the caller graph for this function:

change_layer()

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

protectedinherited

{
    std::string gcode;
    if (m_layer_count > 0)
        // Increment a progress bar indicator.
        gcode += m_writer.update_progress(++ m_layer_index, m_layer_count);
    //BBS
    coordf_t z = print_z + m_config.z_offset.value;  // in unscaled coordinates
    if (FILAMENT_CONFIG(retract_when_changing_layer) && m_writer.will_move_z(z)) {
        LiftType lift_type = this->to_lift_type(ZHopType(FILAMENT_CONFIG(z_hop_types)));
        //BBS: force to use SpiralLift when change layer if lift type is auto
        gcode += this->retract(false, false, ZHopType(FILAMENT_CONFIG(z_hop_types)) == ZHopType::zhtAuto ? LiftType::SpiralLift : lift_type);
    }
 
    m_writer.add_object_change_labels(gcode);
 
    if (m_spiral_vase) {
        //BBS: force to normal lift immediately in spiral vase mode
        std::ostringstream comment;
        comment << "move to next layer (" << m_layer_index << ")";
        gcode += m_writer.travel_to_z(z, comment.str());
    }
 
    m_need_change_layer_lift_z = true;
 
    m_nominal_z = z;
    m_writer.get_position().z() = z;
 
    // forget last wiping path as wiping after raising Z is pointless
    // BBS. Dont forget wiping path to reduce stringing.
    //m_wipe.reset_path();
 
    return gcode;
}

References FILAMENT_CONFIG, m_config, m_layer_count, m_layer_index, m_need_change_layer_lift_z, m_nominal_z, m_spiral_vase, m_writer, retract(), Slic3r::retract_when_changing_layer(), Slic3r::SpiralLift, to_lift_type(), and Slic3r::zhtAuto.

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

Here is the call graph for this function:

Here is the caller graph for this function:

check_placeholder_parser_failed()

void Slic3r::GCode::check_placeholder_parser_failed ( )

protectedinherited

{
    if (! m_placeholder_parser_integration.failed_templates.empty()) {
        // G-code export proceeded, but some of the PlaceholderParser substitutions failed.
        std::string msg = Slic3r::format(_(L("Failed to generate G-code for invalid custom G-code.\n\n")));
        for (const auto &name_and_error : m_placeholder_parser_integration.failed_templates)
            msg += name_and_error.first + " " + name_and_error.second + "\n";
        msg += Slic3r::format(_(L("Please check the custom G-code or use the default custom G-code.")));
        throw Slic3r::PlaceholderParserError(msg);
    }
}

References _, Slic3r::format(), L, and m_placeholder_parser_integration.

Referenced by do_export(), and process_layers().

Here is the call graph for this function:

Here is the caller graph for this function:

collect_layers_to_print() [1/2]

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

staticprotectedinherited

{
    struct OrderingItem {
        coordf_t    print_z;
        size_t      object_idx;
        size_t      layer_idx;
    };
 
    std::vector<std::vector<LayerToPrint>>  per_object(print.objects().size(), std::vector<LayerToPrint>());
    std::vector<OrderingItem>               ordering;
 
    std::vector<Slic3r::SlicingError> errors;
 
    for (size_t i = 0; i < print.objects().size(); ++i) {
        try {
            per_object[i] = collect_layers_to_print(*print.objects()[i], print.config().belt_printer.value);
        } catch (const Slic3r::SlicingError &e) {
            errors.push_back(e);
            continue;
        }
        // On a belt an object may be left without a layer to print at all.
        if (per_object[i].empty())
            continue;
        OrderingItem ordering_item;
        ordering_item.object_idx = i;
        ordering.reserve(ordering.size() + per_object[i].size());
        const LayerToPrint& front = per_object[i].front();
        for (const LayerToPrint& ltp : per_object[i]) {
            ordering_item.print_z = ltp.print_z();
            ordering_item.layer_idx = &ltp - &front;
            ordering.emplace_back(ordering_item);
        }
    }
 
    if (!errors.empty()) { throw Slic3r::SlicingErrors(errors); }
 
    std::sort(ordering.begin(), ordering.end(), [](const OrderingItem& oi1, const OrderingItem& oi2) { return oi1.print_z < oi2.print_z; });
 
    std::vector<std::pair<coordf_t, std::vector<LayerToPrint>>> layers_to_print;
 
    // Merge numerically very close Z values.
    for (size_t i = 0; i < ordering.size();) {
        // Find the last layer with roughly the same print_z.
        size_t j = i + 1;
        coordf_t zmax = ordering[i].print_z + EPSILON;
        for (; j < ordering.size() && ordering[j].print_z <= zmax; ++j);
        // Merge into layers_to_print.
        std::pair<coordf_t, std::vector<LayerToPrint>> merged;
        // Assign an average print_z to the set of layers with nearly equal print_z.
        merged.first = 0.5 * (ordering[i].print_z + ordering[j - 1].print_z);
        merged.second.assign(print.objects().size(), LayerToPrint());
        for (; i < j; ++i) {
            const OrderingItem& oi = ordering[i];
            assert(merged.second[oi.object_idx].layer() == nullptr);
            merged.second[oi.object_idx] = std::move(per_object[oi.object_idx][oi.layer_idx]);
        }
        layers_to_print.emplace_back(std::move(merged));
    }
 
    return layers_to_print;
}

References collect_layers_to_print(), Slic3r::Print::config(), Slic3r::empty(), EPSILON, Slic3r::Print::objects(), Print, and Slic3r::ConstVectorOfPtrsAdaptor< T >::size().

Here is the call graph for this function:

collect_layers_to_print() [2/2]

std::vector< GCode::LayerToPrint > Slic3r::GCode::collect_layers_to_print ( const PrintObject & object, bool skip_empty_first_layer = false )

staticprotectedinherited

{
    std::vector<GCode::LayerToPrint> layers_to_print;
    layers_to_print.reserve(object.layers().size() + object.support_layers().size());
 
    /*
    // Calculate a minimum support layer height as a minimum over all extruders, but not smaller than 10um.
    // This is the same logic as in support generator.
    //FIXME should we use the printing extruders instead?
    double gap_over_supports = object.config().support_top_z_distance;
    // FIXME should we test object.config().support_material_synchronize_layers ? Currently the support layers are synchronized with object layers iff soluble supports.
    assert(!object.has_support() || gap_over_supports != 0. || object.config().support_material_synchronize_layers);
    if (gap_over_supports != 0.) {
        gap_over_supports = std::max(0., gap_over_supports);
        // Not a soluble support,
        double support_layer_height_min = 1000000.;
        for (auto lh : object.print()->config().min_layer_height.values)
            support_layer_height_min = std::min(support_layer_height_min, std::max(0.01, lh));
        gap_over_supports += support_layer_height_min;
    }*/
 
    std::vector<std::pair<double, double>> warning_ranges;
 
    // Pair the object layers with the support layers by z.
    //
    // Belt printers add a third stream: brim apron bands, which sit on the belt AHEAD of
    // the part and so print below the object's first layer.  They are merged here rather
    // than pushed as standalone records, because a band's print_z can coincide with a
    // support layer of this same object - and the print-wide merge downstream keeps only
    // one record per object per z, so a standalone band would be silently overwritten.
    size_t idx_object_layer = 0;
    size_t idx_support_layer = 0;
    size_t idx_brim_band = 0;
    const auto &brim_bands = object.belt_brim_prologue();   // ordered by ascending print_z
    const LayerToPrint* last_extrusion_layer = nullptr;
    while (idx_object_layer < object.layers().size() || idx_support_layer < object.support_layers().size()
        || idx_brim_band < brim_bands.size()) {
        LayerToPrint layer_to_print;
        double print_z_min = std::numeric_limits<double>::max();
        if (idx_object_layer < object.layers().size()) {
            layer_to_print.object_layer = object.layers()[idx_object_layer++];
            print_z_min = std::min(print_z_min, layer_to_print.object_layer->print_z);
        }
 
        if (idx_support_layer < object.support_layers().size()) {
            layer_to_print.support_layer = object.support_layers()[idx_support_layer++];
            print_z_min = std::min(print_z_min, layer_to_print.support_layer->print_z);
        }
 
        if (idx_brim_band < brim_bands.size()) {
            layer_to_print.belt_brim_band = &brim_bands[idx_brim_band++];
            print_z_min = std::min(print_z_min, layer_to_print.belt_brim_band->print_z);
        }
 
        if (layer_to_print.object_layer && layer_to_print.object_layer->print_z > print_z_min + EPSILON) {
            layer_to_print.object_layer = nullptr;
            --idx_object_layer;
        }
 
        if (layer_to_print.support_layer && layer_to_print.support_layer->print_z > print_z_min + EPSILON) {
            layer_to_print.support_layer = nullptr;
            --idx_support_layer;
        }
 
        if (layer_to_print.belt_brim_band && layer_to_print.belt_brim_band->print_z > print_z_min + EPSILON) {
            layer_to_print.belt_brim_band = nullptr;
            --idx_brim_band;
        }
 
        layer_to_print.original_object = &object;
        layers_to_print.push_back(layer_to_print);
 
        bool has_extrusions = (layer_to_print.object_layer && layer_to_print.object_layer->has_extrusions())
            || (layer_to_print.support_layer && layer_to_print.support_layer->has_extrusions())
            || (layer_to_print.belt_brim_band && ! layer_to_print.belt_brim_band->fills.empty());
 
        // Check that there are extrusions on the very first layer. The case with empty
        // first layer may result in skirt/brim in the air and maybe other issues.
        // Skip this check for belt printers.  The shear transform tilts the
        // model so the first horizontal layer plane intersects only a thin
        // sliver of the model (width ≈ first_layer_height / shear_factor).
        // This sliver is often narrower than the nozzle diameter, producing
        // zero perimeters and an empty first layer — which is expected, not
        // an error.  In global shear mode the object may also start above
        // Z=0 on the tilted belt surface.
        if (layers_to_print.size() == 1u) {
            if (!has_extrusions && !skip_empty_first_layer)
                throw Slic3r::SlicingError(_(L("One object has an empty first layer and can't be printed. Please Cut the bottom or enable supports.")), object.id().id);
        }
 
        // In case there are extrusions on this layer, check there is a layer to lay it on.
        if ((layer_to_print.object_layer && layer_to_print.object_layer->has_extrusions())
            // Allow empty support layers, as the support generator may produce no extrusions for non-empty support regions.
            || (layer_to_print.support_layer /* && layer_to_print.support_layer->has_extrusions() */)) {
            double top_cd = object.config().support_top_z_distance;
            double bottom_cd = object.config().support_bottom_z_distance == 0. ? top_cd : object.config().support_bottom_z_distance;
            //if (!object.print()->config().independent_support_layer_height)
            { // the actual support gap may be larger than the configured one due to rounding to layer height for organic support, regardless of independent support layer height
                top_cd    = std::ceil(top_cd / object.config().layer_height) * object.config().layer_height;
                bottom_cd = std::ceil(bottom_cd / object.config().layer_height) * object.config().layer_height;
            }
            double extra_gap = (layer_to_print.support_layer ? bottom_cd : top_cd);
 
            // raft contact distance should not trigger any warning
            if (last_extrusion_layer && last_extrusion_layer->support_layer) {
                double raft_gap = object.config().raft_contact_distance.value;
                //if (!object.print()->config().independent_support_layer_height)
                {
                    raft_gap = std::ceil(raft_gap / object.config().layer_height) * object.config().layer_height;
                }
                extra_gap = std::max(extra_gap, object.config().raft_contact_distance.value);
            }
            double maximal_print_z = (last_extrusion_layer ? last_extrusion_layer->print_z() : 0.)
                + layer_to_print.layer()->height
                + std::max(0., extra_gap);
            // Negative support_contact_z is not taken into account, it can result in false positives in cases
 
            if (has_extrusions && layer_to_print.print_z() > maximal_print_z + 2. * EPSILON) {
                // Belt printers: a *leading* empty range (no prior extrusion layer, so the
                // gap starts at Z=0) is not a floating object — it is just the belt lead-in.
                // The part rests on the conveyor as it advances, so the first material can
                // legitimately appear well above Z=0. This empty-layer check assumes a fixed
                // bed, where material with nothing below it is unprintable; that assumption
                // does not hold on a belt for the lead-in. Suppress only this leading case,
                // and keep flagging genuine *internal* gaps (which on a belt may still be an
                // over-angle overhang that would print into air).
                const bool belt_leading_gap = object.print()->config().belt_printer.value
                                           && last_extrusion_layer == nullptr;
                if (!belt_leading_gap)
                    warning_ranges.emplace_back(std::make_pair((last_extrusion_layer ? last_extrusion_layer->print_z() : 0.), layers_to_print.back().print_z()));
            }
        }
        // Remember last layer with extrusions.
        if (has_extrusions)
            last_extrusion_layer = &layers_to_print.back();
    }
 
    // ORCA-Belt: objects print at their position along the belt, so the first
    // extrusions legitimately start far above Z=0. Drop the spurious
    // "empty layers from the bed" range while keeping genuine mid-print gaps.
    if (skip_empty_first_layer && !warning_ranges.empty() && warning_ranges.front().first == 0.)
        warning_ranges.erase(warning_ranges.begin());
 
    if (! warning_ranges.empty()) {
        std::string warning;
        size_t i = 0;
        for (i = 0; i < std::min(warning_ranges.size(), size_t(5)); ++i)
            warning += Slic3r::format(_(L("The object has empty layers between %1% and %2% and can\u2019t be printed.")),
                                      warning_ranges[i].first, warning_ranges[i].second) + "\n";
        warning += Slic3r::format(_(L("Object: %1%")), object.model_object()->name) + "\n"
            + _(L("Parts of the object at these heights may be too thin or the object may have a faulty mesh."));
 
        const_cast<Print*>(object.print())->active_step_add_warning(
            PrintStateBase::WarningLevel::CRITICAL, warning, PrintStateBase::SlicingEmptyGcodeLayers);
    }
 
    // Belt printers: drop the layers that print nothing at all.  An object's slicing
    // frame starts at the belt below its leading end, so its first layers are empty,
    // and with several objects along the belt those empty layers fall between other
    // objects' printing layers.  A layer change with no moves is noise in the file, and
    // the preview (libvgcode) numbers its layers from the moves it sees, so a gap folds
    // every later layer into the one before it.  Both print sequences collect their
    // layers here, so neither writes such a layer.
    if (object.print()->config().belt_printer.value)
        layers_to_print.erase(
            std::remove_if(layers_to_print.begin(), layers_to_print.end(), [&object](const LayerToPrint &ltp) {
                return ! ((ltp.object_layer != nullptr && belt_object_layer_prints_something(object, *ltp.object_layer)) ||
                          (ltp.support_layer != nullptr && ltp.support_layer->has_extrusions()) ||
                          (ltp.belt_brim_band != nullptr && ! ltp.belt_brim_band->fills.empty()));
            }),
            layers_to_print.end());
 
    return layers_to_print;
}

References _, Slic3r::GCode::LayerToPrint::belt_brim_band, Slic3r::belt_printer(), config(), Slic3r::PrintStateBase::CRITICAL, Slic3r::ExtrusionEntityCollection::empty(), EPSILON, Slic3r::BeltBrimBand::fills, Slic3r::format(), Slic3r::Layer::has_extrusions(), Slic3r::SupportLayer::has_extrusions(), Slic3r::Layer::height, L, Slic3r::GCode::LayerToPrint::layer(), Slic3r::layer_height(), Slic3r::GCode::LayerToPrint::object_layer, Slic3r::GCode::LayerToPrint::original_object, Print, Slic3r::BeltBrimBand::print_z, Slic3r::GCode::LayerToPrint::print_z(), Slic3r::Layer::print_z, Slic3r::PrintStateBase::SlicingEmptyGcodeLayers, and Slic3r::GCode::LayerToPrint::support_layer.

Referenced by _do_export(), and collect_layers_to_print().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_farthest_point()

void Slic3r::GCode::compute_farthest_point ( const std::vector< LayerToPrint > & layers, int most_used_extruder, const std::map< std::pair< const SupportLayer *, ExtrusionRole >, unsigned int > & support_filaments )

protectedinherited

{
    m_farthest_point_timelapse.farthest_point = Point(0, 0);
    m_farthest_point_timelapse.farthest_gcode_pos = Vec2d(0, 0);
    m_farthest_point_timelapse.farthest_extruder_id = 0;
    m_farthest_point_timelapse.farthest_is_photo_head = false;
 
    // Track farthest point for external perimeters and fallback (infill/support) separately
    int64_t max_dist_sq_ext = -1;
    Point   farthest_point_ext;
    int     farthest_extruder_ext = 0;
 
    int64_t max_dist_sq_fallback = -1;
    Point   farthest_point_fallback;
    int     farthest_extruder_fallback = 0;
 
    // Recursive visitor: call fn(const ExtrusionPath&) for every leaf path
    auto for_each_path = [](const ExtrusionEntity *entity, const auto &fn, const auto &self) -> void {
        if (entity->is_collection()) {
            for (const auto *child : static_cast<const ExtrusionEntityCollection *>(entity)->entities)
                self(child, fn, self);
        } else if (entity->is_loop()) {
            for (const ExtrusionPath &p : static_cast<const ExtrusionLoop *>(entity)->paths)
                fn(p);
        } else if (const auto *mp = dynamic_cast<const ExtrusionMultiPath *>(entity)) {
            for (const ExtrusionPath &p : mp->paths)
                fn(p);
        } else {
            fn(static_cast<const ExtrusionPath &>(*entity));
        }
    };
 
    auto is_ext_perimeter_role = [](ExtrusionRole role) -> bool {
        return role == erExternalPerimeter;
    };
    auto is_fallback_role = [](ExtrusionRole role) -> bool {
        return role == erInternalInfill || role == erSolidInfill || role == erTopSolidInfill;
    };
    auto is_candidate_support_role = [](ExtrusionRole role) -> bool {
        return role == erSupportMaterial || role == erSupportMaterialInterface || role == erSupportTransition;
    };
 
    // Update a (max_dist_sq, point, extruder_id) triple
    auto update_max = [](int64_t &max_dsq, Point &out_point, int &out_ext,
                         const Point &p, const Point &shift, int extruder_id) {
        Point global = p + shift;
        int64_t dsq = (int64_t)global.x() * global.x() + (int64_t)global.y() * global.y();
        if (dsq > max_dsq) {
            max_dsq = dsq;
            out_point = global;
            out_ext = extruder_id;
        }
    };
 
    // Collect candidate endpoints from one ExtrusionPath, handling arc fitting.
    // Orca: ExtrusionPath::polyline is a Polyline3 (Point3 points) rather than a 2D Polyline, so each
    // stored point is projected to 2D via to_point() before the distance test (Z is irrelevant here).
    auto collect_from_path = [&update_max](int64_t &max_dsq, Point &out_point, int &out_ext,
                                           const ExtrusionPath &path, const Point &shift, int extruder_id) {
        const Polyline3 &poly = path.polyline;
        if (poly.points.empty()) return;
 
        if (!poly.fitting_result.empty()) {
            if (poly.fitting_result.front().start_point_index < poly.points.size())
                update_max(max_dsq, out_point, out_ext,
                           poly.points[poly.fitting_result.front().start_point_index].to_point(), shift, extruder_id);
 
            for (const PathFittingData &seg : poly.fitting_result) {
                if (seg.path_type == EMovePathType::Linear_move) {
                    for (size_t i = seg.start_point_index; i <= seg.end_point_index && i < poly.points.size(); ++i)
                        update_max(max_dsq, out_point, out_ext, poly.points[i].to_point(), shift, extruder_id);
                } else if (seg.path_type == EMovePathType::Arc_move_cw || seg.path_type == EMovePathType::Arc_move_ccw) {
                    update_max(max_dsq, out_point, out_ext, seg.arc_data.end_point, shift, extruder_id);
                }
            }
        } else {
            for (const Point3 &pt : poly.points)
                update_max(max_dsq, out_point, out_ext, pt.to_point(), shift, extruder_id);
        }
    };
 
    // Single pass: scan all paths, collecting ext-perimeter and fallback candidates.
    // Use original_object (not ltp.object()) to get instance shifts, because
    // ltp.object() may return a shared/merged PrintObject whose instances() only
    // reflects one copy's shift. original_object preserves the per-ModelObject
    // PrintObject with correct instance positions.
    for (const LayerToPrint &ltp : layers) {
        const PrintObject *print_obj = ltp.original_object;
        if (!print_obj) continue;
 
        for (const PrintInstance &inst : print_obj->instances()) {
            const Point &shift = inst.shift;
 
            if (ltp.object_layer) {
                for (const LayerRegion *region : ltp.object_layer->regions()) {
                    const PrintRegionConfig &rcfg = region->region().config();
 
                    for (const ExtrusionEntity *entity : region->perimeters.entities) {
                        for_each_path(entity, [&](const ExtrusionPath &path) {
                            if (is_ext_perimeter_role(path.role()))
                                collect_from_path(max_dist_sq_ext, farthest_point_ext, farthest_extruder_ext,
                                                  path, shift, (int)get_extruder_id(rcfg.outer_wall_filament_id.value - 1));
                        }, for_each_path);
                    }
 
                    for (const ExtrusionEntity *entity : region->fills.entities) {
                        for_each_path(entity, [&](const ExtrusionPath &path) {
                            if (!is_fallback_role(path.role())) return;
                            int eid = (path.role() == erInternalInfill)
                                ? (int)get_extruder_id(rcfg.sparse_infill_filament_id.value - 1)
                                : (int)get_extruder_id(rcfg.internal_solid_filament_id.value - 1);
                            collect_from_path(max_dist_sq_fallback, farthest_point_fallback, farthest_extruder_fallback,
                                              path, shift, eid);
                        }, for_each_path);
                    }
                }
            }
 
            if (ltp.support_layer) {
                for (const ExtrusionEntity *entity : ltp.support_layer->support_fills.entities) {
                    for_each_path(entity, [&](const ExtrusionPath &path) {
                        if (!is_candidate_support_role(path.role())) return;
                        auto support_filament = support_filaments.find({ ltp.support_layer, path.role() });
                        if (support_filament == support_filaments.end()) return;
                        int eid = (int)get_extruder_id(support_filament->second);
                        collect_from_path(max_dist_sq_fallback, farthest_point_fallback, farthest_extruder_fallback,
                                          path, shift, eid);
                    }, for_each_path);
                }
            }
        }
    }
 
    // Prefer external perimeter result; fall back to infill/support
    int64_t max_dist_sq;
    if (max_dist_sq_ext > 0) {
        max_dist_sq = max_dist_sq_ext;
        m_farthest_point_timelapse.farthest_point = farthest_point_ext;
        m_farthest_point_timelapse.farthest_extruder_id = farthest_extruder_ext;
    } else {
        max_dist_sq = max_dist_sq_fallback;
        m_farthest_point_timelapse.farthest_point = farthest_point_fallback;
        m_farthest_point_timelapse.farthest_extruder_id = farthest_extruder_fallback;
    }
 
    if (max_dist_sq > 0) {
        m_farthest_point_timelapse.farthest_gcode_pos = unscale(m_farthest_point_timelapse.farthest_point);
        // Single nozzle with AMS: all virtual extruders share one physical nozzle,
        // so the nozzle is always the photo head regardless of which filament is used.
        bool single_nozzle = (m_config.nozzle_diameter.size() <= 1);
        m_farthest_point_timelapse.farthest_is_photo_head = single_nozzle || (m_farthest_point_timelapse.farthest_extruder_id == most_used_extruder);
    }
}

References Slic3r::PathFittingData::arc_data, Slic3r::Arc_move_ccw, Slic3r::Arc_move_cw, Slic3r::PrintRegion::config(), Slic3r::ArcSegment::end_point, Slic3r::PathFittingData::end_point_index, Slic3r::erExternalPerimeter, Slic3r::erInternalInfill, Slic3r::erSolidInfill, Slic3r::erSupportMaterial, Slic3r::erSupportMaterialInterface, Slic3r::erSupportTransition, Slic3r::erTopSolidInfill, get_extruder_id(), Slic3r::PrintObject::instances(), Slic3r::ExtrusionEntity::is_collection(), Slic3r::ExtrusionEntity::is_loop(), Slic3r::Linear_move, m_config, m_farthest_point_timelapse, Slic3r::PathFittingData::path_type, Slic3r::PrintRegionConfig, Slic3r::ExtrusionPath::role(), Slic3r::PathFittingData::start_point_index, Slic3r::Point3::to_point(), and Slic3r::unscale().

Referenced by process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

config()

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

inlineinherited

{ return m_config; }

References m_config.

Referenced by Slic3r::CalibPressureAdvanceLine::CalibPressureAdvanceLine(), _do_export(), _extrude(), Slic3r::OozePrevention::_get_temp(), _needSAFC(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), Slic3r::Wipe::calculateWipeRetractionLengths(), collect_layers_to_print(), emit_belt_brim_bands(), extrude_path(), generate_object_brim(), generate_object_skirt_group(), generate_timelapse_gcode(), Slic3r::need_wipe(), Slic3r::overhang_fan_enabled(), Slic3r::OozePrevention::post_toolchange(), Slic3r::OozePrevention::pre_toolchange(), process_belt_brim_layer(), process_layer(), process_layer_change_gcode(), retract(), set_extruder(), timelapse_gcode_config(), Slic3r::AvoidCrossingPerimeters::travel_to(), and Slic3r::Wipe::wipe().

Here is the caller graph for this function:

cur_extruder_index()

size_t Slic3r::GCode::cur_extruder_index ( ) const

protectedinherited

{
    //TODO: check if the function is duplicated
    //just return m_writer.filament()->extruder_id()
    return get_extruder_id(m_writer.filament()->id());
}

References get_extruder_id(), and m_writer.

Here is the call graph for this function:

do_export()

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

inherited

{
    PROFILE_CLEAR();
 
    // BBS
    m_curr_print = print;
    m_skirt_group_done.clear();
    m_pending_start_gcode_position.reset();
    m_exclusion_volume_travel_avoidance.init(print->config(), print->get_plate_origin());
 
    GCodeWriter::full_gcode_comment = print->config().gcode_comments;
    CNumericLocalesSetter locales_setter;
 
    // Does the file exist? If so, we hope that it is still valid.
    if (print->is_step_done(psGCodeExport) && boost::filesystem::exists(boost::filesystem::path(path)))
        return;
 
    BOOST_LOG_TRIVIAL(info) << boost::format("Will export G-code to %1% soon")%path;
 
    GCodeProcessor::s_IsBBLPrinter = print->is_BBL_printer();
    m_writer.set_is_bbl_machine(print->is_BBL_printer());
    print->set_started(psGCodeExport);
 
    {
        LifecycleEventContext ctx;
        ctx.id = std::to_string(print->model().id().id);
        ctx.name = print->get_model_name();
        ctx.code = LifecycleEvtCode::Ok;
        ctx.msg  = path;
        ctx.cancellation_check = [print]() { return print->canceled(); };
        fire_lifecycle_event(LifecycleEvent::GCodeExportStarted, ctx);
    }
 
    // check if any custom gcode contains keywords used by the gcode processor to
    // produce time estimation and gcode toolpaths
    std::vector<std::pair<std::string, std::string>> validation_res = DoExport::validate_custom_gcode(*print);
    if (!validation_res.empty()) {
        std::string reports;
        for (const auto& [source, keyword] : validation_res) {
            reports += source + ": \"" + keyword + "\"\n";
        }
        //print->active_step_add_warning(PrintStateBase::WarningLevel::NON_CRITICAL,
        //    _(L("In the custom G-code were found reserved keywords:")) + "\n" +
        //    reports +
        //    _(L("This may cause problems in g-code visualization and printing time estimation.")));
        std::string temp = "Dangerous keywords in custom Gcode: " + reports + "\nThis may cause problems in g-code visualization and printing time estimation.";
        BOOST_LOG_TRIVIAL(warning) << temp;
    }
 
    BOOST_LOG_TRIVIAL(info) << "Exporting G-code..." << log_memory_info();
 
    // Remove the old g-code if it exists.
    boost::nowide::remove(path);
 
    fs::path file_path(path);
    fs::path folder = file_path.parent_path();
    if (!fs::exists(folder)) {
        fs::create_directory(folder);
        BOOST_LOG_TRIVIAL(error) << "[WARNING]: the parent path " + folder.string() +" is not there, create it!" << std::endl;
    }
 
    std::string path_tmp(path);
    path_tmp += ".tmp";
 
    m_processor.initialize(path_tmp);
    m_processor.set_print(print);
    GCodeOutputStream file(boost::nowide::fopen(path_tmp.c_str(), "wb"), m_processor);
    if (! file.is_open()) {
        // TRN %1% is a file path.
        std::string err_msg = Slic3r::format(_(L("G-code export to %1% failed.\nCannot open the file for writing.")), path) + "\n";
        BOOST_LOG_TRIVIAL(error) << err_msg << std::endl;
        if (!fs::exists(folder)) {
            //fs::create_directory(folder);
            // TRN %1% is a folder path.
            std::string add_err_msg = Slic3r::format(_(L("The folder %1% does not exist.")), folder.string());
            BOOST_LOG_TRIVIAL(error) << add_err_msg << std::endl;
            err_msg += add_err_msg;
        }
        {
            LifecycleEventContext ctx;
            ctx.id = std::to_string(print->model().id().id);
            ctx.name = print->get_model_name();
            ctx.code = LifecycleEvtCode::Error;
            ctx.msg  = std::string(path) + "\n" + err_msg;
            ctx.cancellation_check = [print]() { return print->canceled(); };
            fire_lifecycle_event(LifecycleEvent::GCodeExportFinished, ctx);
        }
        throw Slic3r::RuntimeError(err_msg);
    }
 
    try {
        this->_do_export(*print, file, thumbnail_cb);
        file.flush();
        if (file.is_error()) {
            file.close();
            boost::nowide::remove(path_tmp.c_str());
            // TRN %1% is a file path.
            throw Slic3r::RuntimeError(Slic3r::format(_(L("G-code export to %1% failed.\nIs the disk full?")), path) + "\n");
        }
    } catch (std::exception &ex) {
        // Rethrow on any exception. std::runtime_exception and CanceledException are expected to be thrown.
        // Close and remove the file.
        file.close();
        boost::nowide::remove(path_tmp.c_str());
        {
            LifecycleEventContext ctx;
            ctx.id = std::to_string(print->model().id().id);
            ctx.name = print->get_model_name();
            ctx.code = LifecycleEvtCode::Error;
            ctx.msg  = std::string(path) + "\n" + ex.what();
            ctx.cancellation_check = [print]() { return print->canceled(); };
            fire_lifecycle_event(LifecycleEvent::GCodeExportFinished, ctx);
        }
        throw;
    }
    file.close();
 
    check_placeholder_parser_failed();
 
#if ORCA_CHECK_GCODE_PLACEHOLDERS
    if (!m_placeholder_error_messages.empty()){
        std::ostringstream message;
        message << "Some EditGcodeDialog defs were not specified properly. Do so in PrintConfig under SlicingStatesConfigDef:" << std::endl;
        for (const auto& error : m_placeholder_error_messages) {
            message << std::endl << error.first << ": " << std::endl;
            for (const auto& str : error.second)
                message << str << ", ";
            message.seekp(-2, std::ios_base::end);
            message << std::endl;
        }
        throw Slic3r::PlaceholderParserError(message.str());
    }
#endif
 
    BOOST_LOG_TRIVIAL(debug) << "Start processing gcode, " << log_memory_info();
    // Post-process the G-code to update time stamps.
 
    m_timelapse_warning_code = 0;
    if (m_config.printer_structure.value == PrinterStructure::psI3 && m_spiral_vase) {
        m_timelapse_warning_code += 1;
    }
    if (m_config.printer_structure.value == PrinterStructure::psI3 && print->config().print_sequence == PrintSequence::ByObject) {
        m_timelapse_warning_code += (1 << 1);
    }
    if (m_config.timelapse_type.value == TimelapseType::tlSmooth && !m_config.enable_prime_tower.value) {
        m_timelapse_warning_code += (1 << 2);
    }
    m_processor.result().timelapse_warning_code = m_timelapse_warning_code;
    m_processor.result().support_traditional_timelapse = m_support_traditional_timelapse;
 
    bool activate_long_retraction_when_cut = false;
    for (const auto& filament : m_writer.extruders()) {
        size_t fi = get_filament_config_index((int)filament.id());
        activate_long_retraction_when_cut |= (
            m_config.long_retractions_when_cut.get_at(fi)
         && m_config.retraction_distances_when_cut.get_at(fi) > 0
            );
    }
 
    m_processor.result().long_retraction_when_cut = activate_long_retraction_when_cut;
   
    {   //BBS:check bed and filament compatible
        const ConfigOptionInts *bed_temp_opt = m_config.option<ConfigOptionInts>(get_bed_temp_1st_layer_key(m_config.curr_bed_type));
        std::vector<int> conflict_filament;
        for(auto extruder_id : m_initial_layer_extruders){
            int cur_bed_temp = bed_temp_opt->get_at(extruder_id);
            if (cur_bed_temp == 0) {
                conflict_filament.push_back(extruder_id);
            }
        }
 
        m_processor.result().filament_printable_reuslt = FilamentPrintableResult(conflict_filament, bed_type_to_gcode_string(m_config.curr_bed_type));
    }
    // check gcode is valid in machine printabele area and multi_extruder printabele area
    int extruder_size = m_print->config().nozzle_diameter.values.size();
    std::vector<Polygons> extruder_unprintable_polys   = m_print->get_extruder_unprintable_polygons();
    Pointfs               plate_printable_area         = m_print->config().printable_area.values;
    Pointfs               wrapping_exclude_area_points = m_print->config().wrapping_exclude_area.values;
    m_processor.check_multi_extruder_gcode_valid(extruder_size, plate_printable_area, m_print->config().printable_height.value, wrapping_exclude_area_points,
                                                 extruder_unprintable_polys, m_print->get_extruder_printable_height(),  m_print->get_filament_maps(),
                                                 m_print->get_physical_unprintable_filaments(m_print->get_slice_used_filaments(false)));
 
    // Hand the per-filament nozzle grouping to the processor BEFORE finalize, so the
    // pre-heat injector's second pass can resolve filament->nozzle->extruder (get_nozzle_from_id /
    // is_support_dynamic_nozzle_map). Print::_do_export re-assigns it onto the extracted result afterwards
    // (Print.cpp) for the device GUI, but that is too late for the in-finalize injector. Null for
    // single-nozzle prints, where the injector is gated off anyway (enable_pre_heating false).
    m_processor.result().nozzle_group_result = m_print->get_layered_nozzle_group_result();
 
    m_processor.finalize(true);
    if (m_processor.get_result().exclusion_volume_path_conflict) {
        const int extruder_id = m_processor.get_result().exclusion_volume_conflict_extruder_id;
        std::string warning = extruder_id >= 0 ?
            Slic3r::format(
                // TRN %1% is the extruder number counted from 1.
                _(L("A G-code move intersects a collision volume for extruder %1%. This may cause a printer collision.")),
                std::to_string(extruder_id + 1)) :
            _(L("A G-code move intersects a collision volume. This may cause a printer collision."));
        if (m_processor.get_result().exclusion_volume_conflict_used_unknown_z) {
            warning += "\n" + Slic3r::format(
                _(L("The intersecting move is at G-code line %1%. Its Z position is unknown after homing, so Orca checked it against every height.")),
                std::to_string(m_processor.get_result().exclusion_volume_conflict_gcode_id));
        }
        print->active_step_add_warning(
            PrintStateBase::WarningLevel::CRITICAL,
            warning,
            PrintStateBase::SlicingExclusionVolumeToolpath);
    }
//    DoExport::update_print_estimated_times_stats(m_processor, print->m_print_statistics);
    DoExport::update_print_estimated_stats(m_processor, m_writer.extruders(), print->m_print_statistics, print->config());
    // Printed-mass safety check. Flushed filament leaves the bed, so subtract it
    // from the total to get the mass actually resting on the plate. Gated on machine_max_printed_mass
    // (>0 only for A2L machines), so no existing printer's gcode_check_result changes.
    if (m_print->config().machine_max_printed_mass.value > EPSILON) {
        double mass_on_bed_total = print->m_print_statistics.total_weight;
        for (auto volume : m_processor.get_result().print_statistics.flush_per_filament) {
            size_t extruder_id = volume.first;
            auto   extruder    = std::find_if(m_writer.extruders().begin(), m_writer.extruders().end(), [extruder_id](const Extruder &extr) { return extr.id() == extruder_id; });
            if (extruder == m_writer.extruders().end()) continue;
            mass_on_bed_total -= (volume.second * extruder->filament_density() * 0.001);
        } // flushed weight will not be keeped on the hot bed, exclude it
        if (mass_on_bed_total > m_print->config().machine_max_printed_mass.value) {
            m_processor.result().gcode_check_result.error_code |= (1 << 11); // printed weight over limit
        }
    }
    if (result != nullptr) {
        *result = std::move(m_processor.extract_result());
        // set the filename to the correct value
        result->filename = path;
    }
 
    //BBS: add some log for error output
    BOOST_LOG_TRIVIAL(debug) << boost::format("Finished processing gcode to %1% ") % path_tmp;
 
    std::error_code ret = rename_file(path_tmp, path);
    if (ret) {
        {
            LifecycleEventContext ctx;
            ctx.id = std::to_string(print->model().id().id);
            ctx.name = print->get_model_name();
            ctx.code = LifecycleEvtCode::Error;
            ctx.msg  = std::string(path) + "\nFailed to rename the output G-code file: " + ret.message();
            ctx.cancellation_check = [print]() { return print->canceled(); };
            fire_lifecycle_event(LifecycleEvent::GCodeExportFinished, ctx);
        }
        throw Slic3r::RuntimeError(
            // TRN %1% is the temporary file path, %2% the output file path, %3% the system error message.
            Slic3r::format(_(L("Failed to rename the output G-code file from %1% to %2%.\nError: %3%\nIs %1% locked?")),
                           path_tmp, path, ret.message()) + '\n');
    }
    else {
        BOOST_LOG_TRIVIAL(info) << boost::format("rename_file from %1% to %2% successfully")% path_tmp % path;
    }
 
    BOOST_LOG_TRIVIAL(info) << "Exporting G-code finished" << log_memory_info();
    print->set_done(psGCodeExport);
 
    {
        LifecycleEventContext ctx;
        ctx.id = std::to_string(print->model().id().id);
        ctx.name = print->get_model_name();
        ctx.code = LifecycleEvtCode::Ok;
        ctx.msg  = path;
        ctx.cancellation_check = [print]() { return print->canceled(); };
        fire_lifecycle_event(LifecycleEvent::GCodeExportFinished, ctx);
    }
 
    // Orca: label_object_enabled reflects whether objects are labeled in the g-code (EXCLUDE_OBJECT /
    // M486), which is driven by exclude_object for every printer
    if(result != nullptr)
        result->label_object_enabled = m_enable_exclude_object;
    // Write the profiler measurements to file
    PROFILE_UPDATE();
    PROFILE_OUTPUT(debug_out_path("gcode-export-profile.txt").c_str());
}

References _, _do_export(), Slic3r::PrintBaseWithState< PrintStepEnum, COUNT >::active_step_add_warning(), Slic3r::bed_type_to_gcode_string(), Slic3r::ByObject, Slic3r::PrintBase::canceled(), Slic3r::LifecycleEventContext::cancellation_check, check_placeholder_parser_failed(), Slic3r::GCode::GCodeOutputStream::close(), Slic3r::LifecycleEventContext::code, Slic3r::Print::config(), Slic3r::PrintStateBase::CRITICAL, Slic3r::debug_out_path(), EPSILON, Slic3r::Error, Slic3r::GCodeProcessorResult::filename, Slic3r::fire_lifecycle_event(), Slic3r::GCode::GCodeOutputStream::flush(), Slic3r::format(), Slic3r::GCodeWriter::full_gcode_comment, Slic3r::GCodeExportFinished, Slic3r::GCodeExportStarted, Slic3r::ConfigOptionVector< int >::get_at(), Slic3r::get_bed_temp_1st_layer_key(), get_filament_config_index(), Slic3r::Print::get_model_name(), Slic3r::Print::get_plate_origin(), Slic3r::LifecycleEventContext::id, Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::Print::is_BBL_printer(), Slic3r::GCode::GCodeOutputStream::is_error(), Slic3r::GCode::GCodeOutputStream::is_open(), Slic3r::Print::is_step_done(), L, Slic3r::GCodeProcessorResult::label_object_enabled, Slic3r::log_memory_info(), m_config, m_curr_print, m_enable_exclude_object, m_exclusion_volume_travel_avoidance, m_initial_layer_extruders, m_pending_start_gcode_position, m_print, Slic3r::Print::m_print_statistics, m_processor, m_skirt_group_done, m_spiral_vase, m_support_traditional_timelapse, m_timelapse_warning_code, m_writer, Slic3r::PrintBase::model(), Slic3r::LifecycleEventContext::msg, Slic3r::LifecycleEventContext::name, Slic3r::Ok, Print, Slic3r::psGCodeExport, Slic3r::psI3, Slic3r::rename_file(), Slic3r::GCodeProcessor::s_IsBBLPrinter, Slic3r::PrintBaseWithState< PrintStepEnum, COUNT >::set_done(), Slic3r::PrintBaseWithState< PrintStepEnum, COUNT >::set_started(), Slic3r::PrintStateBase::SlicingExclusionVolumeToolpath, Slic3r::tlSmooth, Slic3r::PrintStatistics::total_weight, Slic3r::DoExport::update_print_estimated_stats(), and Slic3r::DoExport::validate_custom_gcode().

Here is the call graph for this function:

effective_layer_index_for_point()

int Slic3r::GCode::effective_layer_index_for_point ( const Vec3d & point_slicing_mm ) const

inlineprotectedinherited

                                                                             {
        double h;
        if (this->belt_height_above_floor(point_slicing_mm, h)) {
            const double lh = this->first_layer_band_mm();
            return h <= 0. ? 0 : int(std::floor(h / lh));
        }
        return on_first_layer() ? 0 : layer_id();
    }

References belt_height_above_floor(), first_layer_band_mm(), layer_id(), and on_first_layer().

Referenced by _extrude().

Here is the call graph for this function:

Here is the caller graph for this function:

emit_belt_brim_bands()

std::string Slic3r::GCode::emit_belt_brim_bands ( const Print & print, const std::vector< LayerToPrint > & layers, const size_t single_object_instance_idx, const unsigned int extruder_id )

protectedinherited

{
    std::string gcode;
    for (const LayerToPrint &ltp : layers) {
        const BeltBrimBand *band = ltp.belt_brim_band;
        if (band == nullptr || band->fills.empty() || ltp.original_object == nullptr)
            continue;
        const PrintObject &object = *ltp.original_object;
        // belt_brim_filament() is 1-based.
        if (! object.has_belt_brim() || static_cast<unsigned int>(object.belt_brim_filament() - 1) != extruder_id)
            continue;
        // Speeds, flow and retraction all read m_config.
        m_config.apply(print.default_region_config());
        m_config.apply(object.config(), true);
        // Apron bands have no Layer at all (m_layer is null here), so the belt
        // floor owner has to be named the same way the object brim names it.
        BeltFloorObjectGuard floor_owner{ m_belt_floor_object, &object };
        const size_t i_begin = single_object_instance_idx == size_t(-1) ? 0 : single_object_instance_idx;
        const size_t i_end   = single_object_instance_idx == size_t(-1) ? object.instances().size()
                                                                       : single_object_instance_idx + 1;
        for (size_t i = i_begin; i < i_end && i < object.instances().size(); ++ i) {
            // Band geometry is object-local, like the object's own extrusions.
            const Point &offset = object.instances()[i].shift;
            this->set_origin(unscale(offset));
            this->on_set_origin(&object, offset);
            m_avoid_crossing_perimeters.use_external_mp();
            for (const ExtrusionEntity *ee : band->fills.entities)
                if (ee != nullptr)
                    gcode += this->extrude_entity(*ee, "brim", NOZZLE_CONFIG(support_speed));
            m_avoid_crossing_perimeters.use_external_mp(false);
            m_avoid_crossing_perimeters.disable_once();
        }
    }
    return gcode;
}

References config(), Slic3r::Print::default_region_config(), Slic3r::ExtrusionEntityCollection::empty(), Slic3r::ExtrusionEntityCollection::entities, extrude_entity(), Slic3r::BeltBrimBand::fills, m_avoid_crossing_perimeters, m_belt_floor_object, m_config, NOZZLE_CONFIG, Slic3r::offset(), on_set_origin(), Print, set_origin(), and Slic3r::unscale().

Referenced by process_belt_brim_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

enable_cooling_markers()

bool Slic3r::GCode::enable_cooling_markers ( ) const

inlineinherited

{ return m_enable_cooling_markers; }

References m_enable_cooling_markers.

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

Here is the caller graph for this function:

export_layer_filaments()

void Slic3r::GCode::export_layer_filaments ( GCodeProcessorResult * result )

inherited

{
    if (result == nullptr)
        return;
 
    const std::vector<int>filament_map = m_config.filament_map.values; // 1 based
    std::vector<int>prev_filament(m_config.nozzle_diameter.size(), -1);
    for (size_t idx = 0; idx < m_sorted_layer_filaments.size(); ++idx) {
        for (auto f : m_sorted_layer_filaments[idx]) {
            // Mirror the guard in the sibling sequence loop below (the `filament_id < filament_map.size() &&
            // filament_map[filament_id] > 0` check): the H2C dynamic engine can yield a
            // per-layer filament set whose ids fall outside filament_map, or a filament_map value beyond the
            // physical-extruder count (prev_filament is sized nozzle_diameter.size()). Either an unguarded read
            // (filament_map[f], prev_filament[extruder_idx]) or the write below would be out of bounds and
            // corrupt the heap. Skipping such filaments keeps every access in range; on any valid slice the
            // guard never fires, so the shipping/static path is byte-identical.
            if (f >= filament_map.size() || filament_map[f] <= 0)
                continue;
            int extruder_idx = filament_map[f] - 1;
            if (extruder_idx >= (int) prev_filament.size())
                continue;
            if (prev_filament[extruder_idx] != -1 && f != prev_filament[extruder_idx]) {
                std::pair<int, int> from_to_pair = { prev_filament[extruder_idx],f };
                auto iter = result->filament_change_count_map.find(from_to_pair);
                if (iter == result->filament_change_count_map.end())
                    result->filament_change_count_map.emplace(from_to_pair, 1);
                else
                    iter->second += 1;
            }
            prev_filament[extruder_idx] = f;
        }
 
        // now we do not need sorted data, so we sort the filaments in id order
        auto layer_filaments = m_sorted_layer_filaments[idx];
        std::sort(layer_filaments.begin(), layer_filaments.end());
        auto iter = result->layer_filaments.find(layer_filaments);
        if (iter == result->layer_filaments.end()) {
            result->layer_filaments[layer_filaments].emplace_back(idx, idx);
        }
        else {
            // if layer id is sequential, expand the range
            if (iter->second.back().second == idx - 1)
                iter->second.back().second = idx;
            else
                iter->second.emplace_back(idx, idx);
        }
    }
 
    result->filament_change_sequence.clear();
    result->nozzle_change_sequence.clear();
 
    int prev_sequence_filament = -1;
    int prev_sequence_nozzle = -1;
    for (size_t layer_idx = 0; layer_idx < m_sorted_layer_filaments.size(); ++layer_idx) {
        for (unsigned int filament_id : m_sorted_layer_filaments[layer_idx]) {
            int nozzle_id = 0;
            if (filament_id < filament_map.size() && filament_map[filament_id] > 0)
                nozzle_id = filament_map[filament_id] - 1;
            if (prev_sequence_nozzle != nozzle_id || prev_sequence_filament != static_cast<int>(filament_id)) {
                result->nozzle_change_sequence.emplace_back(static_cast<unsigned int>(nozzle_id));
                result->filament_change_sequence.emplace_back(filament_id);
                prev_sequence_nozzle = nozzle_id;
                prev_sequence_filament = static_cast<int>(filament_id);
            }
        }
    }
 
    result->used_mixed_filaments = m_print->get_slice_used_mixed_filaments();
 
    result->optimal_assignment.clear();
    result->optimal_assignment.reserve(filament_map.size());
    for (int nozzle_id : filament_map)
        result->optimal_assignment.emplace_back(nozzle_id > 0 ? nozzle_id - 1 : 0);
}

References Slic3r::f(), Slic3r::GCodeProcessorResult::filament_change_count_map, Slic3r::GCodeProcessorResult::filament_change_sequence, Slic3r::filament_map(), Slic3r::GCodeProcessorResult::layer_filaments, m_config, m_print, m_sorted_layer_filaments, Slic3r::GCodeProcessorResult::nozzle_change_sequence, Slic3r::GCodeProcessorResult::optimal_assignment, and Slic3r::GCodeProcessorResult::used_mixed_filaments.

Here is the call graph for this function:

extrude_entity()

std::string Slic3r::GCode::extrude_entity ( const ExtrusionEntity & entity, const std::string & description = "", double speed = -1., const std::vector< const ExtrusionEntity * > & region_perimeters = {}, const WipeInwardSupport * wipe_support = nullptr )

protectedinherited

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

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

Referenced by emit_belt_brim_bands(), extrude_infill(), extrude_perimeters(), and generate_object_brim().

Here is the call graph for this function:

Here is the caller graph for this function:

extrude_infill()

std::string Slic3r::GCode::extrude_infill ( const Print & print, const std::vector< ObjectByExtruder::Island::Region > & by_region, bool ironing )

protectedinherited

{
    std::string                                   gcode;
    std::vector<const ExtrusionEntity*>           extrusions;
    std::vector<std::unique_ptr<ExtrusionEntity>> reversed;
    const char*                                   extrusion_name = ironing ? "ironing" : "infill";
    for (const ObjectByExtruder::Island::Region &region : by_region)
        if (! region.infills.empty()) {
            extrusions.clear();
            extrusions.reserve(region.infills.size());
            for (const ExtrusionEntity *ee : region.infills)
                if ((ee->role() == erIroning) == ironing)
                    extrusions.emplace_back(ee);
            if (! extrusions.empty()) {
                m_config.apply(print.get_print_region(&region - &by_region.front()).config());
                reversed.clear();
                chain_and_reorder_extrusion_entities(extrusions, m_last_pos.to_point(), reversed);
                // The reversed copies are in chain order.
                auto next_reversed = reversed.begin();
                for (const ExtrusionEntity *fill : extrusions) {
                    ExtrusionEntity *own_copy = next_reversed != reversed.end() && next_reversed->get() == fill ? (next_reversed++)->get() : nullptr;
                    auto *eec = dynamic_cast<const ExtrusionEntityCollection*>(fill);
                    if (eec) {
                        // A reversed copy is owned here and can be moved from.
                        ExtrusionEntityCollection chained = own_copy ? std::move(static_cast<ExtrusionEntityCollection&>(*own_copy)) : ExtrusionEntityCollection(*eec);
                        if (!chained.no_sort)
                            chain_and_reorder_extrusion_entities(chained.entities, m_last_pos.to_point());
                        for (ExtrusionEntity *ee : chained.entities)
                            gcode += this->extrude_entity(*ee, extrusion_name);
                    } else
                        gcode += this->extrude_entity(*fill, extrusion_name);
                }
            }
        }
    return gcode;
}

References Slic3r::chain_and_reorder_extrusion_entities(), Slic3r::PrintRegion::config(), Slic3r::ExtrusionEntityCollection::entities, Slic3r::erIroning, extrude_entity(), Slic3r::Print::get_print_region(), m_config, m_last_pos, Slic3r::ExtrusionEntityCollection::no_sort, Print, and Slic3r::ExtrusionEntity::role().

Here is the call graph for this function:

extrude_loop()

std::string Slic3r::GCode::extrude_loop ( const ExtrusionLoop & loop, const std::string & description, double speed = -1., const std::vector< const ExtrusionEntity * > & region_perimeters = {}, const Point * start_point = nullptr, const WipeInwardSupport * wipe_support = nullptr )

protectedinherited

{
    // get a copy; don't modify the orientation of the original loop object otherwise
    // next copies (if any) would not detect the correct orientation
    ExtrusionLoop loop = loop_ref;
 
    bool is_hole = (loop.loop_role() & elrHole) == elrHole;
 
    if (m_config.spiral_mode && !is_hole) {
        // if spiral vase, we have to ensure that all contour are in the same orientation.
        if (m_config.wall_direction == WallDirection::CounterClockwise)
            loop.make_counter_clockwise();
        else
            loop.make_clockwise();
    }
    //if (loop.loop_role() == elrSkirt && (this->m_layer->id() % 2 == 1))
    //    loop.reverse();
 
    // find the point of the loop that is closest to the current extruder position
    // or randomize if requested;
    // or, if `start_point` is specified, start the loop at point closest to it
    Point last_pos = start_point ? *start_point : this->last_pos();
    float seam_overhang = std::numeric_limits<float>::lowest();
    if (!m_config.spiral_mode && description == "perimeter") {
        assert(m_layer != nullptr);
        m_seam_placer.place_seam(m_layer, loop, last_pos, seam_overhang);
    } else
        loop.split_at(last_pos, false);
 
    const auto seam_scarf_type = m_config.seam_slope_type.value;
    // Belt printers never get a scarf joint. The scarf starts one layer height
    // below the layer, which on a tilted belt is a step backwards along the belt
    // axis into the previous layer's wall at the seam (0.28 mm at 45 degrees per
    // 0.2 mm layer); with an aligned seam that ram repeats at the same spot on
    // every layer and knocks the part loose.
    bool enable_seam_slope = ((seam_scarf_type == SeamScarfType::External && !is_hole) || seam_scarf_type == SeamScarfType::All) &&
        !m_config.spiral_mode && !m_config.belt_printer.value &&
        (loop.role() == erExternalPerimeter || (loop.role() == erPerimeter && m_config.seam_slope_inner_walls)) &&
        layer_id() > 0;
    const auto nozzle_diameter = EXTRUDER_CONFIG(nozzle_diameter);
    if (enable_seam_slope && m_config.seam_slope_conditional.value) {
        enable_seam_slope = loop.is_smooth(m_config.scarf_angle_threshold.value * M_PI / 180., nozzle_diameter);
    }
 
    if (enable_seam_slope && m_config.seam_slope_conditional.value && m_config.scarf_overhang_threshold.value > 0.0f) {
        const auto _line_width = loop.role() == erExternalPerimeter ? m_config.outer_wall_line_width.get_abs_value(nozzle_diameter) :
                                                                      m_config.inner_wall_line_width.get_abs_value(nozzle_diameter);
        enable_seam_slope      = seam_overhang < m_config.scarf_overhang_threshold.value * 0.01f * _line_width;
    }
 
    // clip the path to avoid the extruder to get exactly on the first point of the loop;
    // if polyline was shorter than the clipping distance we'd get a null polyline, so
    // we discard it in that case
    const double seam_gap = scale_(m_config.seam_gap.get_abs_value(nozzle_diameter));
    const bool seam_gap_applied = enable_seam_slope || m_enable_loop_clipping;
    const double seam_gap_distance_mm = seam_gap_applied ? unscale_(seam_gap) : 0.0;
    double seam_scarf_distance_mm = 0.0;
    const double clip_length = m_enable_loop_clipping && !enable_seam_slope ? seam_gap : 0;
 
    // get paths
    ExtrusionPaths paths;
    loop.clip_end(clip_length, &paths);
    if (paths.empty()) return "";
 
    // SoftFever: check loop lenght for small perimeter. 
    double small_peri_speed = -1;
    if (speed == -1 && loop.length() <= SMALL_PERIMETER_LENGTH(NOZZLE_CONFIG(small_perimeter_threshold))) {
        if(NOZZLE_CONFIG(small_perimeter_speed).value == 0)
            small_peri_speed = NOZZLE_CONFIG(outer_wall_speed) * 0.5;
        else
            small_peri_speed = NOZZLE_CONFIG(small_perimeter_speed).get_abs_value(NOZZLE_CONFIG(outer_wall_speed));
    }
 
    // extrude along the path
    std::string gcode;
    
    // Orca:
    // Port of "wipe inside before extruding an external perimeter" feature from super slicer
    // If region perimeters size not greater than or equal to 2, then skip the wipe inside move as we will extrude in mid air
    // as no neighbouring perimeter exists. If an internal perimeter exists, we should find 2 perimeters touching the de-retraction point
    // 1 - the currently printed external perimeter and 2 - the neighbouring internal perimeter.
    if (m_config.wipe_before_external_loop.value && !paths.empty() && paths.front().size() > 1 && paths.back().size() > 1 && paths.front().role() == erExternalPerimeter && region_perimeters.size() > 1) {
        const bool is_full_loop_ccw = loop.polygon().is_counter_clockwise();
        bool is_hole_loop = (loop.loop_role() & ExtrusionLoopRole::elrHole) != 0;
        const double nozzle_diam = nozzle_diameter;
 
        // note: previous & next are inverted to extrude "in the opposite direction, and we are "rewinding"
        Point previous_point = Point(paths.front().polyline.points[1].x(), paths.front().polyline.points[1].y());
        Point current_point = Point(paths.front().polyline.points.front().x(), paths.front().polyline.points.front().y());
        Point next_point = Point(paths.back().polyline.points.back().x(), paths.back().polyline.points.back().y());
 
        // can happen if seam_gap is null
        if (next_point == current_point) {
            const Point3 &p3 = paths.back().polyline.points[paths.back().polyline.points.size() - 2];
            next_point = Point(p3.x(), p3.y());
        }
 
        Point a = next_point;  // second point
        Point b = previous_point;  // second to last point
        if ((is_hole_loop ? !is_full_loop_ccw : is_full_loop_ccw)) {
            // swap points
            std::swap(a, b);
        }
 
        double angle = current_point.ccw_angle(a, b) / 3;
 
        // turn outwards if contour, turn inwwards if hole
        if (is_hole_loop ? !is_full_loop_ccw : is_full_loop_ccw) angle *= -1;
 
        Vec2d current_pos = current_point.cast<double>();
        Vec2d next_pos = next_point.cast<double>();
        Vec2d vec_dist = next_pos - current_pos;
        double vec_norm = vec_dist.norm();
        // Offset distance is the minimum between half the nozzle diameter or half the line width for the upcomming perimeter
        // This is to mimimize potential instances where the de-retraction is performed on top of a neighbouring
        // thin perimeter due to arachne reducing line width.
        coordf_t dist = std::min(scaled(nozzle_diam) * 0.5, scaled(paths.front().width) * 0.5);
 
        // FIXME Hiding the seams will not work nicely for very densely discretized contours!
        Point pt = (current_pos + vec_dist * (2 * dist / vec_norm)).cast<coord_t>();
        pt.rotate(angle, current_point);
        pt = (current_pos + vec_dist * (2 * dist / vec_norm)).cast<coord_t>();
        pt.rotate(angle, current_point);
        
        // Search region perimeters for lines that are touching the de-retraction point.
        // If an internal perimeter exists, we should find 2 perimeters touching the de-retraction point
        // 1: the currently printed external perimeter and 2: the neighbouring internal perimeter.
        int discoveredTouchingLines = 0;
        for (const ExtrusionEntity* ee : region_perimeters){
            auto potential_touching_line = ee->as_polyline();
            AABBTreeLines::LinesDistancer<Line> potential_touching_line_distancer{potential_touching_line.lines()};
            auto touching_line = potential_touching_line_distancer.all_lines_in_radius(pt, scale_(nozzle_diam));
            if(touching_line.size()){
                discoveredTouchingLines ++;
                if(discoveredTouchingLines > 1) break; // found 2 touching lines. End the search early.
            }
        }
        // found 2 perimeters touching the de-retraction point. Its safe to deretract as the point will be
        // inside the model
        if(discoveredTouchingLines > 1){
            // use extrude instead of travel_to_xy to trigger the unretract
            ExtrusionPath fake_path_wipe(Polyline3(Points3{Point3(pt), Point3(current_point)}), paths.front());
            fake_path_wipe.set_force_no_extrusion(true);
            fake_path_wipe.mm3_per_mm = 0;
            //fake_path_wipe.set_extrusion_role(erExternalPerimeter);
            gcode += extrude_path(fake_path_wipe, "move inwards before retraction/seam", speed);
        }
    }
 
 
    const auto speed_for_path = [&speed, &small_peri_speed](const ExtrusionPath& path) {
        // don't apply small perimeter setting for overhangs/bridges/non-perimeters
        const bool is_small_small_perimeter = small_peri_speed > 0 && !is_bridge(path.role()) && is_perimeter(path.role());
        return is_small_small_perimeter ? small_peri_speed : speed;
    };
 
    
    //Orca: Adaptive PA: calculate average mm3_per_mm value over the length of the loop.
    //This is used for adaptive PA
    m_multi_flow_segment_path_pa_set = false; // always emit PA on the first path of the loop
    m_multi_flow_segment_path_average_mm3_per_mm = 0;
    double weighted_sum_mm3_per_mm = 0.0;
    double total_multipath_length = 0.0;
    for (const ExtrusionPath& path : paths) {
        if(!path.is_force_no_extrusion()){
            double path_length = unscale<double>(path.length()); //path length in mm
            weighted_sum_mm3_per_mm += path.mm3_per_mm * path_length;
            total_multipath_length += path_length;
        }
    }
    if (total_multipath_length > 0.0)
        m_multi_flow_segment_path_average_mm3_per_mm = weighted_sum_mm3_per_mm / total_multipath_length;
    // Orca: end of multipath average mm3_per_mm value calculation
    
    if (!enable_seam_slope) {
        for (const ExtrusionPath& path : paths) {
            gcode += this->_extrude(path, description, speed_for_path(path));
            // Orca: Adaptive PA - dont adapt PA after the first multipath extrusion is completed
            // as we have already set the PA value to the average flow over the totality of the path
            // in the first extrude move
            // TODO: testing is needed with slope seams and adaptive PA.
            m_multi_flow_segment_path_pa_set = true;
        }
    } else {
        // Create seam slope
        double start_slope_ratio;
        if (m_config.seam_slope_start_height.percent) {
            start_slope_ratio = m_config.seam_slope_start_height.value / 100.;
        } else {
            // Get the ratio against current layer height
            double h = paths.front().height;
            start_slope_ratio = m_config.seam_slope_start_height.value / h;
        }
        if (start_slope_ratio >= 1)
            start_slope_ratio = 0.99;
 
        double loop_length = 0.;
        for (const auto & path : paths) {
            loop_length += unscale_(path.length());
        }
 
        const bool   slope_entire_loop        = m_config.seam_slope_entire_loop;
        const double slope_min_length         = slope_entire_loop ? loop_length : std::min(m_config.seam_slope_min_length.value, loop_length);
        const int    slope_steps              = m_config.seam_slope_steps;
        const double slope_max_segment_length = scale_(slope_min_length / slope_steps);
        seam_scarf_distance_mm = slope_min_length;
 
        // Calculate the sloped loop
        ExtrusionLoopSloped new_loop(paths, seam_gap, slope_min_length, slope_max_segment_length, start_slope_ratio, loop.loop_role());
        new_loop.clip_slope(seam_gap);
 
        // Then extrude it
        for (const ExtrusionPath* path : new_loop.get_all_paths()) {
            gcode += this->_extrude(*path, description, speed_for_path(*path));
            // Orca: Adaptive PA - dont adapt PA after the first pultipath extrusion is completed
            // as we have already set the PA value to the average flow over the totality of the path
            // in the first extrude move
            m_multi_flow_segment_path_pa_set = true;
        }
 
        // Fix path for wipe
        if (!new_loop.ends.empty()) {
            paths.clear();
            // The start slope part is ignored as it overlaps with the end part
            paths.reserve(new_loop.paths.size() + new_loop.ends.size());
            paths.insert(paths.end(), new_loop.paths.begin(), new_loop.paths.end());
            paths.insert(paths.end(), new_loop.ends.begin(), new_loop.ends.end());
        }
    }
 
    if (description == "perimeter") {
        m_processor.result().print_statistics.total_seam_gap_distance += static_cast<float>(seam_gap_distance_mm);
        m_processor.result().print_statistics.total_seam_scarf_distance += static_cast<float>(seam_scarf_distance_mm);
    }
 
    // Orca: share the post-extrusion nozzle position between wipe_inward and wipe_on_loops.
    const bool is_ccw = loop.is_counter_clockwise();
 
    std::optional<Point> wipe_on_loops_dest;
    if (m_config.wipe_on_loops.value && paths.back().role() == erExternalPerimeter &&
        m_layer != nullptr && m_config.wall_loops.value > 1 && paths.front().size() >= 2 &&
        paths.back().polyline.points.size() >= 2)
        wipe_on_loops_dest = wipe_on_loops_destination(paths, scale_(nozzle_diameter), is_ccw, is_hole);
 
    bool wipe_inward_applied = false;
    // Orca: store loop paths in print order because inward offsets use this orientation.
    if (m_wipe.enable && FILAMENT_CONFIG(wipe)) {
        m_wipe.update_path(paths);
 
        // Orca: loop wipe paths retain print direction. Their material side is
        // therefore left for CCW contours and right for CW contours, with the
        // result inverted for holes. Only external perimeters are eligible.
        // Calibration overrides are applied during extrusion, after the region
        // context was created. Check the effective setting again at execution.
        if (m_config.wipe_inward && m_config.wipe_inward_distance.value > 0. &&
            wipe_support != nullptr && !wipe_support->inner_lines.empty() &&
            // A loop's role is its first path's role. An overhanging start must
            // not hide ordinary external-wall segments elsewhere in the loop.
            std::any_of(paths.begin(), paths.end(),
                [](const ExtrusionPath &path) { return is_external_perimeter(path.role()); }) &&
            m_wipe.path.points.size() >= 2) {
            // Orca: use the actual extrusion width from the path, not the config
            // value — outer_wall_line_width=0 (Auto) would make get_abs_value
            // return 0 and silently disable the feature, and Arachne may produce
            // a different width than the config default.
            const double outer_wall_line_width = paths.front().width;
            const double requested_offset = m_config.wipe_inward_distance.get_abs_value(outer_wall_line_width);
            const double offset_dist = scale_(std::min(requested_offset, outer_wall_line_width));
            if (offset_dist > SCALED_EPSILON) {
                const Point seam_start = paths.front().first_point();
                const Point seam_end   = paths.back().last_point();
                const Point wipe_start = wipe_on_loops_dest.value_or(seam_end);
                const double max_wipe_length = scale_(FILAMENT_CONFIG(wipe_distance));
                // Orca: Wipe::wipe() replaces points[0] with last_pos and executes
                // from points[1]. The helper preserves that sentinel and atomically
                // replaces the remaining points, or leaves the path untouched.
                // Orca: a configured wall count does not guarantee that Arachne
                // generated an adjacent wall for this particular loop. Only
                // earlier entities are considered because later walls have
                // not been printed yet (for example with Outer/Inner order).
                // Inner walls determine the material side; every earlier wall
                // remains available to validate the executable wipe path.
                const double support_distance = scale_(std::max(nozzle_diameter, outer_wall_line_width));
                Polyline inward_path = m_wipe.path;
                if (offset_wipe_path_toward_support(
                        inward_path, seam_start, seam_end, wipe_start,
                        wipe_offset_direction(is_ccw, is_hole), offset_dist, max_wipe_length,
                        wipe_support->inner_lines, wipe_support->printed_lines,
                        m_wipe.path.lines(), support_distance)) {
                    m_wipe.path = std::move(inward_path);
                    wipe_inward_applied = true;
                }
            }
        }
    }
 
    // Orca: make the configured inward move before leaving the loop.
    if (wipe_on_loops_dest) {
        gcode += m_writer.extrude_to_xy(
            this->point_to_gcode(*wipe_on_loops_dest), 0, "move inwards before travel", true);
        this->set_last_pos(*wipe_on_loops_dest);
    }
 
    // Execute the accepted path before another extrusion replaces it. Wiping
    // must not force retraction or Z-hop across a short travel to the next wall.
    // Ordinary travel planning decides whether to retract from the new position.
    if (wipe_inward_applied)
        gcode += m_wipe.wipe(*this, 0.);
 
    return gcode;
}

References _extrude(), Slic3r::All, Slic3r::AABBTreeLines::LinesDistancer< LineType >::all_lines_in_radius(), Slic3r::angle(), Slic3r::cast(), Slic3r::Point::ccw_angle(), Slic3r::ExtrusionLoop::clip_end(), Slic3r::ExtrusionLoopSloped::clip_slope(), Slic3r::CounterClockwise, Slic3r::Geometry::dist(), Slic3r::elrHole, Slic3r::ExtrusionLoopSloped::ends, Slic3r::erExternalPerimeter, Slic3r::erPerimeter, Slic3r::External, extrude_path(), EXTRUDER_CONFIG, FILAMENT_CONFIG, Slic3r::ExtrusionLoopSloped::get_all_paths(), Slic3r::WipeInwardSupport::inner_lines, Slic3r::is_bridge(), Slic3r::Geometry::is_ccw(), Slic3r::ExtrusionLoop::is_counter_clockwise(), Slic3r::Polygon::is_counter_clockwise(), Slic3r::is_perimeter(), Slic3r::ExtrusionLoop::is_smooth(), last_pos(), layer_id(), Slic3r::ExtrusionLoop::length(), Slic3r::ExtrusionLoop::loop_role(), m_config, m_enable_loop_clipping, m_layer, m_multi_flow_segment_path_average_mm3_per_mm, m_multi_flow_segment_path_pa_set, M_PI, m_processor, m_seam_placer, m_wipe, m_writer, Slic3r::ExtrusionLoop::make_clockwise(), Slic3r::ExtrusionLoop::make_counter_clockwise(), Slic3r::ExtrusionPath::mm3_per_mm, NOZZLE_CONFIG, Slic3r::nozzle_diameter(), Slic3r::offset_wipe_path_toward_support(), Slic3r::outer_wall_speed(), Slic3r::ExtrusionLoop::paths, point_to_gcode(), Slic3r::ExtrusionLoop::polygon(), Slic3r::WipeInwardSupport::printed_lines, Slic3r::ExtrusionLoop::role(), Slic3r::Point::rotate(), scale_, Slic3r::scaled(), SCALED_EPSILON, Slic3r::ExtrusionPath::set_force_no_extrusion(), set_last_pos(), SMALL_PERIMETER_LENGTH, Slic3r::small_perimeter_speed(), Slic3r::ExtrusionLoop::split_at(), Slic3r::unscale(), unscale_, Slic3r::wipe(), Slic3r::wipe_offset_direction(), and Slic3r::wipe_on_loops_destination().

Referenced by extrude_entity(), extrude_support(), and generate_skirt().

Here is the call graph for this function:

Here is the caller graph for this function:

extrude_multi_path()

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

protectedinherited

{
    // extrude along the path
    std::string gcode;
 
    //Orca: calculate multipath average mm3_per_mm value over the length of the path.
    //This is used for adaptive PA
    m_multi_flow_segment_path_pa_set = false; // always emit PA on the first path of the multi-path
    m_multi_flow_segment_path_average_mm3_per_mm = 0;
    double weighted_sum_mm3_per_mm = 0.0;
    double total_multipath_length = 0.0;
    for (const ExtrusionPath& path : multipath.paths) {
        if(!path.is_force_no_extrusion()){
            double path_length = unscale<double>(path.length()); //path length in mm
            weighted_sum_mm3_per_mm += path.mm3_per_mm * path_length;
            total_multipath_length += path_length;
        }
    }
    if (total_multipath_length > 0.0)
        m_multi_flow_segment_path_average_mm3_per_mm = weighted_sum_mm3_per_mm / total_multipath_length;
    // Orca: end of multipath average mm3_per_mm value calculation
 
    for (const ExtrusionPath &path : multipath.paths){
        gcode += this->_extrude(path, description, speed);
        // Orca: Adaptive PA - dont adapt PA after the first pultipath extrusion is completed
        // as we have already set the PA value to the average flow over the totality of the path
        // in the first extrude move.
        m_multi_flow_segment_path_pa_set = true;
    }
 
    // Orca: multipath wipes retrace the extrusion in reverse order.
    if (m_wipe.enable && FILAMENT_CONFIG(wipe))
        m_wipe.update_path(multipath.paths, true);
 
    return gcode;
}

References _extrude(), FILAMENT_CONFIG, Slic3r::ExtrusionPath::is_force_no_extrusion(), Slic3r::ExtrusionPath::length(), m_multi_flow_segment_path_average_mm3_per_mm, m_multi_flow_segment_path_pa_set, m_wipe, Slic3r::ExtrusionPath::mm3_per_mm, Slic3r::ExtrusionMultiPath::paths, Slic3r::unscale(), and Slic3r::wipe().

Referenced by extrude_entity(), and extrude_support().

Here is the call graph for this function:

Here is the caller graph for this function:

extrude_path()

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

protectedinherited

{
    // Orca: Reset average multipath flow as this is a single line, single extrude volumetric speed path
    m_multi_flow_segment_path_pa_set = false;
    m_multi_flow_segment_path_average_mm3_per_mm = 0;
    //    description += ExtrusionEntity::role_to_string(path.role());
    std::string gcode = this->_extrude(path, description, speed);
    if (m_wipe.enable && FILAMENT_CONFIG(wipe)) {
        m_wipe.reset_path();
        m_wipe.path = path.polyline.to_polyline();
        if (is_tree(this->config().support_type) && is_support(path.role())) {
            if ((m_wipe.path.first_point() - m_wipe.path.last_point()).cast<double>().norm() > scale_(0.2)) {
                double min_dist = scale_(0.2);
                int    i        = 0;
                for (; i < path.polyline.points.size(); i++) {
                    double dist = (path.polyline.points[i] - path.last_point3()).cast<double>().norm();
                    if (dist < min_dist) min_dist = dist;
                    if (min_dist < scale_(0.2) && dist > min_dist) break;
                }
                m_wipe.path = Polyline3(Points3(path.polyline.points.begin() + i - 1, path.polyline.points.end())).to_polyline();
            }
        } else
            m_wipe.path.reverse();
    }
 
    return gcode;
}

References _extrude(), config(), Slic3r::Geometry::dist(), FILAMENT_CONFIG, Slic3r::is_support(), Slic3r::is_tree(), Slic3r::ExtrusionPath::last_point3(), m_multi_flow_segment_path_average_mm3_per_mm, m_multi_flow_segment_path_pa_set, m_wipe, Slic3r::MultiPoint3::points, Slic3r::ExtrusionPath::polyline, Slic3r::ExtrusionPath::role(), scale_, Slic3r::Polyline3::to_polyline(), and Slic3r::wipe().

Referenced by extrude_entity(), extrude_loop(), and extrude_support().

Here is the call graph for this function:

Here is the caller graph for this function:

extrude_perimeters()

std::string Slic3r::GCode::extrude_perimeters ( const Print & print, const std::vector< ObjectByExtruder::Island::Region > & by_region, bool is_first_layer, bool is_infill_first, bool unsupported_loops_only = false )

protectedinherited

{
    std::string gcode;
    for (const ObjectByExtruder::Island::Region &region : by_region)
        if (! region.perimeters.empty()) {
            m_config.apply(print.get_print_region(&region - &by_region.front()).config());
            // BBS: for first layer, we always print wall firstly to get better bed adhesive force
            // This behaviour is same with cura
            const bool should_print = is_first_layer ? !is_infill_first
                : (m_config.is_infill_first == is_infill_first);
            if (!should_print) continue;
 
            // Build the printed prefix once in emission order, scoped to this
            // region. Disabled or zero-length wipes need no support geometry.
            std::optional<WipeInwardSupport> wipe_support;
            if (m_wipe.enable && FILAMENT_CONFIG(wipe) && m_config.wipe_inward &&
                m_config.wipe_inward_distance.value > 0. &&
                scale_(FILAMENT_CONFIG(wipe_distance)) > SCALED_EPSILON)
                wipe_support.emplace();
 
            // ORCA: loops flagged as extruded in mid air, out of reach of the layer below, are held back
            // for a second pass after the infill that anchors them. Infill already precedes infill first walls.
            const bool defer_unsupported = !is_infill_first;
            auto waits_for_infill = [](const ExtrusionEntity *ee) {
                return ee->is_loop() && static_cast<const ExtrusionLoop *>(ee)->print_after_infill;
            };
 
            // The deferred pass runs after the infill, so the loops the first pass emitted are
            // already down and belong in the prefix an inward wipe may land on.
            if (wipe_support && defer_unsupported && unsupported_loops_only)
                for (const ExtrusionEntity* ee : region.perimeters)
                    if (!waits_for_infill(ee))
                        wipe_support->append(*ee);
 
            for (const ExtrusionEntity* ee : region.perimeters) {
                if (defer_unsupported && waits_for_infill(ee) != unsupported_loops_only)
                    continue;
                gcode += this->extrude_entity(*ee, "perimeter", -1., region.perimeters,
                                             wipe_support ? &*wipe_support : nullptr);
                if (wipe_support)
                    wipe_support->append(*ee);
            }
        }
    return gcode;
}

References Slic3r::PrintRegion::config(), extrude_entity(), FILAMENT_CONFIG, Slic3r::Print::get_print_region(), Slic3r::is_infill_first(), m_config, m_wipe, Print, scale_, SCALED_EPSILON, and Slic3r::wipe().

Here is the call graph for this function:

extrude_support()

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

protectedinherited

{
    static constexpr const char* support_label            = "support material";
    static constexpr const char* support_interface_label  = "support material interface";
    static constexpr const char* support_transition_label = "support transition";
    static constexpr const char* support_ironing_label    = "support ironing";
 
    // Not static: it captures `this` by reference.
    const auto speed_for_path = [&](double length, ExtrusionRole role, double default_speed = -1.0) {
        if (!is_support(role) || length > SMALL_PERIMETER_LENGTH(NOZZLE_CONFIG(small_support_perimeter_threshold)))
            return default_speed;
 
        double small_perimeter_speed = -1.0;
 
        const auto base_speed = (role == erSupportMaterialInterface) 
            ? NOZZLE_CONFIG(support_interface_speed) : NOZZLE_CONFIG(support_speed);
 
        if (NOZZLE_CONFIG(small_support_perimeter_speed).value == 0)
            small_perimeter_speed = base_speed * 0.5;
        else
            small_perimeter_speed = NOZZLE_CONFIG(small_support_perimeter_speed).get_abs_value(base_speed);
 
        return small_perimeter_speed > 0 ? small_perimeter_speed : default_speed;
    };
 
    // Supports are removed after printing and gain nothing from high precision G-code but a larger file, so they are
    // written with the standard precision, as the wipe tower is. Support ironing keeps it, as it smooths the surface
    // the object is printed on.
    const bool was_standard_precision = m_writer.force_standard_precision(support_extrusion_role != erIroning);
    ScopeGuard restore_precision([this, was_standard_precision] { m_writer.force_standard_precision(was_standard_precision); });
 
    std::string gcode;
    if (!support_fills.entities.empty()) {
 
        std::vector<const ExtrusionEntity*> extrusions;
        extrusions.reserve(support_fills.entities.size());
        for (const ExtrusionEntity* ee : support_fills.entities) {
            const auto role = ee->role();
            if ((role == support_extrusion_role) || (support_extrusion_role == erMixed && role != erIroning)) {
                extrusions.emplace_back(ee);
            }
        }
        if (extrusions.empty())
            return gcode;
 
        std::vector<std::unique_ptr<ExtrusionEntity>> reversed;
        //ORCA: Respect no_sort to preserve support base outline->fill order.
        if (!support_fills.no_sort)
            chain_and_reorder_extrusion_entities(extrusions, m_last_pos.to_point(), reversed);
 
        for (const ExtrusionEntity *ee : extrusions) {
            ExtrusionRole role = ee->role();
            assert(is_support(role) || role == erIroning);
 
            const char* label = (role == erSupportMaterial) ? support_label :
                ((role == erSupportMaterialInterface) ? support_interface_label : 
                ((role == erIroning) ? support_ironing_label : support_transition_label));
 
            const ExtrusionPath* path = dynamic_cast<const ExtrusionPath*>(ee);
            const ExtrusionMultiPath* multipath = dynamic_cast<const ExtrusionMultiPath*>(ee);
            const ExtrusionLoop* loop = dynamic_cast<const ExtrusionLoop*>(ee);
            const ExtrusionEntityCollection* collection = dynamic_cast<const ExtrusionEntityCollection*>(ee);
 
            if (path) {
                gcode += extrude_path(*path, label, speed_for_path(path->length(), role));
            }
            else if (multipath) {
                gcode += extrude_multi_path(*multipath, label, speed_for_path(multipath->length(), role));
            }
            else if (loop) {
                gcode += extrude_loop(*loop, label, speed_for_path(loop->length(), role));
            }
            else if (collection) {
                gcode += extrude_support(*collection, support_extrusion_role);
            }
            else {
                throw Slic3r::InvalidArgument("Unknown extrusion type");
            }
        }
    }
    return gcode;
}

References Slic3r::chain_and_reorder_extrusion_entities(), Slic3r::ExtrusionEntityCollection::entities, Slic3r::erIroning, Slic3r::erMixed, Slic3r::erSupportMaterial, Slic3r::erSupportMaterialInterface, extrude_loop(), extrude_multi_path(), extrude_path(), extrude_support(), Slic3r::is_support(), Slic3r::ExtrusionLoop::length(), Slic3r::ExtrusionMultiPath::length(), Slic3r::ExtrusionPath::length(), Slic3r::length(), m_last_pos, m_writer, Slic3r::ExtrusionEntityCollection::no_sort, NOZZLE_CONFIG, Slic3r::ExtrusionEntity::role(), SMALL_PERIMETER_LENGTH, Slic3r::small_perimeter_speed(), and Slic3r::small_support_perimeter_speed().

Referenced by extrude_support().

Here is the call graph for this function:

Here is the caller graph for this function:

extrusion_role_to_string_for_parser()

std::string Slic3r::GCode::extrusion_role_to_string_for_parser ( const ExtrusionRole & role )

inherited

{
    switch (role) {
        case erPerimeter: return "Perimeter";
        case erExternalPerimeter: return "ExternalPerimeter";
        case erOverhangPerimeter: return "OverhangPerimeter";
        case erInternalInfill: return "InternalInfill";
        case erSolidInfill: return "SolidInfill";
        case erTopSolidInfill: return "TopSolidInfill";
        case erBottomSurface: return "BottomSurface";
        case erBridgeInfill:
        case erInternalBridgeInfill: return "BridgeInfill";
        case erGapFill: return "GapFill";
        case erIroning: return "Ironing";
        case erSkirt: return "Skirt";
        case erBrim: return "Brim";
        case erSupportMaterial: return "SupportMaterial";
        case erSupportMaterialInterface: return "SupportMaterialInterface";
        case erSupportTransition: return "SupportTransition";
        case erWipeTower: return "WipeTower";
        case erCustom:
        case erMixed:
        case erCount:
        case erNone:
        default: return "Mixed";
    }
}

References Slic3r::erBottomSurface, Slic3r::erBridgeInfill, Slic3r::erBrim, Slic3r::erCount, Slic3r::erCustom, Slic3r::erExternalPerimeter, Slic3r::erGapFill, Slic3r::erInternalBridgeInfill, Slic3r::erInternalInfill, Slic3r::erIroning, Slic3r::erMixed, Slic3r::erNone, Slic3r::erOverhangPerimeter, Slic3r::erPerimeter, Slic3r::erSkirt, Slic3r::erSolidInfill, Slic3r::erSupportMaterial, Slic3r::erSupportMaterialInterface, Slic3r::erSupportTransition, Slic3r::erTopSolidInfill, and Slic3r::erWipeTower.

Referenced by _extrude().

Here is the caller graph for this function:

first_layer_band_mm()

double Slic3r::GCode::first_layer_band_mm ( ) const

inlineprotectedinherited

                                       {
        const double band = m_config.initial_layer_print_height.value;
        return band > 0. ? band : 0.2;
    }

References m_config.

Referenced by belt_layer_past_first_layer_band(), and effective_layer_index_for_point().

Here is the caller graph for this function:

gcode_to_point()

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

inherited

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

References m_config, m_origin, m_writer, and Slic3r::scaled().

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

Here is the call graph for this function:

Here is the caller graph for this function:

generate_object_brim()

std::string Slic3r::GCode::generate_object_brim ( const Print & print, const PrintObject & object, size_t instance_id, bool first_layer, unsigned int extruder_id, const Layer * object_layer )

protectedinherited

{
    // Belt printers lay the brim onto the tilted belt over many layers, so there is
    // nothing special about the first one.  The bands that coincide with an object
    // layer are emitted here; those below the object's first layer are apron and go
    // through process_belt_brim_layer() instead.
    if (object.has_belt_brim()) {
        if (object_layer == nullptr)
            return {};
        const std::vector<ExtrusionEntityCollection> &by_layer = object.belt_brim_by_layer();
        const size_t layer_idx = object_layer->id();
        if (layer_idx >= by_layer.size() || by_layer[layer_idx].empty())
            return {};
        std::string gcode;
        // The band geometry is in the object's local slicing frame, exactly like its
        // perimeters, so it needs this instance's origin.  The caller does not set it
        // until later, and the plate brim path deliberately uses (0, 0) because its
        // geometry is already in plate coordinates.
        m_config.apply(print.default_region_config());
        m_config.apply(object.config(), true);
        // m_layer is not switched to this object until after brim emission, so name
        // the belt-floor owner explicitly or the classification borrows whichever
        // object was visited last.
        BeltFloorObjectGuard floor_owner{ m_belt_floor_object, &object };
        const Point &offset = object.instances()[instance_id].shift;
        this->set_origin(unscale(offset));
        this->on_set_origin(&object, offset);
        m_avoid_crossing_perimeters.use_external_mp();
        for (const ExtrusionEntity *ee : by_layer[layer_idx].entities)
            if (ee != nullptr)
                gcode += this->extrude_entity(*ee, "brim", NOZZLE_CONFIG(support_speed));
        m_avoid_crossing_perimeters.use_external_mp(false);
        m_avoid_crossing_perimeters.disable_once();
        return gcode;
    }
 
    if (!first_layer)
        return {};
 
    const bool wait_for_owner_filament = has_bed_exclude_volumes(m_config) &&
        active_bed_exclude_volume_mode(m_config) != BedExcludeVolumeMode::Shared;
    auto emit_brim = [this, extruder_id, wait_for_owner_filament](const ExtrusionEntityCollection& brim,
                                         const std::vector<ObjectInstanceID>& instances,
                                         const unsigned int brim_filament_id) {
        std::string gcode;
        // Combined brims have an explicit owner filament. Waiting for that
        // filament is only required when each nozzle has different obstacles.
        // Otherwise retain Orca's established first-visit emission order.
        if (wait_for_owner_filament && brim_filament_id != extruder_id)
            return gcode;
        const bool already_emitted = std::none_of(instances.begin(), instances.end(), [this](const ObjectInstanceID& instance) {
            return m_objsWithBrim.find(instance) != m_objsWithBrim.end();
        });
        if (already_emitted || brim.empty())
            return gcode;
 
        this->set_origin(0., 0.);
        m_avoid_crossing_perimeters.use_external_mp();
        for (const ExtrusionEntity* ee : brim.entities)
            if (ee != nullptr)
                gcode += this->extrude_entity(*ee, "brim", NOZZLE_CONFIG(support_speed));
        m_avoid_crossing_perimeters.use_external_mp(false);
        m_avoid_crossing_perimeters.disable_once();
        for (const ObjectInstanceID& instance : instances)
            m_objsWithBrim.erase(instance);
        return gcode;
    };
 
    const ObjectInstanceID object_instance_id{ object.id(), instance_id };
    const size_t group_idx = find_skirt_brim_group_idx(print, object.id(), instance_id);
    if (group_idx != size_t(-1)) {
        std::string gcode;
        for (const Print::SkirtBrimGroup::Brim& brim : print.skirt_brim_groups()[group_idx].brims)
            if (std::find(brim.instances.begin(), brim.instances.end(), object_instance_id) != brim.instances.end())
                gcode += emit_brim(brim.brim, brim.instances, brim.filament_id);
        return gcode;
    }
 
    return {};
}

References Slic3r::active_bed_exclude_volume_mode(), config(), Slic3r::Print::default_region_config(), extrude_entity(), Slic3r::find_skirt_brim_group_idx(), Slic3r::has_bed_exclude_volumes(), Slic3r::Layer::id(), m_avoid_crossing_perimeters, m_belt_floor_object, m_config, m_objsWithBrim, NOZZLE_CONFIG, Slic3r::offset(), on_set_origin(), Print, set_origin(), Slic3r::Shared, Slic3r::Print::skirt_brim_groups(), and Slic3r::unscale().

Here is the call graph for this function:

generate_object_skirt_group()

std::string Slic3r::GCode::generate_object_skirt_group ( const Print & print, const PrintObject & object, size_t instance_id, const LayerTools & layer_tools, const Layer & layer, unsigned int extruder_id )

protectedinherited

{
    if (print.config().skirt_type != stPerObject || !layer_tools.has_skirt || print.skirt_brim_groups().empty())
        return {};
 
    const size_t group_idx = find_skirt_brim_group_idx(print, object.id(), instance_id);
    if (group_idx == size_t(-1) || print.skirt_brim_groups()[group_idx].skirt.empty())
        return {};
 
    LayerTools object_skirt_tools = layer_tools;
    object_skirt_tools.extruders  = { extruder_id };
    object_skirt_tools.has_skirt  = true;
 
    return generate_skirt(print, print.skirt_brim_groups()[group_idx].skirt, Point(0, 0), object.config().skirt_start_angle,
                          object_skirt_tools, layer, extruder_id, m_skirt_group_done[group_idx]);
}

References config(), Slic3r::Print::config(), Slic3r::LayerTools::extruders, Slic3r::find_skirt_brim_group_idx(), generate_skirt(), Slic3r::LayerTools::has_skirt, layer(), m_skirt_group_done, Print, Slic3r::Print::skirt_brim_groups(), and Slic3r::stPerObject.

Here is the call graph for this function:

generate_skirt()

std::string Slic3r::GCode::generate_skirt ( const Print & print, const ExtrusionEntityCollection & skirt, const Point & offset, const float skirt_start_angle, const LayerTools & layer_tools, const Layer & layer, unsigned int extruder_id, std::vector< coordf_t > & skirt_done )

protectedinherited

{
    
    bool first_layer = (layer.id() == 0 && abs(layer.bottom_z()) < EPSILON);
    std::string gcode;
    // Extrude skirt at the print_z of the raft layers and normal object layers
    // not at the print_z of the interlaced support material layers.
    // Map from extruder ID to <begin, end> index of skirt loops to be extruded with that extruder.
    std::map<unsigned int, std::pair<size_t, size_t>> skirt_loops_per_extruder;
    skirt_loops_per_extruder = first_layer ?
        Skirt::make_skirt_loops_per_extruder_1st_layer(print, skirt, layer_tools, skirt_done) :
        Skirt::make_skirt_loops_per_extruder_other_layers(print, skirt, layer_tools, skirt_done);
 
    if (auto loops_it = skirt_loops_per_extruder.find(extruder_id); loops_it != skirt_loops_per_extruder.end()) {
        const std::pair<size_t, size_t> loops = loops_it->second;
       
        set_origin(unscaled(offset));
 
        m_avoid_crossing_perimeters.use_external_mp();
        Flow layer_skirt_flow = print.skirt_flow().with_height(float(skirt_done.back() - (skirt_done.size() == 1 ? 0. : skirt_done[skirt_done.size() - 2])));
        double mm3_per_mm = layer_skirt_flow.mm3_per_mm();
        // Decide where to start looping:
        // - If it’s the first layer or if we do NOT want a single-wall skirt/draft shield,
        //   start from loops.first (all loops).
        // - Otherwise, if single_loop_draft_shield == true (and not the first layer),
        //   start from loops.second - 1 (just one loop).
        const size_t start_idx = (first_layer || !print.m_config.single_loop_draft_shield)
                                 ? loops.first
                                 : (loops.second - 1);
 
        // Loop over the skirt loops and extrude
        for (size_t i = start_idx; i < loops.second; ++i) {
            // Adjust flow according to this layer's layer height.
            ExtrusionLoop loop = *dynamic_cast<const ExtrusionLoop*>(skirt.entities[i]);
            for (ExtrusionPath &path : loop.paths) {
                path.height = layer_skirt_flow.height();
                path.mm3_per_mm = mm3_per_mm;
            }
 
            //FIXME using the support_speed of the 1st object printed.
            if (first_layer && i==loops.first) {
                //set skirt start point location
                const Point desired_start_point = Skirt::find_start_point(loop, skirt_start_angle);
                gcode += this->extrude_loop(loop, "skirt", NOZZLE_CONFIG(support_speed), {}, &desired_start_point);
            }
            else
                gcode += this->extrude_loop(loop, "skirt", NOZZLE_CONFIG(support_speed));
 
            // If we only want a single wall on non-first layers, break now
            if (!first_layer && print.m_config.single_loop_draft_shield) {
                break;
            }
        }
        m_avoid_crossing_perimeters.use_external_mp(false);
        // Allow a straight travel move to the first object point if this is the first layer (but don't in next layers).
        if (first_layer && loops.first == 0)
            m_avoid_crossing_perimeters.disable_once();
    }
    return gcode;
}

References Slic3r::ExtrusionEntityCollection::entities, EPSILON, extrude_loop(), Slic3r::Skirt::find_start_point(), Slic3r::ExtrusionPath::height, Slic3r::Flow::height(), layer(), m_avoid_crossing_perimeters, Slic3r::Print::m_config, Slic3r::Skirt::make_skirt_loops_per_extruder_1st_layer(), Slic3r::Skirt::make_skirt_loops_per_extruder_other_layers(), Slic3r::ExtrusionPath::mm3_per_mm, Slic3r::Flow::mm3_per_mm(), NOZZLE_CONFIG, Slic3r::offset(), Slic3r::ExtrusionLoop::paths, Print, set_origin(), Slic3r::Print::skirt_flow(), Slic3r::unscaled(), and Slic3r::Flow::with_height().

Referenced by generate_object_skirt_group().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_timelapse_gcode()

std::string Slic3r::GCode::generate_timelapse_gcode ( const Print & print, coordf_t print_z, int most_used_extruder, const std::set< size_t > * layer_object_label_ids, const std::vector< const PrintObject * > * printed_objects, bool skip_pos_pick = false )

protectedinherited

{
    if (!m_writer.filament())
        return {};
 
    std::string timelapse_gcode;
    if (!print.config().time_lapse_gcode.value.empty()) {
        const DynamicConfig config = timelapse_gcode_config(print, print_z, most_used_extruder, printed_objects, skip_pos_pick);
        timelapse_gcode = this->placeholder_parser_process("time_lapse_gcode", print.config().time_lapse_gcode.value, m_writer.filament()->id(), &config) + "\n";
    }
 
    if (!timelapse_gcode.empty()) {
        m_writer.set_current_position_clear(false);
 
        double temp_z_after_tool_change;
        if (GCodeProcessor::get_last_z_from_gcode(timelapse_gcode, temp_z_after_tool_change)) {
            Vec3d pos = m_writer.get_position();
            pos(2)    = temp_z_after_tool_change;
            m_writer.set_position(pos);
        }
    }
 
    // (layer_object_label_ids->size() < 64) this restriction comes from _encode_label_ids_to_base64()
    if (layer_object_label_ids &&
        is_BBL_Printer() &&
        (print.num_object_instances() <= g_max_label_object) && // Don't support too many objects on one plate
        (print.num_object_instances() > 1) &&                 // Don't support skipping single object
        (!layer_object_label_ids->empty()) &&
        (print.calib_params().mode == CalibMode::Calib_None)) {
        std::ostringstream oss;
        for (auto it = layer_object_label_ids->begin(); it != layer_object_label_ids->end(); ++it) {
            if (it != layer_object_label_ids->begin()) oss << ",";
            oss << *it;
        }
 
        std::string start_str = std::string("; object ids of layer ") + std::to_string(m_layer_index + 1) + (" start: ") + oss.str() + "\n";
        start_str += "M624 " + _encode_label_ids_to_base64(std::vector<size_t>(layer_object_label_ids->begin(), layer_object_label_ids->end())) + "\n";
 
        std::string end_str = std::string("; object ids of this layer") + std::to_string(m_layer_index + 1) + (" end: ") + oss.str() + "\n";
        end_str   += "M625\n";
 
        timelapse_gcode = start_str + timelapse_gcode + end_str;
    }
 
    return timelapse_gcode;
}

References _encode_label_ids_to_base64(), Slic3r::Calib_None, Slic3r::Print::calib_params(), config(), Slic3r::Print::config(), Slic3r::g_max_label_object, Slic3r::GCodeProcessor::get_last_z_from_gcode(), is_BBL_Printer(), m_layer_index, m_writer, Slic3r::Calib_Params::mode, Slic3r::Print::num_object_instances(), placeholder_parser_process(), Print, and timelapse_gcode_config().

Referenced by _extrude().

Here is the call graph for this function:

Here is the caller graph for this function:

get_bed_temperature()

int Slic3r::GCode::get_bed_temperature ( const int extruder_id, const bool is_first_layer, const BedType bed_type ) const

protectedinherited

{
    std::string bed_temp_key = is_first_layer ? get_bed_temp_1st_layer_key(bed_type) : get_bed_temp_key(bed_type);
    const ConfigOptionInts* bed_temp_opt = m_config.option<ConfigOptionInts>(bed_temp_key);
    return bed_temp_opt->get_at(extruder_id);
}

References Slic3r::ConfigOptionVector< int >::get_at(), Slic3r::get_bed_temp_1st_layer_key(), Slic3r::get_bed_temp_key(), and m_config.

Referenced by _do_export(), _print_first_layer_bed_temperature(), get_highest_bed_temperature(), and process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

get_extruder_id()

size_t Slic3r::GCode::get_extruder_id ( unsigned int filament_id ) const

protectedinherited

{
    if (m_print) {
        return m_print->get_extruder_id(filament_id);
    }
    return 0;
}

References m_print.

Referenced by _do_export(), _extrude(), Slic3r::WipeTowerIntegration::append_tcr(), compute_farthest_point(), cur_extruder_index(), get_nozzle_config_index(), and set_extruder().

Here is the caller graph for this function:

get_filament_config_index() [1/2]

size_t Slic3r::GCode::get_filament_config_index ( int filament_id ) const

inherited

{
    if (m_print)
        return m_filament_index_cache.get(filament_id, m_cur_layer_idx, m_print->config_index_generation(),
                                          [&] { return m_print->get_filament_config_indx(filament_id, m_cur_layer_idx); });
    // Orca: without a Print the filament-indexed arrays are unexpanded, so the
    // filament id itself is the only meaningful column.
    return filament_id;
}

References m_cur_layer_idx, m_filament_index_cache, and m_print.

Referenced by _do_export(), _extrude(), Slic3r::OozePrevention::_get_temp(), _print_first_layer_extruder_temperatures(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), do_export(), process_layer(), set_extruder(), set_filament_pressure_advance(), update_placeholder_parser_with_variant_params(), and Slic3r::Wipe::wipe().

Here is the caller graph for this function:

get_filament_config_index() [2/2]

size_t Slic3r::GCode::get_filament_config_index ( int filament_id, size_t layer_id ) const

inherited

{
    // Orca: uncached, as the stages after the generator run concurrently with it.
    return m_print ? m_print->get_filament_config_indx(filament_id, (int) layer_id, false) : filament_id;
}

References layer_id(), and m_print.

Here is the call graph for this function:

get_highest_bed_temperature()

int Slic3r::GCode::get_highest_bed_temperature ( const bool is_first_layer, const Print & print ) const

protectedinherited

{
    auto bed_type = m_config.curr_bed_type;
    int bed_temp = 0;
    // Only the filaments printed on the first layer touch the bed, so a filament that starts higher up, such as a
    // support interface, must not raise the bed temperature for the rest of the print.
    for (auto fidx : print.get_slice_used_filaments(true)) {
        bed_temp = std::max(bed_temp, get_bed_temperature(fidx, is_first_layer, bed_type));
    }
    return bed_temp;
}

References get_bed_temperature(), Slic3r::Print::get_slice_used_filaments(), m_config, and Print.

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_nozzle_config_index()

size_t Slic3r::GCode::get_nozzle_config_index ( int filament_id ) const

inherited

{
    if (m_print)
        return m_nozzle_index_cache.get(filament_id, m_cur_layer_idx, m_print->config_index_generation(),
                                        [&] { return m_print->get_nozzle_config_index(filament_id, m_cur_layer_idx); });
    // Orca: same reasoning; degenerate to the filament's extruder column.
    return get_extruder_id(filament_id);
}

References get_extruder_id(), m_cur_layer_idx, m_nozzle_index_cache, and m_print.

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

Here is the call graph for this function:

Here is the caller graph for this function:

init_belt_writer()

void Slic3r::BeltGCode::init_belt_writer ( Print & print )

overrideprotectedvirtual

Reimplemented from Slic3r::GCode.

{
    // Axis remap and build volume max are set by base GCode after init_belt_writer
    // returns; set_kinematics() replays them, so install order does not matter.
    install_belt_kinematics(m_writer, print.config());
    m_writer.set_force_normal_lift(true);
}

References Slic3r::Print::config(), Slic3r::install_belt_kinematics(), Slic3r::GCode::m_writer, and Slic3r::GCode::Print.

Here is the call graph for this function:

instance_name()

const std::string & Slic3r::GCode::instance_name ( const PrintInstance & instance )

protectedinherited

{
    auto [it, inserted] = m_instance_names.try_emplace(&instance);
    if (inserted)
        it->second = get_instance_name(instance.print_object, instance.id);
    return it->second;
}

References Slic3r::get_instance_name(), Slic3r::PrintInstance::id, m_instance_names, and Slic3r::PrintInstance::print_object.

Referenced by set_object_info().

Here is the call graph for this function:

Here is the caller graph for this function:

interpolate_value_across_layers()

float Slic3r::GCode::interpolate_value_across_layers ( float start_value, float end_value, float step = 0.0f ) const

inherited

{
    float ratio;
    // ORCA-Belt: counter-rotated calibration objects stand on a support wedge,
    // so support-only layers below the object would stretch a layer-index
    // interpolation. Use the object's own Z span instead, so the value ramps
    // across the test geometry only.
    if (m_config.belt_printer.value && m_layer != nullptr && !m_layer->object()->layers().empty()) {
        const auto& layers = m_layer->object()->layers();
        // Skip empty ghost layers the grid may produce below the object.
        double z_min = layers.front()->print_z;
        for (const Layer* l : layers)
            if (!l->lslices.empty()) { z_min = l->print_z; break; }
        const double z_max = layers.back()->print_z;
        if (m_layer->print_z <= z_min + EPSILON || z_max - z_min <= EPSILON)
            return start_value;
        ratio = float(std::min(1.0, (m_layer->print_z - z_min) / (z_max - z_min)));
    } else if (m_layer_index <= 1) {
        return start_value;
    } else {
        ratio = m_layer_index / (m_layer_count - 1.f);
    }
    if (step > 0.f) {
        // Discrete equal-width bands. band is clamped to the last band so the result can't overshoot the range:
        // at the top layer ratio * n_bands == n_bands, which would otherwise index one band past the end.
        const int n_bands = std::lround(std::abs(end_value - start_value) / step) + 1;
        const int band    = std::min(n_bands - 1, static_cast<int>(ratio * n_bands));
        return start_value + (end_value >= start_value ? 1.f : -1.f) * band * step;
    }
    return start_value + ratio * (end_value - start_value);
}

References EPSILON, m_config, m_layer, m_layer_count, and m_layer_index.

Referenced by process_layer().

Here is the caller graph for this function:

is_BBL_Printer()

bool Slic3r::GCode::is_BBL_Printer ( )

inherited

{
    if (m_curr_print)
        return m_curr_print->is_BBL_printer();
    return false;
}

References m_curr_print.

Referenced by generate_timelapse_gcode(), and process_layer().

Here is the caller graph for this function:

last_pos()

Point Slic3r::GCode::last_pos ( ) const

inlineinherited

{ return m_last_pos.to_point(); }

References m_last_pos.

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

Here is the caller graph for this function:

last_pos_defined()

bool Slic3r::GCode::last_pos_defined ( ) const

inlineprotectedinherited

{ return m_last_pos_defined; }

References m_last_pos_defined.

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

Here is the caller graph for this function:

layer()

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

inlineinherited

{ return m_layer; }

References m_layer.

Referenced by _do_export(), Slic3r::OozePrevention::_get_temp(), Slic3r::belt_object_layer_prints_something(), generate_object_skirt_group(), generate_skirt(), Slic3r::GCode::ConfigIndexCache::get(), needs_retraction(), Slic3r::OozePrevention::pre_toolchange(), Slic3r::precompute_overhang_layers(), Slic3r::precomputed_layers_source(), Slic3r::prepares_overhang_estimator(), process_layer(), process_layers(), Slic3r::set_mass_locator(), timelapse_gcode_config(), and Slic3r::AvoidCrossingPerimeters::travel_to().

Here is the caller graph for this function:

layer_count()

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

inlineinherited

{ return m_layer_count; }

References m_layer_count.

Referenced by Slic3r::precomputed_layers_source().

Here is the caller graph for this function:

layer_id()

int Slic3r::GCode::layer_id ( ) const

inlineprotectedinherited

                         {
        if (m_layer == nullptr)
            return -1;
        return m_layer->id();
    }

References m_layer.

Referenced by effective_layer_index_for_point(), extrude_loop(), get_filament_config_index(), process_layer(), sort_print_object_instances(), and update_layer_related_config().

Here is the caller graph for this function:

mass_load_limited_machine_acceleration()

void Slic3r::GCode::mass_load_limited_machine_acceleration ( const PrintStatistics & curr_print_statistics, const Print & print, double & y_acceleration_limit_res, double & accumulated_mass_res )

protectedinherited

{
    double curr_acceleration_y_config = 1e10;
    auto  &machine_max_acceleration_y = print.config().machine_max_acceleration_y.values;
    for (auto &temp : machine_max_acceleration_y)
        if (curr_acceleration_y_config > temp) curr_acceleration_y_config = temp;
    accumulated_mass_res = curr_print_statistics.total_weight;
    // mass in g, acceleration in mm/s2
    double machine_max_force_Y = print.config().machine_max_force_Y.getFloat(),
        machine_bed_mass_Y = print.config().machine_bed_mass_Y.getFloat();
    if (machine_max_force_Y > EPSILON && machine_bed_mass_Y > EPSILON) {
        // This item is not applicable to this printer  FIXME-other printers need acceleration limit?
        double virtual_force_g_mms2 = machine_max_force_Y * 1e6,  // x N =x * 1e6 g*mm/s2
            curr_acceleration_temp  = curr_acceleration_y_config; // temps
        if (accumulated_mass_res > EPSILON) {
            curr_acceleration_temp = virtual_force_g_mms2 / (machine_bed_mass_Y + accumulated_mass_res);
            y_acceleration_limit_res = std::min(curr_acceleration_temp, curr_acceleration_y_config);
        } else {
            y_acceleration_limit_res = curr_acceleration_y_config;
            BOOST_LOG_TRIVIAL(info) << "mass_load_limited_machine_acceleration: Printed mass not detected";
        }
    } else {
        y_acceleration_limit_res = curr_acceleration_y_config;
    }
}

References Slic3r::Print::config(), EPSILON, Print, and Slic3r::PrintStatistics::total_weight.

Referenced by process_layer_change_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

needs_retraction()

bool Slic3r::GCode::needs_retraction ( const Polyline & travel, ExtrusionRole role, LiftType & lift_type )

inherited

{
    if (travel.length() < scale_(FILAMENT_CONFIG(retraction_minimum_travel))) {
        // skip retraction if the move is shorter than the configured threshold
        return false;
    }
 
    //BBS: input travel polyline must be in current plate coordinate system
    auto is_through_overhang = [this](const Polyline& travel) {
        BoundingBox travel_bbox = get_extents(travel);
        travel_bbox.inflated(1);
        travel_bbox.defined = true;
 
        // do not scale for z
        const float protect_z = 0.4;
        std::pair<float, float> z_range;
        z_range.second = m_layer ? m_layer->print_z : 0.f;
        z_range.first = std::max(0.f, z_range.second - protect_z);
        std::vector<LayerPtrs> layers_of_objects;
        std::vector<BoundingBox> boundingBox_for_objects;
        VecOfPoints objects_instances_shift;
        std::vector<size_t> idx_of_object_sorted = m_curr_print->layers_sorted_for_object(z_range.first, z_range.second, layers_of_objects, boundingBox_for_objects, objects_instances_shift);
 
        std::vector<bool> is_layers_of_objects_sorted(layers_of_objects.size(), false);
 
        for (size_t idx : idx_of_object_sorted) {
            for (const Point & instance_shift : objects_instances_shift[idx]) {
                BoundingBox instance_bbox = boundingBox_for_objects[idx];
                if (!instance_bbox.defined)  //BBS: Don't need to check when bounding box of overhang area is empty(undefined)
                    continue;
 
                instance_bbox.offset(scale_(EPSILON));
                instance_bbox.translate(instance_shift.x(), instance_shift.y());
                if (!instance_bbox.overlap(travel_bbox))
                    continue;
 
                Polygons temp;
                temp.emplace_back(instance_bbox.polygon());
                if (intersection_pl(travel, temp).empty())
                    continue;
 
                if (!is_layers_of_objects_sorted[idx]) {
                    std::sort(layers_of_objects[idx].begin(), layers_of_objects[idx].end(), [](auto left, auto right) { return left->loverhangs_bbox.area() > right->loverhangs_bbox.area();});
                    is_layers_of_objects_sorted[idx] = true;
                }
 
                for (const auto& layer : layers_of_objects[idx]) {
                    for (ExPolygon overhang : layer->loverhangs) {
                        overhang.translate(instance_shift);
                        BoundingBox bbox1 = get_extents(overhang);
 
                        if (!bbox1.overlap(travel_bbox))
                            continue;
 
                        if (intersection_pl(travel, overhang).empty())
                            continue;
 
                        return true;
                    }
                }
            }
        }
        return false;
    };
 
    float max_z_hop = 0.f;
    for (int i = 0; i < m_config.z_hop.size(); i++)
        max_z_hop = std::max(max_z_hop, (float)m_config.z_hop.get_at(i));
    float travel_len_thresh = scale_(max_z_hop / tan(this->writer().filament()->travel_slope()));
    float accum_len = 0.f;
    Polyline clipped_travel;
 
    clipped_travel.append(Polyline(travel.points[0], travel.points[1]));
    if (clipped_travel.length() > travel_len_thresh)
        clipped_travel.points.back() = clipped_travel.points.front()+(clipped_travel.points.back() - clipped_travel.points.front()) * (travel_len_thresh / clipped_travel.length());
    //BBS: translate to current plate coordinate system
    clipped_travel.translate(Point::new_scale(double(m_origin.x() - m_writer.get_xy_offset().x()), double(m_origin.y() - m_writer.get_xy_offset().y())));
 
    //BBS: force to retract when leave from external perimeter for a long travel
    //Better way is judging whether the travel move direction is same with last extrusion move.
    if (is_perimeter(m_last_processor_extrusion_role) && m_last_processor_extrusion_role != erPerimeter) {
        if (ZHopType(FILAMENT_CONFIG(z_hop_types)) == ZHopType::zhtAuto) {
            lift_type = is_through_overhang(clipped_travel) ? LiftType::SpiralLift : LiftType::SlopeLift;
        }
        else {
            lift_type = to_lift_type(ZHopType(FILAMENT_CONFIG(z_hop_types)));
        }
        return true;
    }
 
    if (role == erSupportMaterial || role == erSupportTransition) {
        const SupportLayer* support_layer = dynamic_cast<const SupportLayer*>(m_layer);
        //FIXME support_layer->support_islands.contains should use some search structure!
        if (support_layer != NULL)
            // skip retraction if this is a travel move inside a support material island
            //FIXME not retracting over a long path may cause oozing, which in turn may result in missing material
            // at the end of the extrusion path!
            for (const ExPolygon& support_island : support_layer->support_islands)
                if (support_island.contains(travel))
                    return false;
        //reduce the retractions in lightning infills for tree support
        if (support_layer != NULL && support_layer->support_type==stInnerTree)
            for (auto &area : support_layer->base_areas)
                if (area.contains(travel))
                    return false;
    }
    //BBS: need retract when long moving to print perimeter to avoid dropping of material
    if (!is_perimeter(role) && m_config.reduce_infill_retraction && m_layer != nullptr &&
        m_config.sparse_infill_density.value > 0 && m_retract_when_crossing_perimeters.travel_inside_internal_regions(*m_layer, travel))
        // Skip retraction if travel is contained in an internal slice *and*
        // internal infill is enabled (so that stringing is entirely not visible).
        //FIXME any_internal_region_slice_contains() is potentionally very slow, it shall test for the bounding boxes first.
        return false;
 
    // retract if reduce_infill_retraction is disabled or doesn't apply when role is perimeter
    if (ZHopType(FILAMENT_CONFIG(z_hop_types)) == ZHopType::zhtAuto) {
        lift_type = is_through_overhang(clipped_travel) ? LiftType::SpiralLift : LiftType::SlopeLift;
    }
    else {
        lift_type = to_lift_type(ZHopType(FILAMENT_CONFIG(z_hop_types)));
    }
    return true;
}

References Slic3r::Polyline::append(), Slic3r::area(), Slic3r::SupportLayer::base_areas, Slic3r::ExPolygon::contains(), Slic3r::BoundingBoxBase< PointType, APointsType >::defined, Slic3r::empty(), EPSILON, Slic3r::erPerimeter, Slic3r::erSupportMaterial, Slic3r::erSupportTransition, FILAMENT_CONFIG, Slic3r::get_extents(), Slic3r::BoundingBox::inflated(), Slic3r::intersection_pl(), Slic3r::is_perimeter(), layer(), Slic3r::MultiPoint::length(), m_config, m_curr_print, m_last_processor_extrusion_role, m_layer, m_origin, m_retract_when_crossing_perimeters, m_writer, Slic3r::Point::new_scale(), Slic3r::BoundingBoxBase< PointType, APointsType >::offset(), Slic3r::BoundingBoxBase< PointType, APointsType >::overlap(), Slic3r::MultiPoint::points, Slic3r::BoundingBox::polygon(), scale_, Slic3r::SlopeLift, Slic3r::SpiralLift, Slic3r::stInnerTree, Slic3r::SupportLayer::support_islands, Slic3r::SupportLayer::support_type, to_lift_type(), Slic3r::BoundingBoxBase< PointType, APointsType >::translate(), Slic3r::ExPolygon::translate(), Slic3r::MultiPoint::translate(), Slic3r::travel_slope(), writer(), and Slic3r::zhtAuto.

Referenced by travel_to().

Here is the call graph for this function:

Here is the caller graph for this function:

object_layer_over_raft()

bool Slic3r::GCode::object_layer_over_raft ( ) const

inlineprotectedinherited

{ return m_object_layer_over_raft; }

References m_object_layer_over_raft.

Referenced by _extrude().

Here is the caller graph for this function:

on_first_layer() [1/2]

bool Slic3r::GCode::on_first_layer ( ) const

inlineprotectedinherited

{ return m_layer != nullptr && m_layer->id() == 0 && abs(m_layer->bottom_z()) < EPSILON; }

References EPSILON, and m_layer.

Referenced by _do_export(), _extrude(), _needSAFC(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), effective_layer_index_for_point(), on_first_layer(), retract(), set_extruder(), and travel_to().

Here is the caller graph for this function:

on_first_layer() [2/2]

bool Slic3r::GCode::on_first_layer ( const Vec3d & point_slicing_mm ) const

inlineprotectedinherited

                                                             {
        double h;
        if (this->belt_height_above_floor(point_slicing_mm, h))
            return h <= m_config.initial_layer_print_height.value + EPSILON;
        return on_first_layer();
    }

References belt_height_above_floor(), EPSILON, m_config, and on_first_layer().

Here is the call graph for this function:

on_set_origin()

void Slic3r::BeltGCode::on_set_origin ( const PrintObject * obj, const Point & inst_shift )

overrideprotectedvirtual

Reimplemented from Slic3r::GCode.

{
    // Matches the per-instance Z-offset added in PrintObjectSlice.cpp: transform
    // the origin through the belt pipeline so that back_transform(T * origin) =
    // origin (correct machine position). The back_transform applied during
    // G-code emission is the inverse of the forward transform.
 
    // Adjust origin: transform through belt forward pipeline so that
    // the back-transform correctly recovers model-space positions.
    Transform3d T = BeltTransformPipeline::build_forward_transform(m_config);
    Vec2d cur_origin = this->origin();
    Vec3d origin3d(cur_origin.x(), cur_origin.y(), 0.);
    Vec3d adjusted = T.linear() * origin3d;
    this->set_origin(Vec2d(adjusted.x(), adjusted.y()));
}

References Slic3r::BeltTransformPipeline::build_forward_transform(), Slic3r::GCode::m_config, Slic3r::GCode::origin(), and Slic3r::GCode::set_origin().

Here is the call graph for this function:

origin()

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

inlineinherited

{ return m_origin; }

References m_origin.

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

Here is the caller graph for this function:

placeholder_parser() [1/2]

PlaceholderParser & Slic3r::GCode::placeholder_parser ( )

inlineinherited

{ return m_placeholder_parser_integration.parser; }

References m_placeholder_parser_integration.

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

Here is the caller graph for this function:

placeholder_parser() [2/2]

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

inlineinherited

{ return m_placeholder_parser_integration.parser; }

References m_placeholder_parser_integration.

placeholder_parser_process()

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

inherited

{
    // Orca: Added CMake config option since debug is rarely used in current workflow.
    // Also changed from throwing error immediately to storing messages till slicing is completed
    // to raise all errors at the same time.
#if ORCA_CHECK_GCODE_PLACEHOLDERS
    if (config_override) {
        const auto& custom_gcode_placeholders = custom_gcode_specific_placeholders();
 
        // 1-st check: custom G-code "name" have to be present in s_CustomGcodeSpecificPlaceholders;
        //if (custom_gcode_placeholders.count(name) > 0) {
        //    const auto& placeholders = custom_gcode_placeholders.at(name);
        if (auto it = custom_gcode_placeholders.find(name); it != custom_gcode_placeholders.end()) {
            const auto& placeholders = it->second;
 
            for (const std::string& key : config_override->keys()) {
                // 2-nd check: "key" have to be present in s_CustomGcodeSpecificPlaceholders for "name" custom G-code ;
                if (std::find(placeholders.begin(), placeholders.end(), key) == placeholders.end()) {
                    auto& vector = m_placeholder_error_messages[name + " - option not specified for custom gcode type (s_CustomGcodeSpecificPlaceholders)"];
                    if (std::find(vector.begin(), vector.end(), key) == vector.end())
                        vector.emplace_back(key);
                }
                // 3-rd check: "key" have to be present in CustomGcodeSpecificConfigDef for "key" placeholder;
                if (!custom_gcode_specific_config_def.has(key)) {
                    auto& vector = m_placeholder_error_messages[name + " - option has no definition (CustomGcodeSpecificConfigDef)"];
                    if (std::find(vector.begin(), vector.end(), key) == vector.end())
                        vector.emplace_back(key);
                }
            }
        }
        else {
            auto& vector = m_placeholder_error_messages[name + " - gcode type not found in s_CustomGcodeSpecificPlaceholders"];
            if (vector.empty())
                vector.emplace_back("");
        }
    }
#endif
 
PlaceholderParserIntegration &ppi = m_placeholder_parser_integration;
    try {
        ppi.update_from_gcodewriter(m_writer);
        std::string output = ppi.parser.process(templ, current_filament_id, config_override, &ppi.output_config, &ppi.context);
        ppi.validate_output_vector_variables();
        const CustomGCodeMotionStateChanges motion_state_changes = custom_gcode_motion_state_changes(output);
        if (motion_state_changes.acceleration)
            m_writer.invalidate_acceleration();
        if (motion_state_changes.jerk)
            m_writer.invalidate_jerk();
 
        if (const std::vector<double> &pos = ppi.opt_position->values; ppi.position != pos) {
            // Update G-code writer.
            m_writer.set_position({ pos[0], pos[1], pos[2] });
            this->set_last_pos(this->gcode_to_point({ pos[0], pos[1] }));
        }
 
        for (const Extruder &e : m_writer.extruders()) {
            unsigned int eid = e.id();
            assert(eid < ppi.num_extruders);
            if ( eid < ppi.num_extruders) {
                if (! m_writer.config.use_relative_e_distances && ! is_approx(ppi.e_position[eid], ppi.opt_e_position->values[eid]))
                    const_cast<Extruder&>(e).set_position(ppi.opt_e_position->values[eid]);
                if (! is_approx(ppi.e_retracted[eid], ppi.opt_e_retracted->values[eid]) || 
                    ! is_approx(ppi.e_restart_extra[eid], ppi.opt_e_restart_extra->values[eid]))
                    const_cast<Extruder&>(e).set_retracted(ppi.opt_e_retracted->values[eid], ppi.opt_e_restart_extra->values[eid]);
            }
        }
 
        return output;
    } 
    catch (std::runtime_error &err) 
    {
        // Collect the names of failed template substitutions for error reporting.
        auto it = ppi.failed_templates.find(name);
        if (it == ppi.failed_templates.end())
            // Only if there was no error reported for this template, store the first error message into the map to be reported.
            // We don't want to collect error message for each and every occurence of a single custom G-code section.
            ppi.failed_templates.insert(it, std::make_pair(name, std::string(err.what())));
        // Insert the macro error message into the G-code.
        return
            std::string("\n!!!!! Failed to process the custom G-code template ") + name + "\n" +
            err.what() +
            "!!!!! End of an error report for the custom G-code template " + name + "\n\n";
    }
}

References Slic3r::CustomGCodeMotionStateChanges::acceleration, Slic3r::GCode::PlaceholderParserIntegration::context, Slic3r::custom_gcode_motion_state_changes(), Slic3r::custom_gcode_specific_config_def, Slic3r::custom_gcode_specific_placeholders(), Slic3r::GCode::PlaceholderParserIntegration::e_position, Slic3r::GCode::PlaceholderParserIntegration::e_restart_extra, Slic3r::GCode::PlaceholderParserIntegration::e_retracted, Slic3r::GCode::PlaceholderParserIntegration::failed_templates, gcode_to_point(), Slic3r::is_approx(), Slic3r::CustomGCodeMotionStateChanges::jerk, Slic3r::DynamicConfig::keys(), m_placeholder_parser_integration, m_writer, Slic3r::GCode::PlaceholderParserIntegration::num_extruders, Slic3r::GCode::PlaceholderParserIntegration::opt_e_position, Slic3r::GCode::PlaceholderParserIntegration::opt_e_restart_extra, Slic3r::GCode::PlaceholderParserIntegration::opt_e_retracted, Slic3r::GCode::PlaceholderParserIntegration::opt_position, Slic3r::GCode::PlaceholderParserIntegration::output_config, Slic3r::GCode::PlaceholderParserIntegration::parser, Slic3r::GCode::PlaceholderParserIntegration::position, Slic3r::PlaceholderParser::process(), set_last_pos(), Slic3r::GCode::PlaceholderParserIntegration::update_from_gcodewriter(), Slic3r::GCode::PlaceholderParserIntegration::validate_output_vector_variables(), and Slic3r::ConfigOptionVector< double >::values.

Referenced by _do_export(), _extrude(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), Slic3r::ProcessLayer::emit_custom_gcode_per_print_z(), generate_timelapse_gcode(), process_belt_brim_layer(), process_layer(), process_layer_change_gcode(), and set_extruder().

Here is the call graph for this function:

Here is the caller graph for this function:

point_to_gcode() [1/2]

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

inherited

{
    Vec2d extruder_offset = EXTRUDER_CONFIG(extruder_offset);
    return unscale(point) + m_origin - extruder_offset;
}

References EXTRUDER_CONFIG, Slic3r::extruder_offset(), m_origin, and Slic3r::unscale().

Referenced by _extrude(), capture_toolchange_position(), extrude_loop(), point_to_gcode_quantized(), point_to_gcode_quantized(), travel_to(), and Slic3r::Wipe::wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

point_to_gcode() [2/2]

Vec3d Slic3r::GCode::point_to_gcode ( const Point3 & point ) const

inherited

{
    Vec2d extruder_offset = EXTRUDER_CONFIG(extruder_offset);
    Vec2d xy              = unscale(point.to_point()) + m_origin - extruder_offset;
    return Vec3d(xy.x(), xy.y(), unscale_(point.z()));
}

References EXTRUDER_CONFIG, Slic3r::extruder_offset(), m_origin, Slic3r::Point3::to_point(), Slic3r::unscale(), and unscale_.

Here is the call graph for this function:

point_to_gcode_quantized() [1/2]

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

inherited

{
    Vec2d p = this->point_to_gcode(point);
    const bool high_precision = m_writer.high_precision();
    return { GCodeFormatter::quantize_xyz(p.x(), high_precision), GCodeFormatter::quantize_xyz(p.y(), high_precision) };
}

References m_writer, point_to_gcode(), and Slic3r::GCodeFormatter::quantize_xyz().

Referenced by _extrude().

Here is the call graph for this function:

Here is the caller graph for this function:

point_to_gcode_quantized() [2/2]

Vec3d Slic3r::GCode::point_to_gcode_quantized ( const Point3 & point ) const

inherited

{
    Vec3d p = this->point_to_gcode(point);
    const bool high_precision = m_writer.high_precision();
    return { GCodeFormatter::quantize_xyz(p.x(), high_precision), GCodeFormatter::quantize_xyz(p.y(), high_precision),
             GCodeFormatter::quantize_xyz(p.z(), high_precision) };
}

References m_writer, point_to_gcode(), and Slic3r::GCodeFormatter::quantize_xyz().

Here is the call graph for this function:

preamble()

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

protectedinherited

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

References m_config, and m_writer.

Referenced by _do_export().

Here is the caller graph for this function:

print_machine_envelope()

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

protectedinherited

{
    const auto flavor = print.config().gcode_flavor.value;
    if ((flavor == gcfMarlinLegacy || flavor == gcfMarlinFirmware || flavor == gcfRepRapFirmware) &&
        print.config().emit_machine_limits_to_gcode.value == true) {
 
        // Get all physical tool ids current print will use
        std::unordered_set<unsigned int> used_extruders;
        for (const auto& extruder : m_writer.extruders()) {
            used_extruders.insert(extruder.extruder_id());
        }
 
        // Get the max limit value among used extruders
        auto get_max_value = [&used_extruders](const std::string key, const ConfigOptionFloats& v) { 
            unsigned int stride = 1;
            if (printer_options_with_variant_2.count(key) > 0) {
                stride = 2;
            }
 
            double value = std::numeric_limits<double>::lowest();
            for (unsigned int extruder : used_extruders) {
                value = std::max(value, v.values[extruder * stride]);
            }
 
            assert(value > std::numeric_limits<double>::lowest());
            return value;
        };
#define MAX_LIMIT(OPT) get_max_value(#OPT, print.config().OPT)
 
        int factor = flavor == gcfRepRapFirmware ? 60 : 1; // RRF M203 and M566 are in mm/min
        file.write_format("M201 X%d Y%d Z%d E%d\n",
            int(MAX_LIMIT(machine_max_acceleration_x) + 0.5),
            int(MAX_LIMIT(machine_max_acceleration_y) + 0.5),
            int(MAX_LIMIT(machine_max_acceleration_z) + 0.5),
            int(MAX_LIMIT(machine_max_acceleration_e) + 0.5));
        file.write_format("M203 X%d Y%d Z%d E%d\n",
            int(MAX_LIMIT(machine_max_speed_x) * factor + 0.5),
            int(MAX_LIMIT(machine_max_speed_y) * factor + 0.5),
            int(MAX_LIMIT(machine_max_speed_z) * factor + 0.5),
            int(MAX_LIMIT(machine_max_speed_e) * factor + 0.5));
 
        // Now M204 - acceleration. This one is quite hairy thanks to how Marlin guys care about
        // Legacy Marlin should export travel acceleration the same as printing acceleration.
        // MarlinFirmware has the two separated.
        int travel_acc = flavor == gcfMarlinLegacy
                       ? int(MAX_LIMIT(machine_max_acceleration_extruding) + 0.5)
                       : int(MAX_LIMIT(machine_max_acceleration_travel) + 0.5);
        if (flavor == gcfRepRapFirmware)
            file.write_format("M204 P%d T%d ; sets acceleration (P, T), mm/sec^2\n",
                int(MAX_LIMIT(machine_max_acceleration_extruding) + 0.5),
                travel_acc);
        else if (flavor == gcfMarlinFirmware)
            // New Marlin uses M204 P[print] R[retract] T[travel]
            file.write_format("M204 P%d R%d T%d ; sets acceleration (P, T) and retract acceleration (R), mm/sec^2\n",
                int(MAX_LIMIT(machine_max_acceleration_extruding) + 0.5),
                int(MAX_LIMIT(machine_max_acceleration_retracting) + 0.5),
                int(MAX_LIMIT(machine_max_acceleration_travel) + 0.5));
        else
            file.write_format("M204 P%d R%d T%d\n",
                int(MAX_LIMIT(machine_max_acceleration_extruding) + 0.5),
                int(MAX_LIMIT(machine_max_acceleration_retracting) + 0.5),
                travel_acc);
 
        assert(is_decimal_separator_point());
        file.write_format(flavor == gcfRepRapFirmware
            ? "M566 X%.2lf Y%.2lf Z%.2lf E%.2lf ; sets the jerk limits, mm/min\n"
            : "M205 X%.2lf Y%.2lf Z%.2lf E%.2lf ; sets the jerk limits, mm/sec\n",
            MAX_LIMIT(machine_max_jerk_x) * factor,
            MAX_LIMIT(machine_max_jerk_y) * factor,
            MAX_LIMIT(machine_max_jerk_z) * factor,
            MAX_LIMIT(machine_max_jerk_e) * factor);
 
        // New Marlin uses M205 J[mm] for junction deviation (only apply if it is > 0)
        file.write_format(writer().set_junction_deviation(MAX_LIMIT(machine_max_junction_deviation)).c_str());
 
        // Orca: Override input shaping values
        if (print.config().input_shaping_emit.value && flavor != gcfMarlinLegacy) {
            const bool input_shaping_disable = print.config().input_shaping_type.value == InputShaperType::Disable;
            file.write_format(writer().set_input_shaping('X', print.config().input_shaping_damp_x.value,
                print.config().input_shaping_freq_x.value, print.config().opt_serialize("input_shaping_type")).c_str());
            if (flavor != gcfRepRapFirmware && !input_shaping_disable) {
                file.write_format(writer().set_input_shaping('Y', print.config().input_shaping_damp_y.value,
                    print.config().input_shaping_freq_y.value, "").c_str());
            }
        }
    }
#undef MAX_LIMIT
}

References Slic3r::Print::config(), Slic3r::Disable, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepRapFirmware, Slic3r::is_decimal_separator_point(), m_writer, MAX_LIMIT, Print, Slic3r::printer_options_with_variant_2, Slic3r::GCode::GCodeOutputStream::write_format(), and writer().

Referenced by _do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

process_belt_brim_layer()

LayerResult Slic3r::GCode::process_belt_brim_layer ( const Print & print, const std::vector< LayerToPrint > & layers, const LayerTools & layer_tools, const bool last_layer, const size_t single_object_instance_idx, const int most_used_extruder )

protectedinherited

{
    // layer_id 0 is deliberate, not a placeholder.  CoolingBuffer reads it for the
    // initial_layer_fan_speed override and the close_fan_the_first_x_layers gate
    // (CoolingBuffer.cpp), and every apron band is first-layer material by the only
    // definition that means anything on a belt: it lies on the belt plane itself.  Numbering
    // the bands 1, 2, 3... would ramp the fan up while still printing on the belt.
    // spiral_vase_enable false: spiral vase is refused alongside belt brim in
    // Print::validate().  cooling_buffer_flush true: an apron layer is a complete layer, and
    // the default (object_layer || raft_layer || last_layer) is false here, so fan and
    // slowdown would otherwise never be applied to it.
    LayerResult result { {}, 0, false, true };
    if (layer_tools.extruders.empty())
        // Nothing to extrude.
        return result;
 
    coordf_t print_z = 0.;
    coordf_t height  = 0.;
    for (const LayerToPrint &ltp : layers)
        if (ltp.belt_brim_band != nullptr) {
            print_z = ltp.belt_brim_band->print_z;
            height  = ltp.belt_brim_band->height;
            break;
        }
 
    // Apron bands precede object layer 0 and have no layer id of their own; they take the
    // filament and nozzle assignment in effect at the first object layer.
    m_cur_layer_idx = 0;
 
    // Publish the band's Z for _extrude()'s first-layer-plane probe, and make sure
    // it cannot leak past this layer even if an extrusion throws.
    struct BeltBrimZGuard {
        std::optional<coordf_t> &slot;
        ~BeltBrimZGuard() { slot.reset(); }
    } z_guard { m_belt_brim_z };
    m_belt_brim_z = print_z;
    m_layer = nullptr;
 
    std::string gcode;
    const unsigned int extruder_id = layer_tools.extruders.front();
    if (m_writer.filament() == nullptr || m_writer.filament()->id() != extruder_id)
        gcode += this->set_extruder(extruder_id, print_z);
 
    // An apron band is a real printed layer: it is counted in m_layer_count, it advances
    // m_layer_index through change_layer(), and the G-code viewer needs its Z/height tags.
    // Keep the same caches and hooks the ordinary path maintains, or the first object layer
    // would compute its height against a stale pre-apron Z and layer-change templates would
    // skip these layers entirely.
    {
        char buf[64];
        gcode += ";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Layer_Change) + "\n";
        sprintf(buf, ";Z:%g\n", print_z);
        gcode += buf;
        const float band_height = float(height);
        sprintf(buf, ";%s%g\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height).c_str(), band_height);
        gcode += buf;
        m_last_layer_z = float(print_z);
        m_max_layer_z  = std::max(m_max_layer_z, m_last_layer_z);
        m_last_height  = band_height;
    }
 
    if (! m_config.before_layer_change_gcode.value.empty()) {
        DynamicConfig config;
        config.set_key_value("layer_num",   new ConfigOptionInt(m_layer_index + 1));
        config.set_key_value("layer_z",     new ConfigOptionFloat(print_z));
        config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
        gcode += this->placeholder_parser_process("before_layer_change_gcode",
            print.config().before_layer_change_gcode.value, m_writer.filament()->id(), &config) + "\n";
    }
 
    gcode += this->change_layer(print_z);
 
    if (! m_config.layer_change_gcode.value.empty())
        gcode += this->process_layer_change_gcode(print, print_z, most_used_extruder, layer_tools.has_wipe_tower && m_wipe_tower);
 
    // Objects sharing this apron Z may use different brim filaments; print each in its own tool.
    for (const unsigned int brim_extruder : layer_tools.extruders) {
        if (m_writer.filament() == nullptr || m_writer.filament()->id() != brim_extruder)
            gcode += this->set_extruder(brim_extruder, print_z);
        gcode += this->emit_belt_brim_bands(print, layers, single_object_instance_idx, brim_extruder);
    }
 
    result.gcode = std::move(gcode);
    return result;
}

References change_layer(), config(), Slic3r::Print::config(), Slic3r::ConfigOptionFloat, emit_belt_brim_bands(), Slic3r::LayerTools::extruders, Slic3r::LayerResult::gcode, Slic3r::LayerTools::has_wipe_tower, Slic3r::GCodeProcessor::Height, Slic3r::GCodeProcessor::Layer_Change, m_belt_brim_z, m_config, m_cur_layer_idx, m_last_height, m_last_layer_z, m_layer, m_layer_index, m_max_layer_z, m_wipe_tower, m_writer, placeholder_parser_process(), Print, process_layer_change_gcode(), Slic3r::GCodeProcessor::reserved_tag(), and set_extruder().

Referenced by process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

process_layer()

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

protectedinherited

{
    assert(! layers.empty());
    // Either printing all copies of all objects, or just a single copy of a single object.
    assert(single_object_instance_idx == size_t(-1) || layers.size() == 1);
 
    // First object, support and raft layer, if available.
    const Layer         *object_layer  = nullptr;
    const SupportLayer  *support_layer = nullptr;
    const SupportLayer  *raft_layer    = nullptr;
    for (const LayerToPrint &l : layers) {
        if (l.object_layer && ! object_layer)
            object_layer = l.object_layer;
        if (l.support_layer) {
            if (! support_layer)
                support_layer = l.support_layer;
            if (! raft_layer && support_layer->id() < support_layer->object()->slicing_parameters().raft_layers())
                raft_layer = support_layer;
        }
    }
 
    // Belt printers: a brim-only apron layer has neither an object nor a support
    // layer, so it must be handled before layer_ptr is dereferenced below.
    if (object_layer == nullptr && support_layer == nullptr &&
        std::any_of(layers.begin(), layers.end(),
                    [](const LayerToPrint &l) { return l.belt_brim_band != nullptr; }))
        return this->process_belt_brim_layer(print, layers, layer_tools, last_layer, single_object_instance_idx, most_used_extruder);
 
    const Layer* layer_ptr = nullptr;
    if (object_layer != nullptr)
        layer_ptr = object_layer;
    else if (support_layer != nullptr)
        layer_ptr = support_layer;
    const Layer& layer = *layer_ptr;
    m_cur_layer_idx = layer.id();
    // A per-layer nozzle grouping can move the active filament to another variant column on a
    // layer boundary without a toolchange, so re-resolve the writer's config column here.
    if (Extruder *cur_filament = m_writer.filament())
        cur_filament->set_config_index((int)get_filament_config_index((int)cur_filament->id()));
    LayerResult   result { {}, layer.id(), false, last_layer };
    if (layer_tools.extruders.empty())
        // Nothing to extrude.
        return result;
 
    // Extract 1st object_layer and support_layer of this set of layers with an equal print_z.
    coordf_t             print_z       = layer.print_z;
    //BBS: using layer id to judge whether the layer is first layer is wrong. Because if the normal
    //support is attached above the object, and support layers has independent layer height, then the lowest support
    //interface layer id is 0.
    bool                 first_layer   = (layer.id() == 0 && abs(layer.bottom_z()) < EPSILON);
    m_writer.set_is_first_layer(first_layer);
    unsigned int         first_extruder_id = layer_tools.extruders.front();
 
    // Initialize config with the 1st object to be printed at this layer.
    m_config.apply(layer.object()->config(), true);
 
    // Check whether it is possible to apply the spiral vase logic for this layer.
    // Just a reminder: A spiral vase mode is allowed for a single object, single material print only.
    m_enable_loop_clipping = true;
    if (m_spiral_vase && layers.size() == 1 && support_layer == nullptr) {
        bool enable = (layer.id() > 0 || !print.has_brim()) && (layer.id() >= (size_t)print.config().skirt_height.value && ! print.has_infinite_skirt());
        if (enable) {
            for (const LayerRegion *layer_region : layer.regions())
                if (size_t(layer_region->region().config().bottom_shell_layers.value) > layer.id() ||
                    layer_region->perimeters.items_count() > 1u ||
                    layer_region->fills.items_count() > 0) {
                    enable = false;
                    break;
                }
        }
        result.spiral_vase_enable = enable;
        // If we're going to apply spiralvase to this layer, disable loop clipping.
        m_enable_loop_clipping = !enable;
    }
 
    std::string gcode;
    assert(is_decimal_separator_point()); // for the sprintfs
 
    // add tag for processor
    gcode += ";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Layer_Change) + "\n";
    // export layer z
    char buf[80];
    sprintf(buf, print.is_BBL_printer() ? "; Z_HEIGHT: %g\n" : ";Z:%g\n", print_z);
    gcode += buf;
    // export layer height
    float height = first_layer ? static_cast<float>(print_z) : static_cast<float>(print_z) - m_last_layer_z;
    sprintf(buf, ";%s%g\n", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height).c_str(), height);
    gcode += buf;
    // update caches
    m_last_layer_z = static_cast<float>(print_z);
    m_max_layer_z  = std::max(m_max_layer_z, m_last_layer_z);
    m_last_height = height;
 
    // Set new layer - this will change Z and force a retraction if retract_when_changing_layer is enabled.
    if (! m_config.before_layer_change_gcode.value.empty()) {
        DynamicConfig config;
        config.set_key_value("layer_num",   new ConfigOptionInt(m_layer_index + 1));
        config.set_key_value("layer_z",     new ConfigOptionFloat(print_z));
        config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
        gcode += this->placeholder_parser_process("before_layer_change_gcode",
            print.config().before_layer_change_gcode.value, m_writer.filament()->id(), &config)
            + "\n";
    }
 
    PrinterStructure printer_structure           = m_config.printer_structure.value;
    bool is_i3_printer = printer_structure == PrinterStructure::psI3;
    bool is_multi_extruder = m_config.nozzle_diameter.size() > 1;
 
    // Farthest-point timelapse enable-fold. Corexy-only: gated OFF for i3 (psI3 → A1/A2L), for
    // smooth timelapse, and whenever the toggle is unset. When false every downstream hook (compute,
    // _extrude inline photo, process_layer case gates, template ternary) is inert, so the whole shipping
    // fleet that does not set farthest_point_timelapse is byte-identical to the pre-existing behavior.
    m_farthest_point_timelapse.enabled = m_config.farthest_point_timelapse.value
        && m_config.timelapse_type.value == TimelapseType::tlTraditional
        && printer_structure != PrinterStructure::psI3;
    m_farthest_point_timelapse.most_used_extruder = most_used_extruder;
    m_farthest_point_timelapse.inserted_this_layer = false;
 
    bool need_insert_timelapse_gcode_for_traditional = false;
    if ((!m_wipe_tower || !m_wipe_tower->enable_timelapse_print()) && (is_BBL_Printer() || !m_config.time_lapse_gcode.value.empty())) {
        need_insert_timelapse_gcode_for_traditional = ((is_i3_printer && !m_spiral_vase) || is_multi_extruder);
    }
 
    bool has_insert_timelapse_gcode = false;
    bool has_wipe_tower             = (layer_tools.has_wipe_tower && m_wipe_tower);
 
 
    ZHopType z_hope_type = ZHopType(FILAMENT_CONFIG(z_hop_types));
    LiftType auto_lift_type = LiftType::NormalLift;
    if (z_hope_type == ZHopType::zhtAuto || z_hope_type == ZHopType::zhtSpiral || z_hope_type == ZHopType::zhtSlope)
        auto_lift_type = LiftType::SpiralLift;
 
    // BBS: don't use lazy_raise when enable spiral vase
    gcode += this->change_layer(print_z);  // this will increase m_layer_index
    update_layer_related_config(m_layer_index);
    update_placeholder_parser_with_variant_params();
    m_layer = &layer;
    m_object_layer_over_raft = false;
 
    if (!need_insert_timelapse_gcode_for_traditional && !m_config.time_lapse_gcode.value.empty() && !is_BBL_Printer()) {
        const DynamicConfig config = timelapse_gcode_config(print, print_z, most_used_extruder, &m_printed_objects, false);
        gcode += this->placeholder_parser_process("time_lapse_gcode",
             print.config().time_lapse_gcode.value, m_writer.filament()->id(), &config)
             + "\n";
    }
 
    if (!m_config.layer_change_gcode.value.empty())
        gcode += this->process_layer_change_gcode(print, print_z, most_used_extruder, has_wipe_tower);
 
    //BBS: set layer time fan speed after layer change gcode
    gcode += ";_SET_FAN_SPEED_CHANGING_LAYER\n";
 
    // Belt printers: ordinary-layer apron bands (a band whose print_z coincides with an
    // object/support layer, so it takes this path rather than the brim-only branch) are
    // NOT emitted here anymore.  They used to be laid down with whatever tool happened to
    // be active; instead they are now emitted inside the extruder loop below, in their
    // own brim-filament pass and before that pass's object extrusion, so the brim goes
    // down first with the correct tool.  See the emit_belt_brim_for_extruder call.
 
    //Calibration Layer-specific GCode
    // ORCA-Belt: on belt printers the calibration object is counter-rotated to
    // stand upright in slicing space on top of a support wedge, so its first
    // layer starts above Z=0 (at its position along the belt) with support-only
    // layers below it. Reference the per-height calibration bands to the bottom
    // of the object so they keep their designed meaning; on regular printers
    // the object base is at Z=0 and calib_z == print_z.
    double calib_z = print_z;
    if (m_config.belt_printer.value && print.calib_mode() != CalibMode::Calib_None) {
        // Skip empty ghost layers the grid may produce below the object.
        for (const Layer* l : layer.object()->layers())
            if (!l->lslices.empty()) {
                calib_z = print_z - (l->print_z - l->height);
                break;
            }
    }
    switch (print.calib_mode()) {
        case CalibMode::Calib_PA_Tower: {
            gcode += writer().set_pressure_advance(this->interpolate_value_across_layers(static_cast<float>(print.calib_params().start),
                                                                                         static_cast<float>(print.calib_params().end),
                                                                                         static_cast<float>(print.calib_params().step)));
            break;
        }
        case CalibMode::Calib_Temp_Tower: {
            // ORCA-Belt: the sectioned variant prints each temperature as its
            // own object in native belt orientation, with the temperature
            // encoded in the object name ("temp_230") — step per object
            // instead of ramping per layer band.
            int sectioned_temp = 0;
            if (m_config.belt_printer.value &&
                sscanf(layer.object()->model_object()->name.c_str(), "temp_%d", &sectioned_temp) == 1 &&
                sectioned_temp > 0) {
                gcode += writer().set_temperature(static_cast<unsigned int>(sectioned_temp));
            } else {
                gcode += writer().set_temperature(this->interpolate_value_across_layers(static_cast<float>(print.calib_params().start), static_cast<float>(print.calib_params().end), 5.0f));
            }
            break;
        }
        case CalibMode::Calib_VFA_Tower: {
            // Step the outer wall speed from start to end across the tower's layers. Plater::calib_VFA sizes the
            // geometry so each speed step spans one visual block (a fixed number of layers), so the layer-based
            // stepping stays aligned with the blocks regardless of nozzle size / layer height.
            float _speed = this->interpolate_value_across_layers(static_cast<float>(print.calib_params().start),
                                                                 static_cast<float>(print.calib_params().end),
                                                                 static_cast<float>(print.calib_params().step));
            m_calib_config.set_key_value("outer_wall_speed", new ConfigOptionFloatsNullable({std::round(_speed)}));
            break;
        }
        case CalibMode::Calib_Vol_speed_Tower: {
            auto _speed = print.calib_params().start + std::max(0.0, calib_z) * print.calib_params().step;
            m_calib_config.set_key_value("outer_wall_speed", new ConfigOptionFloatsNullable({std::round(_speed)}));
            break;
        }
        case CalibMode::Calib_Retraction_tower: {
            auto _length = print.calib_params().start + std::floor(std::max(0.0,calib_z-0.4)) * print.calib_params().step;
            DynamicConfig _cfg;
            _cfg.set_key_value("retraction_length", new ConfigOptionFloats{_length});
            writer().config.apply(_cfg);
            sprintf(buf, "; Calib_Retraction_tower: Z_HEIGHT: %g, length:%g\n", calib_z, _length);
            gcode += buf;
            break;
        }
        case CalibMode::Calib_Input_shaping_freq: {
            if (m_layer_index == 1){
                gcode += writer().set_input_shaping('A', print.calib_params().start, 0.f, print.calib_params().shaper_type);
            } else {
                if (print.calib_params().freqStartX == print.calib_params().freqStartY && print.calib_params().freqEndX == print.calib_params().freqEndY) {
                    gcode += writer().set_input_shaping('A', 0.f, this->interpolate_value_across_layers(print.calib_params().freqStartX, print.calib_params().freqEndX), "");
                } else {
                    gcode += writer().set_input_shaping('X', 0.f, this->interpolate_value_across_layers(print.calib_params().freqStartX, print.calib_params().freqEndX), "");
                    gcode += writer().set_input_shaping('Y', 0.f, this->interpolate_value_across_layers(print.calib_params().freqStartY, print.calib_params().freqEndY), "");
                }
            }
            break;
        }
        case CalibMode::Calib_Input_shaping_damp: {
            if (m_layer_index == 1){
                gcode += writer().set_input_shaping('X', 0.f, print.calib_params().freqStartX, print.calib_params().shaper_type);
                gcode += writer().set_input_shaping('Y', 0.f, print.calib_params().freqStartY, print.calib_params().shaper_type);
            } else {
                gcode += writer().set_input_shaping('A', this->interpolate_value_across_layers(print.calib_params().start, print.calib_params().end), 0.f, "");
            }
            break;
        }
        case CalibMode::Calib_Cornering: {
            if (m_writer.get_gcode_flavor() == gcfMarlinFirmware &&
                !m_config.machine_max_junction_deviation.values.empty() &&
                m_config.machine_max_junction_deviation.values.front() > 0) {
                gcode += writer().set_junction_deviation(this->interpolate_value_across_layers(print.calib_params().start, print.calib_params().end));
            } else {
                gcode += writer().set_jerk_xy(this->interpolate_value_across_layers(print.calib_params().start, print.calib_params().end));
            }
            break;
        }
    }
 
    //BBS
    if (first_layer) {
        // Orca: we don't need to optimize the Klipper as only set once
        if (NOZZLE_CONFIG(default_acceleration) > 0 && NOZZLE_CONFIG(initial_layer_acceleration) > 0) {
            gcode += m_writer.set_print_acceleration((unsigned int)floor(NOZZLE_CONFIG(initial_layer_acceleration) + 0.5));
        }
 
        if (NOZZLE_CONFIG(default_jerk) > 0 && NOZZLE_CONFIG(initial_layer_jerk) > 0) {
            gcode += m_writer.set_jerk_xy(NOZZLE_CONFIG(initial_layer_jerk));
        }
 
        if (m_writer.get_gcode_flavor() == gcfMarlinFirmware && NOZZLE_CONFIG(default_junction_deviation) > 0) {
            gcode += m_writer.set_junction_deviation(NOZZLE_CONFIG(default_junction_deviation));
        }
    }
 
    // Belt printers: defer the temperature/PLR transition until the entire layer
    // is past the first-layer band above the belt.  Elsewhere (non-belt printers,
    // support-only layers) the legacy `!first_layer` predicate applies, so
    // behavior is bit-identical to the pre-feature path.
    bool past_first_layer_band = !first_layer;
    if (int past = this->belt_layer_past_first_layer_band(object_layer); past >= 0)
        past_first_layer_band = past > 0;
 
    if (past_first_layer_band && !m_second_layer_things_done) {
        // Orca: set power loss recovery
        const auto plr_mode = print.config().enable_power_loss_recovery.value;
        gcode += m_writer.enable_power_loss_recovery(plr_mode);
 
        if (print.is_BBL_printer()) {
            // BBS: open first layer inspection at second layer
            if (print.config().scan_first_layer.value) {
                // BBS: retract first to avoid droping when scan model
                gcode += this->retract();
                gcode += "M976 S1 P1 ; scan model before printing 2nd layer\n";
                gcode += "M400 P100\n";
                gcode += this->unretract();
            }
        }
      // Reset acceleration at sencond layer
      // Orca: only set once, don't need to call set_accel_and_jerk
      if (NOZZLE_CONFIG(default_acceleration) > 0 && NOZZLE_CONFIG(initial_layer_acceleration) > 0) {
        gcode += m_writer.set_print_acceleration((unsigned int) floor(NOZZLE_CONFIG(default_acceleration) + 0.5));
      }
 
      if (NOZZLE_CONFIG(default_jerk) > 0 && NOZZLE_CONFIG(initial_layer_jerk) > 0) {
        gcode += m_writer.set_jerk_xy(NOZZLE_CONFIG(default_jerk));
      }
 
        // Transition from 1st to 2nd layer: set non-initial-layer nozzle temperatures.
        // IMEX parallel modes: secondary carriages (T1-T3) never receive tool-change commands,
        // so they're not in m_writer.extruders() and multiple_extruders==false (max id==0).
        // Use the static set_temperature path for IMEX so the T index is always emitted.
        // In primary mode, fall through to the standard path — tool changes handle temps normally.
        if (!m_imex_parallel_mode.empty() && m_imex_parallel_mode != kImexPrimaryMode) {
            // All active tools need explicit temps — none receive tool-change commands,
            // so we can't rely on the condition used for non-IMEX (temp != initial_layer_temp).
            // A tool whose initial and regular temps are the same still needs to be set here.
            // Mutually exclusive with the `else` below, so a head skipped here gets no
            // transition at all. `tool_idx` is physical; the printing head uses this layer's
            // own filament, the parallel carriages resolve through the head map.
            // nozzle_temperature is indexed by column: bound in slot space, or an out-of-slot
            // logical reaches get_filament_config_index and comes back as filament 0.
            // filament_diameter is the slot-space yardstick -- one entry per filament slot,
            // never variant-expanded -- and is the bound the pressure advance loop uses too.
            const int num_filament_slots = (int) print.config().filament_diameter.values.size();
            // Bounds-checked, not get_at() -- see IMEXHelpers.hpp. A clamp would hand the
            // "initial" branch below to whichever secondary sits on pem[0], giving it the wrong
            // filament's transition temperature and never its own.
            const int initial_physical =
                ((int) first_extruder_id >= 0 &&
                 (int) first_extruder_id < (int) m_config.physical_extruder_map.values.size())
                    ? m_config.physical_extruder_map.values[(int) first_extruder_id]
                    : -1;
            for (int tool_idx : get_imex_active_tools(print)) {
                const int logical = (tool_idx == initial_physical)
                    ? (int)first_extruder_id
                    : resolve_filament_for_head(
                          m_imex_head_filament_map, m_config.physical_extruder_map, tool_idx);
                if (logical < 0 || logical >= num_filament_slots) continue;
                // Variant-expanded printers column each filament; index as the `else` does.
                int temperature = print.config().nozzle_temperature.get_at(get_filament_config_index(logical));
                if (temperature > 0)
                    gcode += GCodeWriter::set_temperature(temperature, m_writer.config.gcode_flavor, false,
                        tool_idx, "set IMEX tool temperature");
            }
        } else {
            // Adjust nozzle temperatures as prescribed by the nozzle dependent
            // nozzle_temperature_initial_layer vs. temperature settings.
            for (const Extruder& extruder : m_writer.extruders()) {
                if ((print.config().single_extruder_multi_material.value || m_ooze_prevention.enable) &&
                    extruder.id() != m_writer.filament()->id())
                    // In single extruder multi material mode, set the temperature for the current extruder only.
                    continue;
                size_t fi = get_filament_config_index((int)extruder.id());
                int temperature = print.config().nozzle_temperature.get_at(fi);
                if (temperature > 0 && temperature != print.config().nozzle_temperature_initial_layer.get_at(fi))
                    gcode += m_writer.set_temperature(temperature, false, extruder.id());
            }
        }
 
        // BBS
        int bed_temp = 0;
        if (m_config.bed_temperature_formula == BedTempFormula::btfHighestTemp)
            bed_temp = get_highest_bed_temperature(false,print);
        else
            bed_temp = get_bed_temperature(first_extruder_id, false, m_config.curr_bed_type);
        gcode += m_writer.set_bed_temperature(bed_temp);
        // Mark the temperature transition from 1st to 2nd layer to be finished.
        m_second_layer_things_done = true;
    }
 
    if (single_object_instance_idx == size_t(-1)) {
        // Normal (non-sequential) print.
        gcode += ProcessLayer::emit_custom_gcode_per_print_z(*this, layer_tools.custom_gcode, m_writer.filament()->id(), first_extruder_id, print.config());
    }
 
    // BBS: get next extruder according to flush and soluble
    auto get_next_extruder = [&](int current_extruder,const std::vector<unsigned int>&extruders) {
        std::vector<float> flush_matrix(cast<float>(get_flush_volumes_matrix(m_config.flush_volumes_matrix.values, 0, m_config.nozzle_diameter.values.size())));
        const unsigned int number_of_extruders = (unsigned int)(sqrt(flush_matrix.size()) + EPSILON);
        // Extract purging volumes for each extruder pair:
        std::vector<std::vector<float>> wipe_volumes;
        for (unsigned int i = 0; i < number_of_extruders; ++i)
            wipe_volumes.push_back(std::vector<float>(flush_matrix.begin() + i * number_of_extruders, flush_matrix.begin() + (i + 1) * number_of_extruders));
        unsigned int next_extruder = current_extruder;
        float min_flush = std::numeric_limits<float>::max();
        for (auto extruder_id : extruders) {
            if (print.config().filament_soluble.get_at(extruder_id) || extruder_id == current_extruder)
                continue;
            if (wipe_volumes[current_extruder][extruder_id] < min_flush) {
                next_extruder = extruder_id;
                min_flush = wipe_volumes[current_extruder][extruder_id];
            }
        }
        return next_extruder;
    };
    
    const bool overhang_fan   = overhang_fan_enabled(m_config, m_enable_cooling_markers);
    auto       overhang_speed = [this](const LayerRegion &region) {
        return bool(region.region().config().enable_overhang_speed.get_at(get_nozzle_config_index(m_writer.filament()->id())));
    };
    for (const auto &layer_to_print : layers)
        if (layer_to_print.object_layer && prepares_overhang_estimator(*layer_to_print.object_layer, overhang_fan, overhang_speed))
            m_extrusion_quality_estimator.prepare_for_new_layer(layer_to_print.original_object, layer_to_print.object_layer);
 
    // Group extrusions by an extruder, then by an object, an island and a region.
    std::map<unsigned int, std::vector<ObjectByExtruder>> by_extruder;
    // Farthest-point timelapse: per-support-layer/role → extruder map, consumed only by
    // compute_farthest_point (below, gated on m_farthest_point_timelapse.enabled). Populated alongside the
    // existing support-extruder assignment; unused (and thus output-neutral) when the subsystem is off.
    std::map<std::pair<const SupportLayer *, ExtrusionRole>, unsigned int> support_filaments;
    std::vector<std::unique_ptr<ExtrusionEntityCollection>> split_perimeter_storage;
    bool is_anything_overridden = const_cast<LayerTools&>(layer_tools).wiping_extrusions().is_anything_overridden();
    for (const LayerToPrint &layer_to_print : layers) {
        if (layer_to_print.support_layer != nullptr) {
            const SupportLayer &support_layer = *layer_to_print.support_layer;
            const PrintObject& object = *layer_to_print.original_object;
            if (! support_layer.support_fills.entities.empty()) {
                ExtrusionRole   role               = support_layer.support_fills.role();
                bool            has_support        = role == erMixed || role == erSupportMaterial || role == erSupportTransition;
                bool            has_interface      = role == erMixed || role == erSupportMaterialInterface;
                // Extruder ID of the support base. -1 if "don't care".
                unsigned int    support_extruder   = object.config().support_filament.value - 1;
                // Shall the support be printed with the active extruder, preferably with non-soluble, to avoid tool changes?
                bool            support_dontcare   = object.config().support_filament.value == 0;
                // Extruder ID of the support interface. -1 if "don't care".
                unsigned int    interface_extruder = object.config().support_interface_filament.value - 1;
                // Shall the support interface be printed with the active extruder, preferably with non-soluble, to avoid tool changes?
                bool            interface_dontcare = object.config().support_interface_filament.value == 0;
 
                // BBS: apply wiping overridden extruders
                WipingExtrusions& wiping_extrusions = const_cast<LayerTools&>(layer_tools).wiping_extrusions();
                if (support_dontcare) {
                    int extruder_override = wiping_extrusions.get_support_extruder_overrides(&object);
                    if (extruder_override >= 0) {
                        support_extruder = extruder_override;
                        support_dontcare = false;
                    }
                }
 
                if (interface_dontcare) {
                    int extruder_override = wiping_extrusions.get_support_interface_extruder_overrides(&object);
                    if (extruder_override >= 0) {
                        interface_extruder = extruder_override;
                        interface_dontcare = false;
                    }
                }
 
                // BBS: try to print support base with a filament other than interface filament
                if (support_dontcare && !interface_dontcare) {
                    unsigned int dontcare_extruder = first_extruder_id;
                    for (unsigned int extruder_id : layer_tools.extruders) {
                        if (print.config().filament_soluble.get_at(extruder_id))
                            continue;
 
                        //BBS: now we don't consider interface filament used in other object
                        if (extruder_id == interface_extruder)
                            continue;
 
                        dontcare_extruder = extruder_id;
                        break;
                    }
                #if 0
                    //BBS: not found a suitable extruder in current layer ,dontcare_extruider==first_extruder_id==interface_extruder
                    if (dontcare_extruder == interface_extruder && (object.config().support_interface_not_for_body && object.config().support_interface_filament.value!=0)) {
                        // BBS : get a suitable extruder from other layer
                        auto all_extruders = print.extruders();
                        dontcare_extruder = get_next_extruder(dontcare_extruder, all_extruders);
                    }
                #endif
 
                    if (support_dontcare)
                        support_extruder = dontcare_extruder;
                }
                else if (support_dontcare || interface_dontcare) {
                    // Some support will be printed with "don't care" material, preferably non-soluble.
                    // Is the current extruder assigned a soluble filament?
                    unsigned int dontcare_extruder = first_extruder_id;
                    if (print.config().filament_soluble.get_at(dontcare_extruder)) {
                        // The last extruder printed on the previous layer extrudes soluble filament.
                        // Try to find a non-soluble extruder on the same layer.
                        for (unsigned int extruder_id : layer_tools.extruders)
                            if (! print.config().filament_soluble.get_at(extruder_id)) {
                                dontcare_extruder = extruder_id;
                                break;
                            }
                    }
                    if (print.config().filament_is_support.get_at(dontcare_extruder)) {
                        // The last extruder printed on the previous layer extrudes support filament.
                        // Try to find a non-support extruder on the same layer.
                        for (unsigned int extruder_id : layer_tools.extruders)
                            if (!print.config().filament_is_support.get_at(extruder_id)) {
                                dontcare_extruder = extruder_id;
                                break;
                            }
                    }
                    if (support_dontcare)
                        support_extruder = dontcare_extruder;
                    if (interface_dontcare)
                        interface_extruder = dontcare_extruder;
                }
                // Both the support and the support interface are printed with the same extruder, therefore
                // the interface may be interleaved with the support base.
                bool single_extruder = ! has_support || support_extruder == interface_extruder;
                // Farthest-point timelapse: record the extruder for each support role so
                // compute_farthest_point can attribute farthest support points correctly.
                if (has_support) {
                    support_filaments[{ &support_layer, erSupportMaterial }] = support_extruder;
                    support_filaments[{ &support_layer, erSupportTransition }] = support_extruder;
                }
                if (has_interface) {
                    support_filaments[{ &support_layer, erSupportMaterialInterface }] =
                        single_extruder ? (has_support ? support_extruder : interface_extruder) : interface_extruder;
                }
                // Assign an extruder to the base.
                ObjectByExtruder &obj = object_by_extruder(by_extruder, has_support ? support_extruder : interface_extruder, &layer_to_print - layers.data(), layers.size());
                obj.support = &support_layer.support_fills;
                obj.support_extrusion_role = single_extruder ? erMixed : erSupportMaterial;
                if (! single_extruder && has_interface) {
                    ObjectByExtruder &obj_interface = object_by_extruder(by_extruder, interface_extruder, &layer_to_print - layers.data(), layers.size());
                    obj_interface.support = &support_layer.support_fills;
                    obj_interface.support_extrusion_role = erSupportMaterialInterface;
                }
            }
        }
 
        if (layer_to_print.object_layer != nullptr) {
            const Layer &layer = *layer_to_print.object_layer;
            // We now define a strategy for building perimeters and fills. The separation
            // between regions doesn't matter in terms of printing order, as we follow
            // another logic instead:
            // - we group all extrusions by extruder so that we minimize toolchanges
            // - we start from the last used extruder
            // - for each extruder, we group extrusions by island
            // - for each island, we extrude perimeters first, unless user set the infill_first
            //   option
            // (Still, we have to keep track of regions because we need to apply their config)
            size_t n_slices = layer.lslices.size();
            const std::vector<BoundingBox> &layer_surface_bboxes = layer.lslices_bboxes;
            // Traverse the slices in an increasing order of bounding box size, so that the islands inside another islands are tested first,
            // so we can just test a point inside ExPolygon::contour and we may skip testing the holes.
            std::vector<size_t> slices_test_order;
            slices_test_order.reserve(n_slices);
            for (size_t i = 0; i < n_slices; ++ i)
                slices_test_order.emplace_back(i);
            std::sort(slices_test_order.begin(), slices_test_order.end(), [&layer_surface_bboxes](size_t i, size_t j) {
                const Vec2d s1 = layer_surface_bboxes[i].size().cast<double>();
                const Vec2d s2 = layer_surface_bboxes[j].size().cast<double>();
                return s1.x() * s1.y() < s2.x() * s2.y();
            });
            auto point_inside_surface = [&layer, &layer_surface_bboxes](const size_t i, const Point &point) {
                const BoundingBox &bbox = layer_surface_bboxes[i];
                return point(0) >= bbox.min(0) && point(0) < bbox.max(0) &&
                       point(1) >= bbox.min(1) && point(1) < bbox.max(1) &&
                       layer.lslices[i].contour.contains(point);
            };
 
            for (size_t region_id = 0; region_id < layer.regions().size(); ++ region_id) {
                const LayerRegion *layerm = layer.regions()[region_id];
                if (layerm == nullptr)
                    continue;
                // PrintObjects own the PrintRegions, thus the pointer to PrintRegion would be unique to a PrintObject, they would not
                // identify the content of PrintRegion accross the whole print uniquely. Translate to a Print specific PrintRegion.
                const PrintRegion &region = print.get_print_region(layerm->region().print_region_id());
 
                // Now we must process perimeters and infills and create islands of extrusions in by_region std::map.
                // It is also necessary to save which extrusions are part of MM wiping and which are not.
                // The process is almost the same for perimeters and infills - we will do it in a cycle that repeats twice:
                std::vector<unsigned int> printing_extruders;
                for (const ObjectByExtruder::Island::Region::Type entity_type : { ObjectByExtruder::Island::Region::INFILL, ObjectByExtruder::Island::Region::PERIMETERS }) {
                    for (const ExtrusionEntity *ee : (entity_type == ObjectByExtruder::Island::Region::INFILL) ? layerm->fills.entities : layerm->perimeters.entities) {
                        // extrusions represents infill or perimeter extrusions of a single island.
                        assert(dynamic_cast<const ExtrusionEntityCollection*>(ee) != nullptr);
                        const auto *extrusions = static_cast<const ExtrusionEntityCollection*>(ee);
                        if (extrusions->entities.empty()) // This shouldn't happen but first_point() would fail.
                            continue;
 
                        auto process_extrusions = [&](const ExtrusionEntityCollection *current_extrusions,
                                                       const ExtrusionEntityCollection *overrides_key,
                                                       bool                             use_overrides) {
                            // This extrusion is part of certain Region, which tells us which extruder should be used for it.
                            int correct_extruder_id = layer_tools.extruder(*current_extrusions, region);
 
                            const WipingExtrusions::ExtruderPerCopy *entity_overrides = nullptr;
                            if (! layer_tools.has_extruder(correct_extruder_id)) {
                                // A mixed-color slot is absent from layer_tools.extruders by design:
                                // resolve_mixed_filaments() replaced it with its physical components,
                                // and the sublayer block emits its geometry separately. Reassigning it
                                // to the last extruder here would print it in the wrong colour, so only
                                // fall back for genuinely stale (dontcare) extruders.
                                if (!layer_tools.is_mixed_slot(correct_extruder_id)) {
                                    // this entity is not overridden, but its extruder is not in layer_tools - we'll print it
                                    // by last extruder on this layer (could happen e.g. when a wiping object is taller than others - dontcare extruders are eradicated from layer_tools)
                                    correct_extruder_id = layer_tools.extruders.back();
                                }
                            }
                            printing_extruders.clear();
                            if (is_anything_overridden && use_overrides) {
                                entity_overrides = const_cast<LayerTools&>(layer_tools).wiping_extrusions().get_extruder_overrides(overrides_key, layer_to_print.original_object, correct_extruder_id, layer_to_print.object()->instances().size());
                                if (entity_overrides == nullptr) {
                                    printing_extruders.emplace_back(correct_extruder_id);
                                } else {
                                    printing_extruders.reserve(entity_overrides->size());
                                    for (int extruder : *entity_overrides)
                                        printing_extruders.emplace_back(extruder >= 0 ?
                                            // at least one copy is overridden to use this extruder
                                            extruder :
                                            // at least one copy would normally be printed with this extruder (see get_extruder_overrides function for explanation)
                                            static_cast<unsigned int>(- extruder - 1));
                                    Slic3r::sort_remove_duplicates(printing_extruders);
                                }
                            } else {
                                printing_extruders.emplace_back(correct_extruder_id);
                            }
 
                            // Now we must add this extrusion into the by_extruder map, once for each extruder that will print it.
                            for (unsigned int extruder : printing_extruders) {
                                std::vector<ObjectByExtruder::Island> &islands = object_islands_by_extruder(
                                    by_extruder,
                                    extruder,
                                    &layer_to_print - layers.data(),
                                    layers.size(), n_slices + 1);
                                for (size_t i = 0; i <= n_slices; ++i) {
                                    bool   last       = i == n_slices;
                                    size_t island_idx = last ? n_slices : slices_test_order[i];
                                    if (last || point_inside_surface(island_idx, current_extrusions->first_point())) {
                                        if (islands[island_idx].by_region.empty())
                                            islands[island_idx].by_region.assign(print.num_print_regions(), ObjectByExtruder::Island::Region());
                                        islands[island_idx].by_region[region.print_region_id()].append(entity_type, current_extrusions, entity_overrides);
                                        break;
                                    }
                                }
                            }
                        };
 
                        const auto is_inner = [](const ExtrusionEntity *entity) { return is_inner_wall(*entity); };
                        const size_t inner_count = entity_type == ObjectByExtruder::Island::Region::PERIMETERS ?
                            std::count_if(extrusions->entities.begin(), extrusions->entities.end(), is_inner) : 0;
                        bool split_mixed_perimeters =
                            region.config().outer_wall_filament_id.value != region.config().inner_wall_filament_id.value &&
                            inner_count > 0 && inner_count < extrusions->entities.size();
 
                        if (split_mixed_perimeters) {
                            auto outer_perimeters = std::make_unique<ExtrusionEntityCollection>();
                            auto inner_perimeters = std::make_unique<ExtrusionEntityCollection>();
                            for (const ExtrusionEntity *entity : extrusions->entities)
                                (is_inner(entity) ? inner_perimeters : outer_perimeters)->append(*entity);
 
                            split_perimeter_storage.emplace_back(std::move(outer_perimeters));
                            process_extrusions(split_perimeter_storage.back().get(), nullptr, false);
                            split_perimeter_storage.emplace_back(std::move(inner_perimeters));
                            process_extrusions(split_perimeter_storage.back().get(), nullptr, false);
                        } else {
                            process_extrusions(extrusions, extrusions, true);
                        }
                    }
                }
            } // for regions
        }
    } // for objects
 
    // Farthest-point timelapse: once all this layer's extrusions are grouped, find the point
    // farthest from the camera. No-op when the subsystem is disabled.
    if (m_farthest_point_timelapse.enabled)
        compute_farthest_point(layers, most_used_extruder, support_filaments);
 
    // Per filament: instances to print, and the visit sequence over them. Island-level ordering
    // may visit an instance more than once per layer; otherwise one visit per instance.
    std::map<unsigned int, std::pair<std::vector<InstanceToPrint>, std::vector<InstanceVisit>>> filament_to_print_instances;
    {
        // Order individual islands rather than whole instances. Off for by-object sequencing,
        // sequential printing, and the explicit AsObjectList order, which tour whole instances.
        const bool island_level_ordering = print.config().print_sequence != PrintSequence::ByObject &&
            single_object_instance_idx == size_t(-1) &&
            print.config().print_order != PrintOrder::AsObjectList;
        // A mixed-color slot is absent from layer_tools.extruders by design: resolve_mixed_filaments()
        // replaced it with its physical components. Its geometry is still keyed under the slot in
        // by_extruder though, and the sublayer emitter looks the plan up by slot id, so append the
        // slots here. Appending rather than merging leaves the flush-optimized order untouched.
        std::vector<unsigned int> plan_filaments = layer_tools.extruders;
        for (const auto &grp : layer_tools.mixed_sub_layer_groups)
            if (std::find(plan_filaments.begin(), plan_filaments.end(), grp.mixed_slot_0based) == plan_filaments.end())
                plan_filaments.push_back(grp.mixed_slot_0based);
 
        for (unsigned int filament_id : plan_filaments) {
            auto objects_by_extruder_it = by_extruder.find(filament_id);
            if (objects_by_extruder_it == by_extruder.end()) continue;
 
            auto &filament_plan = filament_to_print_instances[filament_id];
 
            if (!island_level_ordering) {
                // One visit per instance, printing all of its islands.
                filament_plan.first = sort_print_object_instances(objects_by_extruder_it->second, layers, ordering, single_object_instance_idx);
                filament_plan.second.reserve(filament_plan.first.size());
                for (size_t i = 0; i < filament_plan.first.size(); ++i)
                    filament_plan.second.push_back({i, {}, true});
                continue;
            }
 
            int   plate_idx = print.get_plate_index();
            Point wt_pos(print.config().wipe_tower_x.get_at(plate_idx), print.config().wipe_tower_y.get_at(plate_idx));
 
            // Build the instances and one tour node per non-empty island (a single node for
            // instances without chainable islands). Positions quantized to 1 mm so small
            // centroid drift between layers still hits the tour cache below.
            std::vector<GCode::ObjectByExtruder> &objects_by_extruder = objects_by_extruder_it->second;
            std::vector<InstanceToPrint> &instances = filament_plan.first;
            std::vector<IslandOrderNode> nodes;
            std::vector<std::pair<size_t, bool>> layout;   // Per instance, see IslandOrderCacheEntry
            std::vector<size_t>          node_instances;
            auto quantize_to_mm = [](const Point &pt) -> Point {
                const coord_t grid = coord_t(scale_(1.));
                // Round to the nearest 1 mm symmetrically (integer division truncates toward
                // zero, which would make the bucket straddling the origin twice as wide).
                auto q = [grid](coord_t v) -> coord_t {
                    return ((v >= 0 ? v + grid / 2 : v - grid / 2) / grid) * grid;
                };
                return Point(q(pt.x()), q(pt.y()));
            };
            for (ObjectByExtruder &object_by_extruder : objects_by_extruder) {
                if (object_by_extruder.islands.empty() && (object_by_extruder.support == nullptr || object_by_extruder.support->empty())) continue;
 
                const size_t       layer_id     = &object_by_extruder - objects_by_extruder.data();
                const PrintObject *print_object = layers[layer_id].original_object;
                if (print_object == nullptr)
                    continue;
                const Layer *obj_layer = layers[layer_id].object_layer;
                std::vector<ObjectByExtruder::Island> &islands = object_by_extruder.islands;
                const bool islands_chainable = obj_layer != nullptr && islands.size() == obj_layer->lslices.size() + 1;
                for (size_t instance_id = 0; instance_id < print_object->instances().size(); ++instance_id) {
                    const size_t instance_idx = instances.size();
                    instances.emplace_back(object_by_extruder, layer_id, *print_object, instance_id,
                                           print_object->instances()[instance_id].model_instance->get_labeled_id());
                    layout.emplace_back(islands.size(), ! islands.empty() && ! islands.back().by_region.empty());
                    const Point &shift = print_object->instances()[instance_id].shift;
                    const size_t first_node = nodes.size();
                    if (islands_chainable)
                        for (size_t i = 0; i + 1 < islands.size(); ++i)
                            if (!islands[i].by_region.empty()) {
                                nodes.push_back({print_object->id(), instance_id, i,
                                                 quantize_to_mm(obj_layer->lslices[i].contour.centroid() + shift)});
                                node_instances.emplace_back(instance_idx);
                            }
                    if (nodes.size() == first_node) {
                        // No chainable islands: tour the whole instance as one stop.
                        nodes.push_back({print_object->id(), instance_id, size_t(-1), quantize_to_mm(shift)});
                        node_instances.emplace_back(instance_idx);
                    }
                }
            }
 
            // Reuse the cached tour while this filament's island layout is unchanged.
            auto &cache_entry = m_ordering_cache[filament_id];
            if (! (cache_entry.nodes == nodes && cache_entry.layout == layout)) {
                cache_entry.nodes  = nodes;
                cache_entry.layout = layout;
                Points node_points;
                node_points.reserve(nodes.size());
                for (const IslandOrderNode &node : nodes)
                    node_points.emplace_back(node.pos);
                std::vector<size_t> tour = order_points_with_strategy(node_points, print.config().print_order, &wt_pos);
                // Chained starting near the wipe tower, reversed so the layer ends near it.
                std::reverse(tour.begin(), tour.end());
 
                // Group consecutive tour stops of the same instance into visits.
                std::vector<InstanceVisit> visits;
                std::vector<bool> instance_seen(instances.size(), false);
                std::vector<int>  last_visit_of_instance(instances.size(), -1);
                for (size_t node_idx : tour) {
                    const size_t instance_idx = node_instances[node_idx];
                    if (visits.empty() || visits.back().instance_idx != instance_idx) {
                        visits.push_back({instance_idx, {}, !instance_seen[instance_idx]});
                        instance_seen[instance_idx] = true;
                    }
                    if (nodes[node_idx].island_idx != size_t(-1))
                        visits.back().islands.emplace_back(nodes[node_idx].island_idx);
                    last_visit_of_instance[instance_idx] = int(visits.size()) - 1;
                }
                // The trailing catch-all island has no geometry to chain by; append it to the
                // instance's last visit.
                for (size_t i = 0; i < instances.size(); ++i) {
                    if (last_visit_of_instance[i] < 0)
                        continue;
                    InstanceVisit &last_visit = visits[size_t(last_visit_of_instance[i])];
                    if (last_visit.islands.empty())
                        // A visit without explicit islands already prints everything.
                        continue;
                    std::vector<ObjectByExtruder::Island> &islands = instances[i].object_by_extruder.islands;
                    if (! islands.empty() && ! islands.back().by_region.empty())
                        last_visit.islands.emplace_back(islands.size() - 1);
                }
                cache_entry.visits = std::move(visits);
            }
            filament_plan.second = cache_entry.visits;
        }
    }
 
    std::set<size_t> layer_object_label_ids;
    for (auto iter = filament_to_print_instances.begin(); iter != filament_to_print_instances.end(); ++iter) {
        for (const InstanceToPrint &instance : iter->second.first) {
            layer_object_label_ids.insert(instance.label_object_id);
        }
    }
 
    m_farthest_point_timelapse.layer_object_label_ids = layer_object_label_ids;
 
    // skip_pos_pick: when true the head takes an inline photo at its current spot instead of moving to a
    // picked safe position. Delegates to the extracted member so the per-extrusion farthest-point hook in
    // _extrude() shares the exact same generation path. Every existing call site uses the default (false).
    auto insert_timelapse_gcode = [this, print_z, &print, &most_used_extruder, &layer_object_label_ids,&printed_objects = std::as_const(m_printed_objects)](bool skip_pos_pick = false) -> std::string {
        return generate_timelapse_gcode(print, print_z, most_used_extruder, &layer_object_label_ids, &printed_objects, skip_pos_pick);
    };
 
    // With farthest-point-is-photo-head active, the snapshot is deferred to the inline _extrude
    // hook / layer-end fallback, so skip the layer-start placement here. The extra clause is inert (true)
    // whenever the subsystem is off → pre-existing behavior byte-for-byte.
    if (!need_insert_timelapse_gcode_for_traditional  && is_BBL_Printer()
        && !(m_farthest_point_timelapse.enabled && m_farthest_point_timelapse.farthest_is_photo_head)) { // Equivalent to the timelapse gcode placed in layer_change_gcode
        if (FILAMENT_CONFIG(retract_when_changing_layer)) {
            gcode += this->retract(false, false, auto_lift_type, true);
        }
        gcode += insert_timelapse_gcode();
    }
 
    if (m_wipe_tower)
        m_wipe_tower->set_is_first_print(true);
 
    auto insert_wrapping_detection_gcode = [this, &print, &print_z, &most_used_extruder]() -> std::string {
        std::string wrapping_gcode;
        if (print.config().enable_wrapping_detection && !print.config().wrapping_detection_gcode.value.empty()) {
            DynamicConfig config;
            config.set_key_value("layer_num", new ConfigOptionInt(m_layer_index));
            config.set_key_value("layer_z", new ConfigOptionFloat(print_z));
            config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
            config.set_key_value("most_used_physical_extruder_id", new ConfigOptionInt(m_config.physical_extruder_map.get_at(most_used_extruder)));
            config.set_key_value("curr_physical_extruder_id", new ConfigOptionInt(m_config.physical_extruder_map.get_at(m_writer.filament()->extruder_id())));
            wrapping_gcode = this->placeholder_parser_process("wrapping_detection_gcode", print.config().wrapping_detection_gcode.value, m_writer.filament()->id(), &config) +"\n";
        }
        m_writer.set_current_position_clear(false);
 
        double temp_z_after_tool_change;
        if (GCodeProcessor::get_last_z_from_gcode(wrapping_gcode, temp_z_after_tool_change)) {
            Vec3d pos = m_writer.get_position();
            pos(2)    = temp_z_after_tool_change;
            m_writer.set_position(pos);
        }
        return wrapping_gcode;
    };
 
    bool has_insert_wrapping_detection_gcode = false;
 
    // Extrude the skirt, brim, support, perimeters, infill ordered by the extruders.
    m_skirt_group_done.resize(print.skirt_brim_groups().size());
 
    // Belt brim bookkeeping.  A coincident belt_brim_by_layer band must be emitted
    // exactly once, in its object's brim-filament pass; this records which have gone
    // down so the in-visit emit and the end-of-layer orphan sweep never double it.
    // Key = (LayerToPrint index, instance_id).
    std::set<std::pair<size_t, size_t>> belt_brim_emitted;
 
    // Emit every ORDINARY-layer apron band (belt_brim_prologue band coinciding with an
    // object/support layer) whose brim filament is this pass's extruder, so each band
    // prints in the correct tool's pass (Finding B).  extruder_id is 0-based (the
    // reindexed tool domain).
    auto emit_belt_brim_for_extruder = [this, &print, &layers, single_object_instance_idx](unsigned int extruder_id) -> std::string {
        return this->emit_belt_brim_bands(print, layers, single_object_instance_idx, extruder_id);
    };
 
    for (unsigned int extruder_id : layer_tools.extruders)
    {
        if (print.config().skirt_type == stCombined && !print.skirt_brim_groups().empty()) {
            for (size_t group_idx = 0; group_idx < print.skirt_brim_groups().size(); ++group_idx) {
                const Print::SkirtBrimGroup& group = print.skirt_brim_groups()[group_idx];
                if (group.skirt.empty())
                    continue;
 
                std::string skirt_gcode = generate_skirt(print, group.skirt, Point(0, 0), layer.object()->config().skirt_start_angle,
                                                          layer_tools, layer, extruder_id, m_skirt_group_done[group_idx]);
                gcode += std::move(skirt_gcode);
            }
        }
 
        if (print.config().print_sequence == PrintSequence::ByLayer && m_enable_exclude_object && print.config().support_object_skip_flush.value) {
            std::set<size_t> all_label_ids;
            for (InstanceToPrint &instance : filament_to_print_instances[extruder_id].first)
                all_label_ids.insert(instance.label_object_id);
            // This extruder may also be printing sub-layers on behalf of a mixed slot, whose
            // instances live under the slot id. Their labels belong in the same skip set, or
            // exclude-object would not skip that geometry.
            for (const auto &grp : layer_tools.mixed_sub_layer_groups)
                for (unsigned int comp : grp.components_0based)
                    if (comp == extruder_id) {
                        auto mit = filament_to_print_instances.find(grp.mixed_slot_0based);
                        if (mit != filament_to_print_instances.end())
                            for (const InstanceToPrint &inst : mit->second.first)
                                all_label_ids.insert(inst.label_object_id);
                        break;
                    }
            // Orca: A scheduled extruder may have no object instances on this layer.
            // Clear any pending mask so it cannot be emitted for the wrong toolchange.
            m_filament_instances_code.clear();
            if (!all_label_ids.empty()) {
                std::vector<size_t> filament_instances_id(all_label_ids.begin(), all_label_ids.end());
                m_filament_instances_code = _encode_label_ids_to_base64(filament_instances_id);
            }
        }
 
        // The inline _extrude hook may already have taken the snapshot mid-extrusion on a
        // previous extruder; sync so we don't insert it a second time.
        has_insert_timelapse_gcode |= m_farthest_point_timelapse.inserted_this_layer;
 
        std::string gcode_toolchange;
        if (has_wipe_tower) {
            if (!m_wipe_tower->is_empty_wipe_tower_gcode(*this, extruder_id, extruder_id == layer_tools.extruders.back())) {
                if (need_insert_timelapse_gcode_for_traditional && !has_insert_timelapse_gcode
                    && !(m_farthest_point_timelapse.enabled && m_farthest_point_timelapse.farthest_is_photo_head)) {
                    bool should_insert = true;
                    if (m_config.nozzle_diameter.values.size() == 2){
                        bool curr_is_photo_head = writer().filament() &&
                            get_extruder_id(writer().filament()->id()) == most_used_extruder;
                        // Case B (farthest point printed by a non-photo head): the firmware
                        // snapshots at the picked safe pos, so insert when leaving the photo head instead.
                        // is_case_b is false whenever the subsystem is off → should_insert == pre-existing value.
                        bool is_case_b = m_farthest_point_timelapse.enabled && !m_farthest_point_timelapse.farthest_is_photo_head;
                        should_insert = is_case_b ? !curr_is_photo_head : curr_is_photo_head;
                    }
 
                    if (should_insert) {
                        gcode += this->retract(false, false, auto_lift_type, true);
                        m_writer.add_object_change_labels(gcode);
 
                        gcode += insert_timelapse_gcode();
                        has_insert_timelapse_gcode = true;
                    }
                }
 
                if (print.config().enable_wrapping_detection && !has_insert_wrapping_detection_gcode) {
                    gcode += this->retract(false, false, auto_lift_type, true);
                    gcode += insert_wrapping_detection_gcode();
                    has_insert_wrapping_detection_gcode = true;
                }
                gcode_toolchange = m_wipe_tower->tool_change(*this, extruder_id, extruder_id == layer_tools.extruders.back());
            }
        } else {
            // Same case-A/case-B split for the non-wipe-tower path. With the subsystem off,
            // is_case_b is false and should_insert == (curr == most_used) = pre-existing behavior.
            if (need_insert_timelapse_gcode_for_traditional &&
                !has_insert_timelapse_gcode &&
                !(m_farthest_point_timelapse.enabled && m_farthest_point_timelapse.farthest_is_photo_head) &&
                m_writer.need_toolchange(extruder_id) &&
                m_config.nozzle_diameter.values.size() == 2 &&
                writer().filament()) {
                bool curr_is_photo_head = get_extruder_id(writer().filament()->id()) == most_used_extruder;
                bool is_case_b = m_farthest_point_timelapse.enabled && !m_farthest_point_timelapse.farthest_is_photo_head;
                bool should_insert = is_case_b ? !curr_is_photo_head : curr_is_photo_head;
                if (should_insert) {
                    gcode += this->retract(false, false, auto_lift_type, true);
                    m_writer.add_object_change_labels(gcode);
 
                    gcode += insert_timelapse_gcode();
                    has_insert_timelapse_gcode = true;
                }
            }
 
            if (print.config().enable_wrapping_detection && !has_insert_wrapping_detection_gcode) {
                gcode += this->retract(false, false, auto_lift_type, true);
                gcode += insert_wrapping_detection_gcode();
                has_insert_wrapping_detection_gcode = true;
            }
 
            gcode_toolchange = this->set_extruder(extruder_id, print_z);
        }
 
        if (!gcode_toolchange.empty()) {
            // Disable vase mode for layers that has toolchange
            result.spiral_vase_enable = false;
        }
        
        gcode += std::move(gcode_toolchange);
 
        // let analyzer tag generator aware of a role type change
        if (layer_tools.has_wipe_tower && m_wipe_tower)
            m_last_processor_extrusion_role = erWipeTower;
 
        // Belt printers: now that this pass's tool is selected, lay down any ordinary-layer
        // apron band whose brim filament is this extruder, before the object extrusion at
        // this Z (brim goes down first, with the correct tool).  Restore the origin so the
        // object-setup code below is unaffected.
        if (print.has_belt_brim()) {
            const Vec2d saved_origin = m_origin;
            gcode += emit_belt_brim_for_extruder(extruder_id);
            this->set_origin(saved_origin);
        }
 
        auto &filament_plan = filament_to_print_instances[extruder_id];
        std::vector<InstanceToPrint>     &instances_to_print = filament_plan.first;
        const std::vector<InstanceVisit> &instance_visits    = filament_plan.second;
 
        // We are almost ready to print. However, we must go through all the objects twice to print the overridden extrusions first (infill/perimeter wiping feature):
        std::vector<ObjectByExtruder::Island::Region> by_region_per_copy_cache;
        for (int print_wipe_extrusions = is_anything_overridden; print_wipe_extrusions>=0; --print_wipe_extrusions) {
            if (is_anything_overridden && print_wipe_extrusions == 0)
                gcode+="; PURGING FINISHED\n";
 
            for (const InstanceVisit &visit : instance_visits) {
                InstanceToPrint &instance_to_print = instances_to_print[visit.instance_idx];
                const auto& inst = instance_to_print.print_object.instances()[instance_to_print.instance_id];
                const LayerToPrint &layer_to_print = layers[instance_to_print.layer_id];
                if (visit.first_visit && print_wipe_extrusions == (is_anything_overridden ? 1 : 0)) {
                    gcode += generate_object_skirt_group(print, instance_to_print.print_object, instance_to_print.instance_id, layer_tools, layer, extruder_id);
                    const PrintObject &vobj = instance_to_print.print_object;
                    if (vobj.has_belt_brim()) {
                        // Coincident belt brim: emit once, only in this object's brim-filament
                        // pass (extruder_id and belt_brim_filament()-1 are both 0-based here),
                        // and dedup on the LayerToPrint index (not Layer::id()) so the orphan
                        // sweep below never re-emits it.
                        if (extruder_id == (unsigned int)(vobj.belt_brim_filament() - 1) &&
                            belt_brim_emitted.insert({ instance_to_print.layer_id, instance_to_print.instance_id }).second)
                            gcode += generate_object_brim(print, vobj, instance_to_print.instance_id, first_layer, extruder_id,
                                                          layer_to_print.object_layer);
                    } else {
                        gcode += generate_object_brim(print, vobj, instance_to_print.instance_id, first_layer, extruder_id,
                                                      layer_to_print.object_layer);
                    }
                }
 
                // To control print speed of the 1st object layer printed over raft interface.
                bool object_layer_over_raft = layer_to_print.object_layer && layer_to_print.object_layer->id() > 0 &&
                    instance_to_print.print_object.slicing_parameters().raft_layers() == layer_to_print.object_layer->id();
                m_config.apply(print.default_region_config());
                m_config.apply(instance_to_print.print_object.config(), true);
                m_layer = layer_to_print.layer();
                m_object_layer_over_raft = object_layer_over_raft;
                if (m_config.reduce_crossing_wall)
                    m_avoid_crossing_perimeters.init_layer(*m_layer);
 
                if (this->config().gcode_label_objects) {
                    gcode += std::string("; printing object ") + instance_to_print.print_object.model_object()->name +
                             " id:" + std::to_string(instance_to_print.print_object.get_id()) + " copy " +
                             std::to_string(inst.id) + "\n";
                }
                // exclude objects
                if (m_enable_exclude_object) {
                    if (is_BBL_Printer()) {
                        m_writer.set_object_start_str(
                            std::string("; start printing object, unique label id: ") +
                            std::to_string(instance_to_print.label_object_id) + "\n" + "M624 " +
                            _encode_label_ids_to_base64({instance_to_print.label_object_id}) + "\n");
                    } else {
                        const auto gflavor = print.config().gcode_flavor.value;
                        if (gflavor == gcfKlipper) {
                            m_writer.set_object_start_str(std::string("EXCLUDE_OBJECT_START NAME=") +
                                                          instance_name(inst) + "\n");
                        }
                        else if (gflavor == gcfMarlinLegacy || gflavor == gcfMarlinFirmware || gflavor == gcfRepRapFirmware) {
                            std::string str = std::string("M486 S") + std::to_string(inst.unique_id) + "\n";
                            m_writer.set_object_start_str(str);
                        }
                    }
                }
 
                // Orca(#7946): set current obj regardless of the `enable_overhang_speed` value, because
                // `enable_overhang_speed` is a PrintRegionConfig and here we don't have a region yet.
                // And no side effect doing this even if `enable_overhang_speed` is off, so don't bother
                // checking anything here.
                m_extrusion_quality_estimator.set_current_object(&instance_to_print.print_object);
 
                // When starting a new object, use the external motion planner for the first travel move.
                const Point &offset = instance_to_print.print_object.instances()[instance_to_print.instance_id].shift;
                std::pair<const PrintObject*, Point> this_object_copy(&instance_to_print.print_object, offset);
                if (m_last_obj_copy != this_object_copy)
                    m_avoid_crossing_perimeters.use_external_mp_once();
                m_last_obj_copy = this_object_copy;
                this->set_origin(unscale(offset));
                this->on_set_origin(&instance_to_print.print_object, offset);
                if (visit.first_visit && instance_to_print.object_by_extruder.support != nullptr) {
                    m_layer = layers[instance_to_print.layer_id].support_layer;
                    m_object_layer_over_raft = false;
 
                    // When starting a new object, use the external motion planner for the first travel move.
                    const Point& offset = instance_to_print.print_object.instances()[instance_to_print.instance_id].shift;
                    std::pair<const PrintObject*, Point> this_object_copy(&instance_to_print.print_object, offset);
                    if (m_last_obj_copy != this_object_copy)
                        m_avoid_crossing_perimeters.use_external_mp_once();
                    m_last_obj_copy = this_object_copy;
                    this->set_origin(unscale(offset));
                    this->on_set_origin(&instance_to_print.print_object, offset);
                    ExtrusionEntityCollection support_eec;
 
                    // BBS
                    WipingExtrusions& wiping_extrusions = const_cast<LayerTools&>(layer_tools).wiping_extrusions();
                    bool support_overridden = wiping_extrusions.is_support_overridden(layer_to_print.original_object);
                    bool support_intf_overridden = wiping_extrusions.is_support_interface_overridden(layer_to_print.original_object);
 
                    ExtrusionRole support_extrusion_role = instance_to_print.object_by_extruder.support_extrusion_role;
                    bool is_overridden = support_extrusion_role == erSupportMaterialInterface ? support_intf_overridden : support_overridden;
                    if (is_overridden == (print_wipe_extrusions != 0)) {
                        gcode += this->extrude_support(
                            // support_extrusion_role is erSupportMaterial, erSupportTransition, erSupportMaterialInterface or erMixed for all extrusion paths.
                            *instance_to_print.object_by_extruder.support, support_extrusion_role);
 
                        // Make sure ironing is the last
                        if (support_extrusion_role == erMixed || support_extrusion_role == erSupportMaterialInterface) {
                            gcode += this->extrude_support(*instance_to_print.object_by_extruder.support, erIroning);
                        }
                    }
 
                    m_layer = layer_to_print.layer();
                    m_object_layer_over_raft = object_layer_over_raft;
                }
                // Sequential tool path ordering of multiple parts within the same object, aka. perimeter tracking (#5511)
                // Island print order. Use the islands the tour assigned to this visit; if none,
                // chain all islands nearest-neighbor from the current nozzle position (last_pos(),
                // in this instance's frame after set_origin() above). Empty islands are skipped;
                // the trailing catch-all island has no centroid to chain by and always goes last.
                std::vector<ObjectByExtruder::Island> &islands = instance_to_print.object_by_extruder.islands;
                std::vector<size_t> island_order;
                island_order.reserve(visit.islands.size());
                for (size_t idx : visit.islands)   // Never index past the islands (see IslandOrderCacheEntry)
                    if (idx < islands.size())
                        island_order.emplace_back(idx);
                    else
                        BOOST_LOG_TRIVIAL(error) << "island tour refers to island " << idx << " of " << islands.size() << ", skipped";
                if (island_order.empty()) {
                    island_order.reserve(islands.size());
                    if (layer_to_print.object_layer != nullptr && islands.size() == layer_to_print.object_layer->lslices.size() + 1) {
                        for (size_t i = 0; i + 1 < islands.size(); ++i)
                            if (!islands[i].by_region.empty())
                                island_order.emplace_back(i);
                        if (island_order.size() > 1) {
                            Points island_centroids;
                            island_centroids.reserve(island_order.size());
                            for (size_t i : island_order)
                                island_centroids.emplace_back(layer_to_print.object_layer->lslices[i].contour.centroid());
                            const Point start_near = this->last_pos();
                            std::vector<size_t> chain = chain_points(island_centroids, this->last_pos_defined() ? &start_near : nullptr);
                            std::vector<size_t> ordered;
                            ordered.reserve(island_order.size());
                            for (size_t k : chain)
                                ordered.emplace_back(island_order[k]);
                            island_order = std::move(ordered);
                        }
                        if (!islands.back().by_region.empty())
                            island_order.emplace_back(islands.size() - 1);
                    } else {
                        // Unexpected islands layout, keep the stored order.
                        for (size_t i = 0; i < islands.size(); ++i)
                            island_order.emplace_back(i);
                    }
                }
                for (size_t island_idx : island_order) {
                    ObjectByExtruder::Island &island = islands[island_idx];
                    const auto& by_region_specific = is_anything_overridden ? island.by_region_per_copy(by_region_per_copy_cache, static_cast<unsigned int>(instance_to_print.instance_id), extruder_id, print_wipe_extrusions != 0) : island.by_region;
                    // When starting a new object, use the external motion planner for the first travel move.
                    const Point& offset = instance_to_print.print_object.instances()[instance_to_print.instance_id].shift;
                    std::pair<const PrintObject*, Point> this_object_copy(&instance_to_print.print_object, offset);
                    if (m_last_obj_copy != this_object_copy)
                        m_avoid_crossing_perimeters.use_external_mp_once();
                    m_last_obj_copy = this_object_copy;
                    this->set_origin(unscale(offset));
                    this->on_set_origin(&instance_to_print.print_object, offset);
                    //FIXME the following code prints regions in the order they are defined, the path is not optimized in any way.
 
                    auto has_infill = [](const std::vector<ObjectByExtruder::Island::Region> &by_region) {
                        for (auto region : by_region) {
                            if (!region.infills.empty())
                                return true;
                        }
                        return false;
                    };
                    {
                        // Print perimeters of regions that has is_infill_first == false
                        gcode += this->extrude_perimeters(print, by_region_specific, first_layer, false);
                        if (!has_wipe_tower && need_insert_timelapse_gcode_for_traditional && printer_structure == PrinterStructure::psI3
                            && !has_insert_timelapse_gcode && has_infill(by_region_specific)) {
                            gcode += this->retract(false, false, auto_lift_type, true);
 
                            gcode += insert_timelapse_gcode();
                            has_insert_timelapse_gcode = true;
                        }
                        // Then print infill
                        gcode += this->extrude_infill(print, by_region_specific, false);
                        // Then the walls left hanging in mid air, now that the infill can anchor them
                        gcode += this->extrude_perimeters(print, by_region_specific, first_layer, false, true);
                        // Then print perimeters of regions that has is_infill_first == true
                        gcode += this->extrude_perimeters(print, by_region_specific, first_layer, true);
                    }
                    // ironing
                    gcode += this->extrude_infill(print,by_region_specific, true);
                }
 
                if (this->config().gcode_label_objects) {
                    gcode += std::string("; stop printing object ") +
                             instance_to_print.print_object.model_object()->name +
                             " id:" + std::to_string(instance_to_print.print_object.get_id()) + " copy " +
                             std::to_string(inst.id) + "\n";
                }
                // exclude objects
                // Don't set m_gcode_label_objects_end if you don't had to write the m_gcode_label_objects_start.
                if (!m_writer.is_object_start_str_empty()) {
                    m_writer.set_object_start_str("");
                } else if (m_enable_exclude_object) {
                    if (is_BBL_Printer()) {
                        m_writer.set_object_end_str(std::string("; stop printing object, unique label id: ") +
                                                    std::to_string(instance_to_print.label_object_id) + "\n" +
                                                    "M625\n");
                    } else {
                        const auto gflavor = print.config().gcode_flavor.value;
                        if (gflavor == gcfKlipper) {
                            m_writer.set_object_end_str(std::string("EXCLUDE_OBJECT_END NAME=") +
                                                        instance_name(inst) + "\n");
                        } else if (gflavor == gcfMarlinLegacy || gflavor == gcfMarlinFirmware || gflavor == gcfRepRapFirmware) {
                            m_writer.set_object_end_str(std::string("M486 S-1\n"));
                        }
                    }
                }
            }
        }
 
        // Mixed-color sublayer extrusion: if this extruder is a component of a mixed sublayer
        // group, extrude the mixed slot's geometry at the appropriate sub-Z with scaled flow.
        // Ported from BambuStudio and adapted to Orca's instance loop and its finer-grained
        // per-role region filament options.
        for (const auto &grp : layer_tools.mixed_sub_layer_groups) {
            int sub_idx = -1;
            for (size_t k = 0; k < grp.components_0based.size(); ++k) {
                if (grp.components_0based[k] == extruder_id) {
                    sub_idx = static_cast<int>(k);
                    break;
                }
            }
            if (sub_idx < 0)
                continue;
 
            auto mixed_instances_it = filament_to_print_instances.find(grp.mixed_slot_0based);
            if (mixed_instances_it == filament_to_print_instances.end() || mixed_instances_it->second.first.empty())
                continue;
 
            double lh = grp.layer_height > 0. ? grp.layer_height : static_cast<double>(height);
            double cumulative_h = 0.0;
            for (int i = 0; i < sub_idx; ++i)
                cumulative_h += grp.sub_heights[i];
            double default_sub_h = grp.sub_heights[sub_idx];
            double default_sub_z = print_z - lh + cumulative_h + default_sub_h;
 
            m_sub_layer_flow_ratio = default_sub_h / lh;
            m_sub_layer_height     = default_sub_h;
            m_nominal_z            = default_sub_z;
 
            gcode += this->set_extruder(extruder_id, default_sub_z);
 
            for (InstanceToPrint &instance_to_print : mixed_instances_it->second.first) {
                const bool use_per_volume = grp.is_gradient
                    && !grp.per_volume_gradient.empty()
                    && std::any_of(grp.per_volume_gradient.begin(), grp.per_volume_gradient.end(),
                                   [&](const auto &kv) { return kv.first.obj == &instance_to_print.print_object; });
 
                // --- Shared instance preamble (mirrors Orca's main instance loop) ---
                const LayerToPrint &layer_to_print = layers[instance_to_print.layer_id];
                const auto &inst = instance_to_print.print_object.instances()[instance_to_print.instance_id];
 
                bool object_layer_over_raft = layer_to_print.object_layer && layer_to_print.object_layer->id() > 0 &&
                    instance_to_print.print_object.slicing_parameters().raft_layers() == layer_to_print.object_layer->id();
                m_config.apply(print.default_region_config());
                m_config.apply(instance_to_print.print_object.config(), true);
                m_layer = layer_to_print.layer();
                m_object_layer_over_raft = object_layer_over_raft;
                if (m_config.reduce_crossing_wall)
                    m_avoid_crossing_perimeters.init_layer(*m_layer);
 
                if (this->config().gcode_label_objects) {
                    gcode += std::string("; printing object ") + instance_to_print.print_object.model_object()->name +
                             " id:" + std::to_string(instance_to_print.print_object.get_id()) + " copy " +
                             std::to_string(inst.id) + "\n";
                }
                if (m_enable_exclude_object) {
                    if (is_BBL_Printer()) {
                        m_writer.set_object_start_str(
                            std::string("; start printing object, unique label id: ") +
                            std::to_string(instance_to_print.label_object_id) + "\n" + "M624 " +
                            _encode_label_ids_to_base64({instance_to_print.label_object_id}) + "\n");
                    } else {
                        const auto gflavor = print.config().gcode_flavor.value;
                        if (gflavor == gcfKlipper) {
                            m_writer.set_object_start_str(std::string("EXCLUDE_OBJECT_START NAME=") +
                                                          instance_name(inst) + "\n");
                        } else if (gflavor == gcfMarlinLegacy || gflavor == gcfMarlinFirmware || gflavor == gcfRepRapFirmware) {
                            m_writer.set_object_start_str(std::string("M486 S") + std::to_string(inst.unique_id) + "\n");
                        }
                    }
                }
 
                m_extrusion_quality_estimator.set_current_object(&instance_to_print.print_object);
 
                const Point &offset = inst.shift;
                std::pair<const PrintObject*, Point> this_object_copy(&instance_to_print.print_object, offset);
                if (m_last_obj_copy != this_object_copy)
                    m_avoid_crossing_perimeters.use_external_mp_once();
                m_last_obj_copy = this_object_copy;
                this->set_origin(unscale(offset));
                // Same as the main instance loop: a belt printer rotates the origin through
                // the belt transform (BeltGCode::on_set_origin).
                this->on_set_origin(&instance_to_print.print_object, offset);
 
                // --- Build emission plan ---
                // Each entry represents one travel_to_z + extrude pass. Per-object mode produces
                // exactly 1 entry (all regions, single sub_z); per-volume mode produces N entries
                // for tagged volumes plus an optional entry for untagged residue.
                struct SubLayerEmitEntry {
                    double sub_h;
                    double sub_z;
                    std::function<bool(size_t region_idx)> region_filter;
                    bool skip = false;
                };
                std::vector<SubLayerEmitEntry> emit_plan;
 
                auto compute_sub_zh = [&](double r1, double r2, double &out_sub_h, double &out_sub_z) {
                    std::vector<double> sub_heights_local(grp.components_0based.size());
                    for (size_t ci = 0; ci < grp.components_0based.size(); ++ci)
                        sub_heights_local[ci] = (static_cast<int>(ci) == grp.gradient_first_sorted_idx) ? r1 * lh : r2 * lh;
                    double cum = 0.0;
                    for (int ci = 0; ci < sub_idx; ++ci)
                        cum += sub_heights_local[ci];
                    out_sub_h = sub_heights_local[sub_idx];
                    out_sub_z = print_z - lh + cum + out_sub_h;
                };
 
                auto gradient_ratios = [](const auto &g) -> std::pair<double, double> {
                    double t  = (g.total_layers > 0) ? (2.0 * g.current_idx + 1.0) / (2.0 * g.total_layers) : 0.5;
                    // Custom curve wins over linear range when present; OFF path stays bit-identical.
                    double r1 = g.curve.empty()
                                ? (g.gradient_start + (g.gradient_end - g.gradient_start) * t)
                                : sample_gradient_curve(g.curve, t);
                    return {r1, 1.0 - r1};
                };
 
                // Orca splits BBS's three role filaments into five; a region belongs to the slot
                // when any of its roles is assigned to it.
                auto region_uses_slot = [](const PrintRegionConfig &rcfg, unsigned int slot_1b) {
                    return (unsigned int)rcfg.outer_wall_filament_id.value     == slot_1b
                        || (unsigned int)rcfg.inner_wall_filament_id.value     == slot_1b
                        || (unsigned int)rcfg.sparse_infill_filament_id.value  == slot_1b
                        || (unsigned int)rcfg.internal_solid_filament_id.value == slot_1b
                        || (unsigned int)rcfg.top_surface_filament_id.value    == slot_1b
                        || (unsigned int)rcfg.bottom_surface_filament_id.value == slot_1b;
                };
 
                double obj_sub_z = default_sub_z;
 
                if (use_per_volume) {
                    const PrintObject *po = &instance_to_print.print_object;
                    const unsigned int slot_1b = grp.mixed_slot_0based + 1;
 
                    // Discover tagged volumes and untagged presence for this instance.
                    std::set<ObjectID> tagged_volumes_present;
                    bool has_untagged_for_slot = false;
                    for (ObjectByExtruder::Island &island : instance_to_print.object_by_extruder.islands) {
                        for (size_t r = 0; r < island.by_region.size(); ++r) {
                            const auto &region = island.by_region[r];
                            if (region.perimeters.empty() && region.infills.empty())
                                continue;
                            const PrintRegion &pr = print.get_print_region(r);
                            if (!region_uses_slot(pr.config(), slot_1b))
                                continue;
                            ObjectID vid = pr.gradient_volume_id();
                            if (vid.valid())
                                tagged_volumes_present.insert(vid);
                            else
                                has_untagged_for_slot = true;
                        }
                    }
 
                    // One entry per tagged volume.
                    for (const ObjectID &target_vid : tagged_volumes_present) {
                        auto vg_it = grp.per_volume_gradient.find({po, target_vid});
                        if (vg_it == grp.per_volume_gradient.end())
                            continue;
                        const auto &vg = vg_it->second;
                        auto [r1, r2] = gradient_ratios(vg);
 
                        bool vol_no_split = false;
                        bool skip_entry   = false;
                        const size_t n = grp.components_0based.size();
                        if (n == 2 && vg.current_idx + 1 == vg.total_layers) {
                            const size_t dom_idx = (r1 >= r2) ? 0 : 1;
                            const unsigned int first_sorted_comp = grp.components_0based[grp.gradient_first_sorted_idx];
                            const unsigned int other_comp = grp.components_0based[1 - grp.gradient_first_sorted_idx];
                            const unsigned int dom_0b = (dom_idx == 0) ? first_sorted_comp : other_comp;
                            const unsigned int oth_0b = (dom_idx == 0) ? other_comp : first_sorted_comp;
                            if (dom_0b < oth_0b) {
                                vol_no_split = true;
                                if (extruder_id != dom_0b)
                                    skip_entry = true;
                            }
                        }
 
                        double vol_sub_h = default_sub_h;
                        double vol_sub_z = default_sub_z;
                        if (vol_no_split) {
                            vol_sub_h = lh;
                            vol_sub_z = print_z;
                        } else {
                            compute_sub_zh(r1, r2, vol_sub_h, vol_sub_z);
                        }
 
                        emit_plan.push_back({vol_sub_h, vol_sub_z,
                            [target_vid, &print](size_t r) {
                                return print.get_print_region(r).gradient_volume_id() == target_vid;
                            },
                            skip_entry});
                    }
 
                    // Optional entry for untagged regions (modifier / painted / fuzzy_skin).
                    if (has_untagged_for_slot) {
                        double obj_sub_h = default_sub_h;
                        auto og_it = grp.per_object_gradient.find(po);
                        if (og_it != grp.per_object_gradient.end()) {
                            auto [r1, r2] = gradient_ratios(og_it->second);
                            compute_sub_zh(r1, r2, obj_sub_h, obj_sub_z);
                        }
                        emit_plan.push_back({obj_sub_h, obj_sub_z,
                            [&print](size_t r) {
                                return !print.get_print_region(r).gradient_volume_id().valid();
                            },
                            false});
                    }
                } else {
                    // Legacy per-object path: single entry, no region filter.
                    double legacy_sub_h = default_sub_h;
                    obj_sub_z = default_sub_z;
                    if (grp.is_gradient) {
                        auto og_it = grp.per_object_gradient.find(&instance_to_print.print_object);
                        if (og_it != grp.per_object_gradient.end()) {
                            auto [r1, r2] = gradient_ratios(og_it->second);
                            compute_sub_zh(r1, r2, legacy_sub_h, obj_sub_z);
                        }
                    }
                    emit_plan.push_back({legacy_sub_h, obj_sub_z, nullptr, false});
                }
 
                // --- Unified emission loop ---
                auto plan_has_infill = [](const std::vector<ObjectByExtruder::Island::Region> &by_region) {
                    for (const auto &r : by_region)
                        if (!r.infills.empty())
                            return true;
                    return false;
                };
 
                for (auto &entry : emit_plan) {
                    if (entry.skip)
                        continue;
                    m_sub_layer_flow_ratio = entry.sub_h / lh;
                    m_sub_layer_height     = entry.sub_h;
                    m_nominal_z            = entry.sub_z;
                    // Use the same lazy-Z mechanism as change_layer(): set the flag so travel_to
                    // fires even when m_last_pos coincides with the first extrusion point,
                    // ensuring Z reaches sub_z via the combined XY+Z move.
                    m_need_change_layer_lift_z = true;
 
                    for (ObjectByExtruder::Island &island : instance_to_print.object_by_extruder.islands) {
                        const auto &src = island.by_region;
                        std::vector<ObjectByExtruder::Island::Region> subset_storage;
                        if (entry.region_filter) {
                            subset_storage.resize(src.size());
                            for (size_t r = 0; r < src.size(); ++r)
                                if (entry.region_filter(r))
                                    subset_storage[r] = src[r];
                        }
                        const auto &by_region_specific = entry.region_filter ? subset_storage : src;
 
                        // Orca resolves infill-first per region inside extrude_perimeters()
                        // (unlike BBS, which branches on a single global flag), so mirror the
                        // main instance loop's ordering exactly.
                        gcode += this->extrude_perimeters(print, by_region_specific, first_layer, false);
                        if (!has_wipe_tower && need_insert_timelapse_gcode_for_traditional
                            && printer_structure == PrinterStructure::psI3
                            && !has_insert_timelapse_gcode && plan_has_infill(by_region_specific)) {
                            gcode += this->retract(false, false, auto_lift_type, true);
                            gcode += insert_timelapse_gcode();
                            has_insert_timelapse_gcode = true;
                        }
                        gcode += this->extrude_infill(print, by_region_specific, false);
                        gcode += this->extrude_perimeters(print, by_region_specific, first_layer, false, true);
                        gcode += this->extrude_perimeters(print, by_region_specific, first_layer, true);
                        // ironing
                        gcode += this->extrude_infill(print, by_region_specific, true);
                    }
                }
 
                // --- Shared support ---
                if (instance_to_print.object_by_extruder.support && !instance_to_print.object_by_extruder.support->empty()) {
                    if (use_per_volume) {
                        m_nominal_z = obj_sub_z;
                        m_need_change_layer_lift_z = true;
                    }
                    ExtrusionRole support_role = instance_to_print.object_by_extruder.support_extrusion_role;
                    gcode += this->extrude_support(*instance_to_print.object_by_extruder.support, support_role);
                    // Make sure ironing is the last (Orca names this role erIroning, not erSupportIroning).
                    if (support_role == erMixed || support_role == erSupportMaterialInterface)
                        gcode += this->extrude_support(*instance_to_print.object_by_extruder.support, erIroning);
                }
 
                // --- Shared instance footer (mirrors Orca's main instance loop) ---
                if (!m_writer.is_object_start_str_empty()) {
                    m_writer.set_object_start_str("");
                } else if (m_enable_exclude_object) {
                    if (is_BBL_Printer()) {
                        m_writer.set_object_end_str(std::string("; stop printing object, unique label id: ") +
                                                    std::to_string(instance_to_print.label_object_id) + "\n" +
                                                    "M625\n");
                    } else {
                        const auto gflavor = print.config().gcode_flavor.value;
                        if (gflavor == gcfKlipper) {
                            m_writer.set_object_end_str(std::string("EXCLUDE_OBJECT_END NAME=") +
                                                        instance_name(inst) + "\n");
                        } else if (gflavor == gcfMarlinLegacy || gflavor == gcfMarlinFirmware || gflavor == gcfRepRapFirmware) {
                            m_writer.set_object_end_str(std::string("M486 S-1\n"));
                        }
                    }
                }
            }
 
            m_sub_layer_flow_ratio = 0.0;
            m_sub_layer_height     = 0.0;
        }
        // Flush any pending object end label before leaving the sublayer block, otherwise the
        // wipe tower's add_object_end_labels may consume it into a local temp string and the
        // M625 would be lost for BBL printers.
        if (!layer_tools.mixed_sub_layer_groups.empty()) {
            m_writer.add_object_end_labels(gcode);
            m_nominal_z = print_z;
            m_need_change_layer_lift_z = true;
        }
 
    }
 
    // Belt brim orphan sweep (Finding C).  A coincident belt_brim_by_layer band lives on
    // an object layer, but that layer can yield no InstanceVisit above - a zero-extrusion
    // lead-in slice with no coinciding support - so the in-visit emit never fired and the
    // band would be dropped.  Emit any such band exactly once here, keyed the same way as
    // the in-visit emit so already-printed bands are skipped.  These orphan layers carry
    // no object material, so ending on the brim's position is harmless; we still save and
    // restore m_origin, and only toolchange when the brim filament differs from the active
    // one - a no-op on single-extruder prints, keeping their output unchanged.
    if (print.has_belt_brim()) {
        const Vec2d saved_origin = m_origin;
        for (const LayerToPrint &ltp : layers) {
            const PrintObject *obj = ltp.original_object;
            if (obj == nullptr || ! obj->has_belt_brim() || ltp.object_layer == nullptr)
                continue;
            const size_t       ltp_idx = size_t(&ltp - layers.data());
            const unsigned int brim0   = (unsigned int)(obj->belt_brim_filament() - 1);
            const size_t       i_begin = single_object_instance_idx == size_t(-1) ? 0 : single_object_instance_idx;
            const size_t       i_end   = single_object_instance_idx == size_t(-1) ? obj->instances().size()
                                                                                 : single_object_instance_idx + 1;
            for (size_t instance_id = i_begin; instance_id < i_end && instance_id < obj->instances().size(); ++ instance_id) {
                if (! belt_brim_emitted.insert({ ltp_idx, instance_id }).second)
                    continue;
                if (m_writer.filament() == nullptr || m_writer.filament()->id() != brim0)
                    gcode += this->set_extruder(brim0, print_z);
                gcode += generate_object_brim(print, *obj, instance_id, first_layer, brim0, ltp.object_layer);
            }
        }
        this->set_origin(saved_origin);
    }
 
    if (first_layer) {
        for (auto iter = by_extruder.begin(); iter != by_extruder.end(); ++iter) {
            if (!iter->second.empty())
                m_initial_layer_extruders.insert(iter->first);
        }
    }
 
#if 0
    // Apply spiral vase post-processing if this layer contains suitable geometry
    // (we must feed all the G-code into the post-processor, including the first
    // bottom non-spiral layers otherwise it will mess with positions)
    // we apply spiral vase at this stage because it requires a full layer.
    // Just a reminder: A spiral vase mode is allowed for a single object per layer, single material print only.
    if (m_spiral_vase)
        gcode = m_spiral_vase->process_layer(std::move(gcode));
 
    // Apply cooling logic; this may alter speeds.
    if (m_cooling_buffer)
        gcode = m_cooling_buffer->process_layer(std::move(gcode), layer.id(),
            // Flush the cooling buffer at each object layer or possibly at the last layer, even if it contains just supports (This should not happen).
            object_layer || last_layer);
 
    file.write(gcode);
#endif
 
    BOOST_LOG_TRIVIAL(trace) << "Exported layer " << layer.id() << " print_z " << print_z <<
    log_memory_info();
 
    // The inline _extrude hook may have taken the snapshot; sync.
    has_insert_timelapse_gcode |= m_farthest_point_timelapse.inserted_this_layer;
 
    // Farthest-point-is-photo-head layer-end fallback. If the head never passed within tolerance of
    // the farthest point during extrusion (so the inline hook never fired) insert the snapshot here —
    // single-extruder prints have no traditional multi-extruder fallback below. Guarded on enabled, so this
    // block never runs for a printer with the subsystem off.
    if (m_farthest_point_timelapse.enabled && m_farthest_point_timelapse.farthest_is_photo_head && !has_insert_timelapse_gcode) {
        if (FILAMENT_CONFIG(retract_when_changing_layer)) {
            gcode += this->retract(false, false, auto_lift_type, true);
        }
        m_writer.add_object_change_labels(gcode);
        gcode += insert_timelapse_gcode();
        has_insert_timelapse_gcode = true;
    }
 
    if (need_insert_timelapse_gcode_for_traditional && !has_insert_timelapse_gcode) {
        // The traditional model of thin-walled object will have flaws for I3
        if (m_support_traditional_timelapse
            && printer_structure == PrinterStructure::psI3
            && m_config.timelapse_type.value == TimelapseType::tlTraditional)
            m_support_traditional_timelapse = false;
 
        // The traditional model will have flaws for multi_extruder when switching extruder
        if (m_config.nozzle_diameter.values.size() == 2
            && m_support_traditional_timelapse
            && m_config.timelapse_type.value == TimelapseType::tlTraditional
            && (writer().filament() && get_extruder_id(writer().filament()->id()) != most_used_extruder)) {
            m_support_traditional_timelapse = false;
        }
        if (FILAMENT_CONFIG(retract_when_changing_layer)) {
            gcode += this->retract(false, false, auto_lift_type, true);
        }
        m_writer.add_object_change_labels(gcode);
 
        gcode += insert_timelapse_gcode();
    }
 
    result.gcode = std::move(gcode);
    result.cooling_buffer_flush = object_layer || raft_layer || last_layer;
    return result;
}

References Slic3r::append(), Slic3r::AsObjectList, belt_layer_past_first_layer_band(), Slic3r::btfHighestTemp, Slic3r::ByObject, Slic3r::Calib_Cornering, Slic3r::Calib_Input_shaping_damp, Slic3r::Calib_Input_shaping_freq, Slic3r::Print::calib_mode(), Slic3r::Calib_None, Slic3r::Calib_PA_Tower, Slic3r::Print::calib_params(), Slic3r::Calib_Retraction_tower, Slic3r::Calib_Temp_Tower, Slic3r::Calib_VFA_Tower, Slic3r::Calib_Vol_speed_Tower, Slic3r::cast(), change_layer(), compute_farthest_point(), config(), Slic3r::GCodeWriter::config, Slic3r::Print::config(), Slic3r::PrintRegion::config(), Slic3r::ConfigOptionFloat, Slic3r::LayerTools::custom_gcode, Slic3r::ProcessLayer::emit_custom_gcode_per_print_z(), Slic3r::Calib_Params::end, Slic3r::ExtrusionEntityCollection::entities, EPSILON, Slic3r::erMixed, Slic3r::erSupportMaterial, Slic3r::erSupportMaterialInterface, Slic3r::erSupportTransition, Slic3r::LayerTools::extruder(), Slic3r::LayerTools::extruders, Slic3r::Print::extruders(), FILAMENT_CONFIG, Slic3r::LayerRegion::fills, Slic3r::ExtrusionEntityCollection::first_point(), Slic3r::Calib_Params::freqEndX, Slic3r::Calib_Params::freqEndY, Slic3r::Calib_Params::freqStartX, Slic3r::Calib_Params::freqStartY, Slic3r::gcfMarlinFirmware, get_bed_temperature(), get_filament_config_index(), Slic3r::get_flush_volumes_matrix(), get_highest_bed_temperature(), Slic3r::get_imex_active_tools(), get_nozzle_config_index(), Slic3r::PrintBase::get_plate_index(), Slic3r::Print::get_print_region(), Slic3r::WipingExtrusions::get_support_extruder_overrides(), Slic3r::WipingExtrusions::get_support_interface_extruder_overrides(), Slic3r::grid(), Slic3r::Print::has_brim(), Slic3r::LayerTools::has_extruder(), Slic3r::Print::has_infinite_skirt(), Slic3r::LayerTools::has_wipe_tower, Slic3r::GCodeProcessor::Height, Slic3r::Layer::id(), Slic3r::ObjectBase::id(), Slic3r::GCode::ObjectByExtruder::Island::Region::INFILL, Slic3r::PrintObject::instances(), interpolate_value_across_layers(), is_BBL_Printer(), Slic3r::Print::is_BBL_printer(), Slic3r::is_decimal_separator_point(), Slic3r::is_inner_wall(), Slic3r::LayerTools::is_mixed_slot(), Slic3r::GCode::InstanceVisit::islands, Slic3r::kImexPrimaryMode, layer(), Slic3r::GCodeProcessor::Layer_Change, layer_id(), Slic3r::Layer::lslices, m_calib_config, m_config, m_cur_layer_idx, m_enable_cooling_markers, m_enable_loop_clipping, m_extrusion_quality_estimator, m_farthest_point_timelapse, m_imex_head_filament_map, m_imex_parallel_mode, m_last_height, m_last_layer_z, m_layer, m_layer_index, m_max_layer_z, m_object_layer_over_raft, m_ooze_prevention, m_ordering_cache, m_printed_objects, m_second_layer_things_done, m_spiral_vase, m_wipe_tower, m_writer, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::LayerTools::mixed_sub_layer_groups, Slic3r::NormalLift, NOZZLE_CONFIG, Slic3r::Print::num_print_regions(), Slic3r::Layer::object(), object_by_extruder, object_islands_by_extruder, Slic3r::order_points_with_strategy(), Slic3r::overhang_fan_enabled(), Slic3r::GCode::ObjectByExtruder::Island::Region::PERIMETERS, Slic3r::LayerRegion::perimeters, placeholder_parser_process(), Slic3r::prepares_overhang_estimator(), Print, Slic3r::PrintRegion::print_region_id(), Slic3r::GCode::LayerToPrint::print_z(), process_belt_brim_layer(), process_layer_change_gcode(), Slic3r::psI3, Slic3r::SlicingParameters::raft_layers(), Slic3r::LayerRegion::region(), Slic3r::GCodeProcessor::reserved_tag(), Slic3r::resolve_filament_for_head(), retract(), Slic3r::ExtrusionEntityCollection::role(), scale_, Slic3r::GCodeWriter::set_input_shaping(), Slic3r::GCodeWriter::set_jerk_xy(), Slic3r::GCodeWriter::set_junction_deviation(), Slic3r::DynamicConfig::set_key_value(), Slic3r::GCodeWriter::set_pressure_advance(), Slic3r::GCodeWriter::set_temperature(), Slic3r::Calib_Params::shaper_type, Slic3r::PrintObject::slicing_parameters(), sort_print_object_instances(), Slic3r::sort_remove_duplicates(), Slic3r::LayerResult::spiral_vase_enable, Slic3r::SpiralLift, Slic3r::Calib_Params::start, Slic3r::Calib_Params::step, Slic3r::GCode::ObjectByExtruder::support, Slic3r::GCode::ObjectByExtruder::support_extrusion_role, Slic3r::SupportLayer::support_fills, timelapse_gcode_config(), Slic3r::tlTraditional, unretract(), update_layer_related_config(), update_placeholder_parser_with_variant_params(), writer(), Slic3r::zhtAuto, Slic3r::zhtSlope, and Slic3r::zhtSpiral.

Referenced by process_layers().

Here is the caller graph for this function:

process_layer_change_gcode()

std::string Slic3r::GCode::process_layer_change_gcode ( const Print & print, coordf_t print_z, int most_used_extruder, bool has_wipe_tower )

protectedinherited

{
    DynamicConfig config;
    config.set_key_value("most_used_physical_extruder_id", new ConfigOptionInt(m_config.physical_extruder_map.get_at(most_used_extruder)));
    config.set_key_value("layer_num", new ConfigOptionInt(m_layer_index));
    config.set_key_value("layer_z",   new ConfigOptionFloat(print_z));
    config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
    {
        const int  cur_filament_id = (int) m_writer.filament()->id();
        const auto group_result    = m_print->get_layered_nozzle_group_result();
        config.set_key_value("current_filament_id", new ConfigOptionInt(cur_filament_id));
        config.set_key_value("current_nozzle_id", new ConfigOptionInt(
            nozzle_id_for_gcode_placeholder(group_result, cur_filament_id, (int) m_writer.filament()->extruder_id(), m_layer_index)));
    }
 
    PrintStatistics curr_print_statistics;
    for (const Extruder &extruder : m_writer.extruders()) {
        double extruded_volume = extruder.extruded_volume() + (has_wipe_tower ? print.wipe_tower_data().used_filament[extruder.id()] * 2.4052f : 0.f); // assumes 1.75mm filament diameter
        double filament_weight = extruded_volume * extruder.filament_density() * 0.001;
        if (filament_weight > 0.)
            curr_print_statistics.total_weight += filament_weight;
    }
    double curr_y_acceleration_limit = -1, curr_accumulated_mass = -1;
    mass_load_limited_machine_acceleration(curr_print_statistics, print, curr_y_acceleration_limit, curr_accumulated_mass);
    // Runs before this layer prints, so the mass added since the last layer change is the previous layer's.
    double previous_layer_mass = curr_print_statistics.total_weight - m_last_layer_accumulated_mass;
    if (previous_layer_mass <= EPSILON) previous_layer_mass = 0.0;
    m_last_layer_accumulated_mass = curr_print_statistics.total_weight;
    config.set_key_value("curr_y_acceleration_limit", new ConfigOptionFloat(curr_y_acceleration_limit));
    config.set_key_value("curr_accumulated_mass", new ConfigOptionFloat(curr_accumulated_mass));
    config.set_key_value("previous_layer_mass", new ConfigOptionFloat(previous_layer_mass));
    // Bambu Studio's name for previous_layer_mass.
    config.set_key_value("curr_layer_mass", new ConfigOptionFloat(previous_layer_mass));
 
    return this->placeholder_parser_process("layer_change_gcode",
        print.config().layer_change_gcode.value, m_writer.filament()->id(), &config)
        + "\n";
}

References config(), Slic3r::Print::config(), Slic3r::ConfigOptionFloat, EPSILON, m_config, m_last_layer_accumulated_mass, m_layer_index, m_max_layer_z, m_print, m_writer, mass_load_limited_machine_acceleration(), Slic3r::nozzle_id_for_gcode_placeholder(), placeholder_parser_process(), Print, Slic3r::PrintStatistics::total_weight, and Slic3r::Print::wipe_tower_data().

Referenced by process_belt_brim_layer(), and process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

process_layers() [1/2]

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

protectedinherited

{
    // The pipeline is variable: The vase mode filter is optional.
    size_t layer_to_print_idx = 0;
    const auto source = precomputed_layers_source(layer_to_print_idx, layers_to_print.size(), m_pressure_equalizer != nullptr,
        overhang_fan_enabled(print.config(), m_enable_cooling_markers),
        [&layers_to_print](size_t index) -> const std::vector<LayerToPrint> & { return layers_to_print[index].second; });
    const auto generator = tbb::make_filter<PrecomputedLayer, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
        [this, &print, &tool_ordering, &print_object_instances_ordering, &layers_to_print](PrecomputedLayer precomputed) -> LayerResult {
            if (precomputed.index == size_t(-1))
                return LayerResult::make_nop_layer_result();
            const std::pair<coordf_t, std::vector<LayerToPrint>>& layer = layers_to_print[precomputed.index];
            const LayerTools& layer_tools = tool_ordering.tools_for_layer(layer.first);
            print.set_status(80, Slic3r::format(_(L("Generating G-code: layer %1%")), std::to_string(precomputed.index + 1)));
            if (m_wipe_tower && layer_tools.has_wipe_tower)
                m_wipe_tower->next_layer();
            //BBS
            check_placeholder_parser_failed();
            print.throw_if_canceled();
            m_extrusion_quality_estimator.set_precomputed_layers(std::move(precomputed.overhang_layers));
            return this->process_layer(print, layer.second, layer_tools, &layer == &layers_to_print.back(), &print_object_instances_ordering, tool_ordering.get_most_used_extruder(), size_t(-1));
        });
    if (m_spiral_vase) {
        float nozzle_diameter  = EXTRUDER_CONFIG(nozzle_diameter);
        float max_xy_smoothing = m_config.get_abs_value("spiral_mode_max_xy_smoothing", nozzle_diameter);
        this->m_spiral_vase->set_max_xy_smoothing(max_xy_smoothing);
    }
    const auto spiral_mode = tbb::make_filter<LayerResult, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
        [&spiral_mode = *this->m_spiral_vase.get(), &layers_to_print](LayerResult in) -> LayerResult {
          if (in.nop_layer_result)
                return in;
                
            spiral_mode.enable(in.spiral_vase_enable);
            bool last_layer = in.layer_id == layers_to_print.size() - 1;
            return { spiral_mode.process_layer(std::move(in.gcode), last_layer), in.layer_id, in.spiral_vase_enable, in.cooling_buffer_flush};
        });
    const auto pressure_equalizer = tbb::make_filter<LayerResult, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
        [pressure_equalizer = this->m_pressure_equalizer.get()](LayerResult in) -> LayerResult {
            return pressure_equalizer->process_layer(std::move(in));
        });
    const auto cooling = tbb::make_filter<LayerResult, std::string>(slic3r_tbb_filtermode::serial_in_order,
        [&cooling_buffer = *this->m_cooling_buffer.get()](LayerResult in) -> std::string {
          if (in.nop_layer_result)
                return in.gcode;
            return cooling_buffer.process_layer(std::move(in.gcode), in.layer_id, in.cooling_buffer_flush);
        });
    const auto pa_processor_filter = tbb::make_filter<std::string, std::string>(slic3r_tbb_filtermode::serial_in_order,
            [&pa_processor = *this->m_pa_processor](std::string in) -> std::string {
                return pa_processor.process_layer(std::move(in));
            }
        );
    
    const auto output = tbb::make_filter<std::string, void>(slic3r_tbb_filtermode::serial_in_order,
        [&output_stream](std::string s) { output_stream.write(s); }
    );
 
    const auto fan_mover = tbb::make_filter<std::string, std::string>(slic3r_tbb_filtermode::serial_in_order,
            [&fan_mover = this->m_fan_mover, &config = this->config(), &writer = this->m_writer](std::string in)->std::string {
 
        CNumericLocalesSetter locales_setter;
 
        if (config.fan_speedup_time.value != 0 || config.fan_kickstart.value > 0) {
            if (fan_mover.get() == nullptr)
                fan_mover.reset(new Slic3r::FanMover(
                    writer,
                    std::abs((float)config.fan_speedup_time.value),
                    config.fan_speedup_time.value > 0,
                    config.use_relative_e_distances.value,
                    config.fan_speedup_overhangs.value,
                    (float)config.fan_kickstart.value));
            //flush as it's a whole layer
            return fan_mover->process_gcode(in, true);
        }
        return in;
    });
 
    // The pipeline elements are joined using const references, thus no copying is performed.
    if (m_spiral_vase && m_pressure_equalizer)
        tbb::parallel_pipeline(12, source & generator & spiral_mode & pressure_equalizer & cooling & fan_mover & output);
    else if (m_spiral_vase)
      tbb::parallel_pipeline(12, source & generator & spiral_mode & cooling & fan_mover & output);
    else if (m_pressure_equalizer)
        tbb::parallel_pipeline(12, source & generator & pressure_equalizer & cooling & fan_mover & pa_processor_filter & output);
    else
      tbb::parallel_pipeline(12, source & generator & cooling & fan_mover & pa_processor_filter & output);
    // The estimator's precomputed data points into this print's layers.
    m_extrusion_quality_estimator.set_precomputed_layers({});
 
}

References _, check_placeholder_parser_failed(), Slic3r::Print::config(), EXTRUDER_CONFIG, Slic3r::format(), Slic3r::ToolOrdering::get_most_used_extruder(), Slic3r::LayerTools::has_wipe_tower, L, layer(), m_config, m_enable_cooling_markers, m_extrusion_quality_estimator, m_pressure_equalizer, m_spiral_vase, m_wipe_tower, Slic3r::LayerResult::make_nop_layer_result(), Slic3r::nozzle_diameter(), Slic3r::overhang_fan_enabled(), Slic3r::precomputed_layers_source(), Print, process_layer(), Slic3r::PrintBase::set_status(), Slic3r::PrintBase::throw_if_canceled(), and Slic3r::ToolOrdering::tools_for_layer().

Referenced by _do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

process_layers() [2/2]

void Slic3r::GCode::process_layers ( const Print & print, const ToolOrdering & tool_ordering, std::vector< LayerToPrint > layers_to_print, const size_t single_object_idx, GCodeOutputStream & output_stream, const bool prime_extruder = false )

protectedinherited

{
    // The pipeline is variable: The vase mode filter is optional.
    size_t layer_to_print_idx = 0;
    const auto source = precomputed_layers_source(layer_to_print_idx, layers_to_print.size(), m_pressure_equalizer != nullptr,
        overhang_fan_enabled(print.config(), m_enable_cooling_markers),
        [&layers_to_print](size_t index) { return std::vector<LayerToPrint>{layers_to_print[index]}; });
    const auto generator = tbb::make_filter<PrecomputedLayer, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
        [this, &print, &tool_ordering, &layers_to_print, single_object_idx, prime_extruder](PrecomputedLayer precomputed) -> LayerResult {
            if (precomputed.index == size_t(-1))
                return LayerResult::make_nop_layer_result();
            LayerToPrint &layer = layers_to_print[precomputed.index];
            print.set_status(80, Slic3r::format(_(L("Generating G-code: layer %1%")), std::to_string(precomputed.index + 1)));
            //BBS
            check_placeholder_parser_failed();
            print.throw_if_canceled();
            m_extrusion_quality_estimator.set_precomputed_layers(std::move(precomputed.overhang_layers));
            return this->process_layer(print, { std::move(layer) }, tool_ordering.tools_for_layer(layer.print_z()), &layer == &layers_to_print.back(), nullptr, tool_ordering.get_most_used_extruder(), single_object_idx, prime_extruder);
        });
    if (m_spiral_vase) {
        float nozzle_diameter  = EXTRUDER_CONFIG(nozzle_diameter);
        float max_xy_smoothing = m_config.get_abs_value("spiral_mode_max_xy_smoothing", nozzle_diameter);
        this->m_spiral_vase->set_max_xy_smoothing(max_xy_smoothing);
    }
    const auto spiral_mode = tbb::make_filter<LayerResult, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
        [&spiral_mode = *this->m_spiral_vase.get(), &layers_to_print](LayerResult in)->LayerResult {
            if (in.nop_layer_result)
                return in;
            spiral_mode.enable(in.spiral_vase_enable);
            bool last_layer = in.layer_id == layers_to_print.size() - 1;
            return { spiral_mode.process_layer(std::move(in.gcode), last_layer), in.layer_id, in.spiral_vase_enable, in.cooling_buffer_flush };
        });
    const auto pressure_equalizer = tbb::make_filter<LayerResult, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
        [pressure_equalizer = this->m_pressure_equalizer.get()](LayerResult in) -> LayerResult {
             return pressure_equalizer->process_layer(std::move(in));
        });
    const auto cooling = tbb::make_filter<LayerResult, std::string>(slic3r_tbb_filtermode::serial_in_order,
        [&cooling_buffer = *this->m_cooling_buffer.get()](LayerResult in)->std::string {
            if (in.nop_layer_result)
                return in.gcode;
            return cooling_buffer.process_layer(std::move(in.gcode), in.layer_id, in.cooling_buffer_flush);
        });
    const auto pa_processor_filter = tbb::make_filter<std::string, std::string>(slic3r_tbb_filtermode::serial_in_order,
        [&pa_processor = *this->m_pa_processor](std::string in) -> std::string {
            return pa_processor.process_layer(std::move(in));
        }
    );
    
    const auto output = tbb::make_filter<std::string, void>(slic3r_tbb_filtermode::serial_in_order,
        [&output_stream](std::string s) { output_stream.write(s); }
    );
 
    const auto fan_mover = tbb::make_filter<std::string, std::string>(slic3r_tbb_filtermode::serial_in_order,
        [&fan_mover = this->m_fan_mover, &config = this->config(), &writer = this->m_writer](std::string in)->std::string {
 
        if (config.fan_speedup_time.value != 0 || config.fan_kickstart.value > 0) {
            if (fan_mover.get() == nullptr)
                fan_mover.reset(new Slic3r::FanMover(
                    writer,
                    std::abs((float)config.fan_speedup_time.value),
                    config.fan_speedup_time.value > 0,
                    config.use_relative_e_distances.value,
                    config.fan_speedup_overhangs.value,
                    (float)config.fan_kickstart.value));
            //flush as it's a whole layer
            return fan_mover->process_gcode(in, true);
        }
        return in;
    });
 
    // The pipeline elements are joined using const references, thus no copying is performed.
    if (m_spiral_vase && m_pressure_equalizer)
        tbb::parallel_pipeline(12, source & generator & spiral_mode & pressure_equalizer & cooling & fan_mover & output);
    else if (m_spiral_vase)
      tbb::parallel_pipeline(12, source & generator & spiral_mode & cooling & fan_mover & output);
    else if (m_pressure_equalizer)
        tbb::parallel_pipeline(12, source & generator & pressure_equalizer & cooling & fan_mover & pa_processor_filter & output);
    else
      tbb::parallel_pipeline(12, source & generator & cooling & fan_mover & pa_processor_filter & output);
    // The estimator's precomputed data points into this print's layers.
    m_extrusion_quality_estimator.set_precomputed_layers({});
}

References Slic3r::Print::config(), m_enable_cooling_markers, m_pressure_equalizer, Slic3r::overhang_fan_enabled(), Slic3r::precomputed_layers_source(), and Print.

Here is the call graph for this function:

retract()

std::string Slic3r::GCode::retract ( bool toolchange = false, bool is_last_retraction = false, LiftType lift_type = LiftType::NormalLift, bool apply_instantly = false, ExtrusionRole role = erNone )

inherited

{
    std::string gcode;
 
    if (m_writer.filament() == nullptr)
        return gcode;
 
    // wipe (if it's enabled for this extruder and we have a stored wipe path and no-zero wipe distance)
    if (FILAMENT_CONFIG(wipe) && m_wipe.has_path() && scale_(FILAMENT_CONFIG(wipe_distance)) > SCALED_EPSILON) {
        Wipe::RetractionValues wipeRetractions = m_wipe.calculateWipeRetractionLengths(*this, toolchange);
        gcode += toolchange ? m_writer.retract_for_toolchange(true, wipeRetractions.retraction_length_before_wipe) :
                              m_writer.retract(true, wipeRetractions.retraction_length_before_wipe);
        gcode += m_wipe.wipe(*this, wipeRetractions.retraction_length_during_wipe, toolchange, is_last_retraction);
 
        // Orca: wipeRetractions.retraction_length_after_wipe is not being used explicitly,
        // the remaining retraction after wipe is handled by the subsequent m_writer.retract() call
    }
 
    /*  The parent class will decide whether we need to perform an actual retraction
        (the extruder might be already retracted fully or partially). We call these
        methods even if we performed wipe, since this will ensure the entire retraction
        length is honored in case wipe path was too short.  */
    if ((!this->on_first_layer()  || this->config().bottom_surface_pattern != InfillPattern::ipHilbertCurve) &&
      (role != erTopSolidInfill || this->config().top_surface_pattern    != InfillPattern::ipHilbertCurve))
        gcode += toolchange ? m_writer.retract_for_toolchange() : m_writer.retract();
 
    gcode += m_writer.reset_e();
    // Orca: check if should + can lift (roughly from SuperSlicer)
    RetractLiftEnforceType retract_lift_type = RetractLiftEnforceType(EXTRUDER_CONFIG(retract_lift_enforce));
 
    bool needs_lift = toolchange
        || m_writer.filament()->retraction_length() > 0
        || m_config.use_firmware_retraction;
 
    bool last_fill_extrusion_role_top_infill = (this->m_last_notgapfill_extrusion_role == ExtrusionRole::erTopSolidInfill || this->m_last_notgapfill_extrusion_role == ExtrusionRole::erIroning);
 
    // assume we can lift on retraction; conditions left explicit 
    bool can_lift = true;
 
    if (retract_lift_type == RetractLiftEnforceType::rletAllSurfaces) {
        can_lift = true;
    }
    else if (this->m_layer_index == 0 && (retract_lift_type == RetractLiftEnforceType::rletBottomOnly || retract_lift_type == RetractLiftEnforceType::rletTopAndBottom)) {
        can_lift = true;
    }
    else if (retract_lift_type == RetractLiftEnforceType::rletTopOnly || retract_lift_type == RetractLiftEnforceType::rletTopAndBottom) {
        can_lift = last_fill_extrusion_role_top_infill;
    }
    else {
        can_lift = false;
    }
 
    if (needs_lift && can_lift) {
        if (apply_instantly)
            gcode += m_writer.eager_lift(lift_type);
        else
            gcode += m_writer.lazy_lift(lift_type, m_spiral_vase != nullptr);
    }
 
    return gcode;
}

References config(), Slic3r::erIroning, Slic3r::erTopSolidInfill, EXTRUDER_CONFIG, FILAMENT_CONFIG, Slic3r::ipHilbertCurve, m_config, m_last_notgapfill_extrusion_role, m_layer_index, m_spiral_vase, m_wipe, m_writer, on_first_layer(), Slic3r::Wipe::RetractionValues::retraction_length_before_wipe, Slic3r::Wipe::RetractionValues::retraction_length_during_wipe, Slic3r::rletAllSurfaces, Slic3r::rletBottomOnly, Slic3r::rletTopAndBottom, Slic3r::rletTopOnly, scale_, SCALED_EPSILON, Slic3r::top_surface_pattern(), and Slic3r::wipe().

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_extruder()

std::string Slic3r::GCode::set_extruder ( unsigned int extruder_id, double print_z, bool by_object = false, int toolchange_temp_override = -1, bool defer_temp_wait = false )

inherited

{
    int new_extruder_id = get_extruder_id(new_filament_id);
    if (!m_writer.need_toolchange(new_filament_id))
        return "";
 
    const std::optional<ToolchangePositionState> position_before_toolchange =
        this->capture_toolchange_position();
 
    // if we are running a single-extruder setup, just set the extruder and return nothing
    if (!m_writer.multiple_extruders) {
        this->placeholder_parser().set("current_extruder", new_filament_id);
        // Orca: keep the global current-tool identity coherent even on the single-extruder path (see append_tcr).
        this->placeholder_parser().set("current_filament_id", (int) new_filament_id);
        this->placeholder_parser().set("current_extruder_id", new_extruder_id);
        this->placeholder_parser().set("current_nozzle_id",
            nozzle_id_for_gcode_placeholder(m_print->get_layered_nozzle_group_result(), (int) new_filament_id, new_extruder_id, m_layer_index));
        this->placeholder_parser().set("current_hotend",
            hotend_id_for_gcode_placeholder(m_print->get_layered_nozzle_group_result(), m_print->is_BBL_printer(), (int) new_filament_id,
                                            new_extruder_id, m_layer_index));
        {
            size_t fi = get_filament_config_index(new_filament_id);
            this->placeholder_parser().set("retraction_distance_when_ec", m_config.retraction_distances_when_ec.get_at(fi));
            this->placeholder_parser().set("long_retraction_when_ec", m_config.long_retractions_when_ec.get_at(fi));
        }
 
        std::string gcode;
        // Append the filament start G-code.
        const std::string &filament_start_gcode = m_config.filament_start_gcode.get_at(new_filament_id);
        if (! filament_start_gcode.empty()) {
            // Process the filament_start_gcode for the filament.
            DynamicConfig config;
            config.set_key_value("layer_num", new ConfigOptionInt(m_layer_index));
            config.set_key_value("layer_z", new ConfigOptionFloat(this->writer().get_position().z() - m_config.z_offset.value));
            config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
            config.set_key_value("filament_extruder_id", new ConfigOptionInt(int(new_filament_id)));
            {
                size_t fi = get_filament_config_index(new_filament_id);
                config.set_key_value("retraction_distance_when_cut",
                                     new ConfigOptionFloat(m_config.retraction_distances_when_cut.get_at(fi)));
                config.set_key_value("long_retraction_when_cut", new ConfigOptionBool(m_config.long_retractions_when_cut.get_at(fi)));
            }
 
            gcode += this->placeholder_parser_process("filament_start_gcode", filament_start_gcode, new_filament_id, &config);
            check_add_eol(gcode);
        }
        // In IMEX parallel modes each carriage needs an explicit tool address. In primary
        // mode, and on a non-IMEX printer, imex_pem_tool_for() returns -1 and the qualifier
        // is omitted, because regular tool changes already handle PA there.
        gcode += set_filament_pressure_advance(new_filament_id,
            imex_pem_tool_for((int) new_filament_id, m_imex_parallel_mode, m_config.physical_extruder_map));
 
        // Same suppression as the long multi-extruder path: at print-start in IMEX
        // parallel modes the user's mode_gcode + machine_start_gcode is responsible
        // for tool selection, so the slicer's bare T<n> would be a duplicate. Mid-
        // print toolchanges (count > 1) emit normally — Print::validate() blocks
        // multi-color in configurations where mid-print T<n> wouldn't make sense
        // (see imex_multicolor_block_reason).
        const std::string toolchange_command = m_writer.toolchange(new_filament_id, new_extruder_id);
        if (!imex_suppresses_bare_toolchange(m_imex_parallel_mode, m_toolchange_count))
            gcode += toolchange_command;
        if (Extruder *fil = m_writer.filament())
            fil->set_config_index((int)get_filament_config_index((int)fil->id()));
        if (position_before_toolchange)
            this->synchronize_toolchange_position(*position_before_toolchange, gcode);
        return gcode;
    }
 
    // BBS. Should be placed before retract.
    m_toolchange_count++;
 
    // prepend retraction on the current extruder
    std::string gcode = this->retract(true, false);
 
    // Always reset the extrusion path, even if the tool change retract is set to zero.
    m_wipe.reset_path();
 
    // BBS: insert skip object label before change filament while by object
    if (by_object)
        m_writer.add_object_change_labels(gcode);
 
    bool add_change_filament_624 = false;
    if (m_writer.filament() != nullptr) {
        // Process the custom filament_end_gcode. set_extruder() is only called if there is no wipe tower
        // so it should not be injected twice.
        unsigned int        old_filament_id = m_writer.filament()->id();
        const std::string  &filament_end_gcode  = m_config.filament_end_gcode.get_at(old_filament_id);
        if (! filament_end_gcode.empty()) {
            DynamicConfig config;
            config.set_key_value("layer_num", new ConfigOptionInt(m_layer_index));
            config.set_key_value("layer_z",   new ConfigOptionFloat(m_writer.get_position().z() - m_config.z_offset.value));
            config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
            config.set_key_value("filament_extruder_id", new ConfigOptionInt(int(get_extruder_id(old_filament_id))));
            if (!m_filament_instances_code.empty()) {
                gcode += ("M624 " + m_filament_instances_code + "\n");
                m_filament_instances_code = "";
                add_change_filament_624   = true;
            }
            gcode += placeholder_parser_process("filament_end_gcode", filament_end_gcode, old_filament_id, &config);
            check_add_eol(gcode);
        }
    }
 
 
    // If ooze prevention is enabled, park current extruder in the nearest
    // standby point and set it to the standby temperature.
    //
    // Same-physical short-circuit: on an IMEX printer, skip the standby cool-down when the
    // old and new filament both route to the same physical extruder via physical_extruder_map
    // (AFC/MMU lane swaps where the active heater stays selected and only the lane changes).
    // The cool-down → re-heat round trip is pointless there — same nozzle, same heater, just a
    // different filament feeding it. post_toolchange below still emits M109 to the new
    // filament's print temp, so per-lane temperature differences are still handled.
    //
    // Gated on is_imex so ooze prevention behaves exactly as upstream on every other printer.
    // 73 shipping profiles enable it by default (Snapmaker, Flashforge, Prusa and others) and
    // none of them are asking for this optimisation.
    auto same_physical_extruder = [&](int a, int b) {
        if (!m_config.is_imex.value)
            return false;
        const auto& pem = m_config.physical_extruder_map.values;
        return !pem.empty() && a >= 0 && b >= 0
            && a < (int)pem.size() && b < (int)pem.size()
            && pem[a] == pem[b];
    };
    if (m_ooze_prevention.enable && m_writer.filament() != nullptr
        && !same_physical_extruder(m_writer.filament()->id(), (int)new_filament_id))
        gcode += m_ooze_prevention.pre_toolchange(*this);
 
    // BBS
    // Per-variant filament arrays can hold one column per variant a filament uses under a
    // per-layer nozzle grouping; resolve the column instead of indexing by the filament id.
    size_t new_fi = get_filament_config_index((int)new_filament_id);
    float new_retract_length = m_config.retraction_length.get_at(new_fi);
    float new_retract_length_toolchange = m_config.retract_length_toolchange.get_at(new_fi);
    int new_filament_temp = this->on_first_layer() ? m_config.nozzle_temperature_initial_layer.get_at(new_fi) : m_config.nozzle_temperature.get_at(new_fi);
    // BBS: if print_z == 0 use first layer temperature
    if (abs(print_z) < EPSILON)
        new_filament_temp = m_config.nozzle_temperature_initial_layer.get_at(new_fi);
    if (toolchange_temp_override > 0)
        new_filament_temp = toolchange_temp_override;
 
    // With wait_for_temp_on_wipe_tower the blocking M109 is deferred to the wipe tower, so raise
    // the incoming filament's target here — ahead of the tool change rather than after it — and
    // let the heat-up overlap the change itself as well as the travel to the tower. The command
    // always carries an explicit tool index (the option is off for single extruder MM, so the
    // writer emits one), leaving the outgoing filament that pre_toolchange just dropped to its
    // standby temperature alone. nozzle_temperature == 0 means "use the first layer temperature".
    if (defer_temp_wait) {
        // Target what the tower will wait on. It waits on the first layer temperature not only on
        // the first layer but also while priming, which runs before any layer is set: there
        // on_first_layer() is false and print_z is the initial layer height, so neither test above
        // catches it. nozzle_temperature == 0 means "use the first layer temperature" as well.
        int preheat_temp = new_filament_temp;
        if (toolchange_temp_override <= 0 && (m_layer == nullptr || preheat_temp <= 0))
            preheat_temp = m_config.nozzle_temperature_initial_layer.get_at(new_fi);
        if (preheat_temp > 0)
            gcode += m_writer.set_temperature(preheat_temp, false, new_filament_id);
    }
 
    Vec3d nozzle_pos = m_writer.get_position();
    float old_retract_length, old_retract_length_toolchange, wipe_volume;
    int old_filament_temp, old_filament_e_feedrate;
 
    float filament_area = float((M_PI / 4.f) * pow(m_config.filament_diameter.get_at(new_filament_id), 2));
    //BBS: add handling for filament change in start gcode
    int old_filament_id = -1;
    int old_extruder_id = -1;
    if (m_writer.filament() != nullptr || m_start_gcode_filament != -1) {
        std::vector<float> flush_matrix(cast<float>(get_flush_volumes_matrix(m_config.flush_volumes_matrix.values, new_extruder_id, m_config.nozzle_diameter.values.size())));
        const unsigned int number_of_extruders = (unsigned int) (m_config.filament_colour.values.size()); // if is multi_extruder only use the fist extruder matrix
        if (m_writer.filament() != nullptr)
            assert(m_writer.filament()->id() < number_of_extruders);
        else
            assert(m_start_gcode_filament < number_of_extruders);
 
        old_filament_id = m_writer.filament() != nullptr ? m_writer.filament()->id() : m_start_gcode_filament;
        old_extruder_id = m_writer.filament() != nullptr ? m_writer.filament()->extruder_id() : get_extruder_id(m_start_gcode_filament);
 
        // Resolving the old filament at the current layer is safe: the per-layer nozzle maps are
        // gap-filled carry-forward, so its current-layer column matches the nozzle it occupies.
        size_t old_fi = get_filament_config_index(old_filament_id);
        old_retract_length = m_config.retraction_length.get_at(old_fi);
        old_retract_length_toolchange = m_config.retract_length_toolchange.get_at(old_fi);
        old_filament_temp = this->on_first_layer()? m_config.nozzle_temperature_initial_layer.get_at(old_fi) : m_config.nozzle_temperature.get_at(old_fi);
 
        //During the filament change, the extruder will extrude an extra length of grab_length for the corresponding detection, so the purge can reduce this length.
        float grab_purge_volume = m_config.grab_length.get_at(new_extruder_id) * 2.4;
        if (old_extruder_id != new_extruder_id) {
            //calc flush volume between the same extruder id
            int old_filament_id_in_new_extruder = m_writer.filament(new_extruder_id) != nullptr ? m_writer.filament(new_extruder_id)->id() : -1;
            if (old_filament_id_in_new_extruder == -1)
                wipe_volume = 0;
            else {
                size_t flush_idx = size_t(old_filament_id_in_new_extruder) * number_of_extruders + new_filament_id;
                wipe_volume = flush_idx < flush_matrix.size() ? flush_matrix[flush_idx] : 0.f;
                wipe_volume *= m_config.flush_multiplier.get_at(new_extruder_id);
            }
        }
        else {
            size_t flush_idx = size_t(old_filament_id) * number_of_extruders + new_filament_id;
            wipe_volume = flush_idx < flush_matrix.size() ? flush_matrix[flush_idx] : 0.f;
            wipe_volume *= m_config.flush_multiplier.get_at(new_extruder_id);  // if is multi_extruder only use the fist extruder matrix
        }
        wipe_volume = std::max(0.f, wipe_volume-grab_purge_volume);
 
        old_filament_e_feedrate = (int) (60.0 * m_config.filament_max_volumetric_speed.get_at(old_fi) / filament_area);
        old_filament_e_feedrate = old_filament_e_feedrate == 0 ? 100 : old_filament_e_feedrate;
        //BBS: must clean m_start_gcode_filament
        m_start_gcode_filament = -1;
    } else {
        old_retract_length = 0.f;
        old_retract_length_toolchange = 0.f;
        old_filament_temp = 0;
        wipe_volume = 0.f;
        old_filament_e_feedrate = 200;
    }
    float wipe_length = wipe_volume / filament_area;
    int new_filament_e_feedrate = (int)(60.0 * m_config.filament_max_volumetric_speed.get_at(new_fi) / filament_area);
    new_filament_e_feedrate = new_filament_e_feedrate == 0 ? 100 : new_filament_e_feedrate;
 
    // set volumetric speed of outer wall ,ignore per obejct,just use default setting
    float outer_wall_volumetric_speed = get_outer_wall_volumetric_speed(m_config, *m_print, new_filament_id, (int)new_fi, get_extruder_id(new_filament_id));
    float         wipe_avoid_pos_x            = 110.f;
    // Logical nozzle grouping (null on paths that don't populate it) + null-safe nozzle ids.
    auto group_result   = m_print->get_layered_nozzle_group_result();
    int  old_nozzle_id  = nozzle_id_for_gcode_placeholder(group_result, old_filament_id, old_extruder_id, m_layer_index);
    int  next_nozzle_id = nozzle_id_for_gcode_placeholder(group_result, (int) new_filament_id, new_extruder_id, m_layer_index);
    DynamicConfig dyn_config;
    dyn_config.set_key_value("outer_wall_volumetric_speed", new ConfigOptionFloat(outer_wall_volumetric_speed));
    dyn_config.set_key_value("previous_extruder", new ConfigOptionInt(old_filament_id));
    dyn_config.set_key_value("next_extruder", new ConfigOptionInt((int)new_filament_id));
    dyn_config.set_key_value("current_hotend", new ConfigOptionInt(
        hotend_id_for_gcode_placeholder(group_result, m_print->is_BBL_printer(), old_filament_id, old_extruder_id, m_layer_index)));
    dyn_config.set_key_value("next_hotend", new ConfigOptionInt(
        hotend_id_for_gcode_placeholder(group_result, m_print->is_BBL_printer(), (int) new_filament_id, new_extruder_id, m_layer_index)));
    dyn_config.set_key_value("current_nozzle_id", new ConfigOptionInt(old_nozzle_id));
    dyn_config.set_key_value("next_nozzle_id", new ConfigOptionInt(next_nozzle_id));
    dyn_config.set_key_value("current_filament_id", new ConfigOptionInt(old_filament_id));
    dyn_config.set_key_value("next_filament_id", new ConfigOptionInt((int)new_filament_id));
    // Orca: nozzle-volume variant of the old/new extruder (see append_tcr). Null-safe: old_extruder_id may be -1.
    {
        const auto &extruder_variants = m_config.printer_extruder_variant.values;
        dyn_config.set_key_value("old_extruder_variant", new ConfigOptionString(
            (old_extruder_id >= 0 && old_extruder_id < (int) extruder_variants.size()) ? extruder_variants[old_extruder_id] : std::string()));
        dyn_config.set_key_value("new_extruder_variant", new ConfigOptionString(
            (new_extruder_id >= 0 && new_extruder_id < (int) extruder_variants.size()) ? extruder_variants[new_extruder_id] : std::string()));
    }
    dyn_config.set_key_value("nozzle_diameter_at_nozzle_id", new ConfigOptionFloats(get_nozzle_diameters_by_nozzle_id(group_result.get())));
    dyn_config.set_key_value("nozzle_volume_types", new ConfigOptionStrings(get_nozzle_volume_types_by_nozzle_id(group_result.get())));
    // Old filament's nozzle-change retract length (filament_retract_length_nc; nil/-1 -> 0).
    dyn_config.set_key_value("filament_retract_length_nc", new ConfigOptionFloat(
        (old_filament_id != -1) ? (float) m_config.filament_retract_length_nc.get_at(get_filament_config_index(old_filament_id)) : 0.f));
    // Current parked-retract length of the incoming filament's extruder.
    dyn_config.set_key_value("new_extruder_retracted_length",
        new ConfigOptionFloat(m_writer.get_extruder_retracted_length((int) new_filament_id)));
    dyn_config.set_key_value("layer_num", new ConfigOptionInt(m_layer_index));
    dyn_config.set_key_value("layer_z", new ConfigOptionFloat(print_z));
    dyn_config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
    dyn_config.set_key_value("relative_e_axis", new ConfigOptionBool(m_config.use_relative_e_distances));
    dyn_config.set_key_value("toolchange_count", new ConfigOptionInt((int)m_toolchange_count));
    //BBS: fan speed is useless placeholer now, but we don't remove it to avoid
    //slicing error in old change_filament_gcode in old 3MF
    dyn_config.set_key_value("fan_speed", new ConfigOptionInt((int)0));
    dyn_config.set_key_value("old_retract_length", new ConfigOptionFloat(old_retract_length));
    dyn_config.set_key_value("new_retract_length", new ConfigOptionFloat(new_retract_length));
    dyn_config.set_key_value("old_retract_length_toolchange", new ConfigOptionFloat(old_retract_length_toolchange));
    dyn_config.set_key_value("new_retract_length_toolchange", new ConfigOptionFloat(new_retract_length_toolchange));
    dyn_config.set_key_value("old_filament_temp", new ConfigOptionInt(old_filament_temp));
    dyn_config.set_key_value("new_filament_temp", new ConfigOptionInt(new_filament_temp));
    dyn_config.set_key_value("x_after_toolchange", new ConfigOptionFloat(nozzle_pos(0)));
    dyn_config.set_key_value("y_after_toolchange", new ConfigOptionFloat(nozzle_pos(1)));
    dyn_config.set_key_value("z_after_toolchange", new ConfigOptionFloat(nozzle_pos(2)));
    dyn_config.set_key_value("first_flush_volume", new ConfigOptionFloat(wipe_length / 2.f));
    dyn_config.set_key_value("second_flush_volume", new ConfigOptionFloat(wipe_length / 2.f));
    dyn_config.set_key_value("old_filament_e_feedrate", new ConfigOptionInt(old_filament_e_feedrate));
    dyn_config.set_key_value("new_filament_e_feedrate", new ConfigOptionInt(new_filament_e_feedrate));
    dyn_config.set_key_value("travel_point_1_x", new ConfigOptionFloat(float(travel_point_1.x())));
    dyn_config.set_key_value("travel_point_1_y", new ConfigOptionFloat(float(travel_point_1.y())));
    dyn_config.set_key_value("travel_point_2_x", new ConfigOptionFloat(float(travel_point_2.x())));
    dyn_config.set_key_value("travel_point_2_y", new ConfigOptionFloat(float(travel_point_2.y())));
    dyn_config.set_key_value("travel_point_3_x", new ConfigOptionFloat(float(travel_point_3.x())));
    dyn_config.set_key_value("travel_point_3_y", new ConfigOptionFloat(float(travel_point_3.y())));
    dyn_config.set_key_value("wipe_avoid_perimeter", new ConfigOptionBool(false));
    dyn_config.set_key_value("wipe_avoid_pos_x", new ConfigOptionFloat(wipe_avoid_pos_x));
    dyn_config.set_key_value("is_prime_tower_interface", new ConfigOptionBool(false));
    dyn_config.set_key_value("filament_tower_interface_purge_volume", new ConfigOptionFloat(m_config.filament_tower_interface_purge_volume.get_at(new_filament_id)));
    {
        int interface_temp = m_config.filament_tower_interface_print_temp.get_at(new_filament_id);
        if (interface_temp == -1)
            interface_temp = m_config.nozzle_temperature_range_high.get_at(new_fi);
        dyn_config.set_key_value("filament_tower_interface_print_temp", new ConfigOptionInt(interface_temp));
    }
    if (toolchange_temp_override > 0) {
        // Rebuild in filament order: the config arrays may carry per-variant columns, while
        // these placeholder vectors are consumed indexed by filament id.
        size_t num_filaments = m_print->config().filament_type.values.size();
        std::vector<int> temps(num_filaments);
        std::vector<int> first_layer_temps(num_filaments);
        for (size_t i = 0; i < num_filaments; ++i) {
            size_t fi_i = get_filament_config_index((int)i);
            temps[i]             = m_config.nozzle_temperature.get_at(fi_i);
            first_layer_temps[i] = m_config.nozzle_temperature_initial_layer.get_at(fi_i);
        }
        if (new_filament_id < temps.size())
            temps[new_filament_id] = toolchange_temp_override;
        dyn_config.set_key_value("temperature", new ConfigOptionInts(temps));
        dyn_config.set_key_value("nozzle_temperature", new ConfigOptionInts(temps));
        if (new_filament_id < first_layer_temps.size())
            first_layer_temps[new_filament_id] = toolchange_temp_override;
        dyn_config.set_key_value("first_layer_temperature", new ConfigOptionInts(first_layer_temps));
        dyn_config.set_key_value("nozzle_temperature_initial_layer", new ConfigOptionInts(first_layer_temps));
    }
 
    {
        size_t num_filaments = m_print->config().filament_type.values.size();
        // Fast purge mode uses filament_flush_temp_fast; Default is inert.
        bool   use_fast_flush = m_print->config().prime_volume_mode == PrimeVolumeMode::pvmFast;
        std::vector<double> flush_v_speed(num_filaments);
        std::vector<int>    flush_temps(num_filaments);
        std::vector<double> filament_cooling_before_tower(num_filaments);
        for (size_t idx = 0; idx < num_filaments; ++idx) {
            size_t fi = get_filament_config_index(idx);
            flush_v_speed[idx] = m_print->config().filament_flush_volumetric_speed.get_at(fi);
            if (flush_v_speed[idx] == 0)
                flush_v_speed[idx] = m_print->config().filament_max_volumetric_speed.get_at(fi);
            flush_temps[idx] = use_fast_flush ? m_print->config().filament_flush_temp_fast.get_at(fi)
                                              : m_print->config().filament_flush_temp.get_at(fi);
            if (flush_temps[idx] == 0)
                flush_temps[idx] = m_print->config().nozzle_temperature_range_high.get_at(fi);
            filament_cooling_before_tower[idx] = m_print->config().filament_cooling_before_tower.get_at(fi);
        }
        std::fill(filament_cooling_before_tower.begin(), filament_cooling_before_tower.end(), 0);
        dyn_config.set_key_value("flush_volumetric_speeds", new ConfigOptionFloats(flush_v_speed));
        dyn_config.set_key_value("flush_temperatures", new ConfigOptionInts(flush_temps));
        dyn_config.set_key_value("filament_cooling_before_tower", new ConfigOptionFloats(filament_cooling_before_tower));
    }
    dyn_config.set_key_value("flush_length", new ConfigOptionFloat(wipe_length));
 
    int flush_count = std::min(g_max_flush_count, (int)std::round(wipe_volume / g_purge_volume_one_time));
    float flush_unit = wipe_length / flush_count;
    int flush_idx = 0;
    for (; flush_idx < flush_count; flush_idx++) {
        char key_value[64] = { 0 };
        snprintf(key_value, sizeof(key_value), "flush_length_%d", flush_idx + 1);
        dyn_config.set_key_value(key_value, new ConfigOptionFloat(flush_unit));
    }
 
    for (; flush_idx < g_max_flush_count; flush_idx++) {
        char key_value[64] = { 0 };
        snprintf(key_value, sizeof(key_value), "flush_length_%d", flush_idx + 1);
        dyn_config.set_key_value(key_value, new ConfigOptionFloat(0.f));
    }
 
    // Process the custom change_filament_gcode.
    std::string change_filament_gcode = m_config.change_filament_gcode.value;
 
    // Move the lift gcode here which is in the change_filament_gcode originally
    change_filament_gcode = this->retract(false, false, LiftType::SpiralLift, true) + change_filament_gcode;
 
    std::string toolchange_gcode_parsed;
    //Orca: Ignore change_filament_gcode if is the first call for a tool change and manual_filament_change is enabled
    if (!change_filament_gcode.empty() && !(m_config.manual_filament_change.value && m_toolchange_count == 1)) {
        dyn_config.set_key_value("toolchange_z", new ConfigOptionFloat(print_z));
 
        toolchange_gcode_parsed = placeholder_parser_process("change_filament_gcode", change_filament_gcode, new_filament_id, &dyn_config);
        check_add_eol(toolchange_gcode_parsed);
        // toolchange_gcode_parsed is still read below (get_last_z_from_gcode, custom_gcode_changes_tool).
        gcode += wrap_custom_gcode_for_fan_mover(m_config, toolchange_gcode_parsed);
 
        //BBS
        {
            //BBS: gcode writer doesn't know where the extruder is and whether fan speed is changed after inserting tool change gcode
            //Set this flag so that normal lift will be used the first time after tool change.
            gcode += ";_FORCE_RESUME_FAN_SPEED\n";
            m_writer.set_current_position_clear(false);
            //BBS: check whether custom gcode changes the z position. Update if changed
            double temp_z_after_tool_change;
            if (GCodeProcessor::get_last_z_from_gcode(toolchange_gcode_parsed, temp_z_after_tool_change)) {
                Vec3d pos = m_writer.get_position();
                pos(2) = temp_z_after_tool_change;
                m_writer.set_position(pos);
            }
        }
    }
 
    // BBS. Reset old extruder E-value.
    // Keep retract length because Custom GCode will guarantee retract length be the same as toolchange
    if (m_config.single_extruder_multi_material) {
        m_writer.reset_e();
    }
 
    //BBS: don't add T[next extruder] if there is no T cmd on filament change
     //We inform the writer about what is happening, but we may not use the resulting gcode.
    std::string toolchange_command = m_writer.toolchange(new_filament_id, next_nozzle_id);
    if (Extruder *fil = m_writer.filament())
        fil->set_config_index((int)get_filament_config_index((int)fil->id()));
    // See imex_suppresses_bare_toolchange() — only suppress the print-start initial
    // T<n> in parallel modes (the user's imex_mode_gcode + machine_start_gcode owns
    // tool activation there). Mid-print T<n> emits normally; Print::validate blocks
    // multi-color setups where it wouldn't make sense.
    const bool suppress_imex_bare = imex_suppresses_bare_toolchange(m_imex_parallel_mode, m_toolchange_count);
    if (!custom_gcode_changes_tool(toolchange_gcode_parsed, m_writer.toolchange_prefix(), new_filament_id)
        && !suppress_imex_bare)
        gcode += toolchange_command;
    else {
        // user provided his own toolchange gcode, no need to do anything
    }
 
    // Set the temperature if the wipe tower didn't (not needed for non-single extruder MM)
    if (m_config.single_extruder_multi_material && !m_config.enable_prime_tower) {
        size_t new_fi = get_filament_config_index(new_filament_id);
        int temp = (m_layer_index <= 0 ? m_config.nozzle_temperature_initial_layer.get_at(new_fi) :
                                         m_config.nozzle_temperature.get_at(new_fi));
 
        gcode += m_writer.set_temperature(temp, false);
    }
 
    this->placeholder_parser().set("current_extruder", new_filament_id);
    this->placeholder_parser().set("current_hotend",
        hotend_id_for_gcode_placeholder(group_result, m_print->is_BBL_printer(), (int) new_filament_id, new_extruder_id, m_layer_index));
    // Orca: keep the global current-tool identity coherent for later contexts (see append_tcr).
    this->placeholder_parser().set("current_filament_id", (int) new_filament_id);
    this->placeholder_parser().set("current_extruder_id", new_extruder_id);
    this->placeholder_parser().set("current_nozzle_id", next_nozzle_id);
    {
        size_t fi = get_filament_config_index(new_filament_id);
        this->placeholder_parser().set("retraction_distance_when_cut", m_config.retraction_distances_when_cut.get_at(fi));
        this->placeholder_parser().set("long_retraction_when_cut", m_config.long_retractions_when_cut.get_at(fi));
        this->placeholder_parser().set("retraction_distance_when_ec", m_config.retraction_distances_when_ec.get_at(fi));
        this->placeholder_parser().set("long_retraction_when_ec", m_config.long_retractions_when_ec.get_at(fi));
    }
 
 
    // Append the filament start G-code.
    const std::string &filament_start_gcode = m_config.filament_start_gcode.get_at(new_filament_id);
    if (! filament_start_gcode.empty()) {
        // Process the filament_start_gcode for the new filament.
        DynamicConfig config;
        config.set_key_value("layer_num", new ConfigOptionInt(m_layer_index));
        config.set_key_value("layer_z", new ConfigOptionFloat(this->writer().get_position().z() - m_config.z_offset.value));
        config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
        config.set_key_value("filament_extruder_id", new ConfigOptionInt(int(new_filament_id)));
        if (toolchange_temp_override > 0) {
            // Rebuild in filament order: the config arrays may carry per-variant columns, while
            // these placeholder vectors are consumed indexed by filament id.
            size_t num_filaments = m_print->config().filament_type.values.size();
            std::vector<int> temps(num_filaments);
            std::vector<int> first_layer_temps(num_filaments);
            for (size_t i = 0; i < num_filaments; ++i) {
                size_t fi_i = get_filament_config_index((int)i);
                temps[i]             = m_config.nozzle_temperature.get_at(fi_i);
                first_layer_temps[i] = m_config.nozzle_temperature_initial_layer.get_at(fi_i);
            }
            if (new_filament_id < temps.size())
                temps[new_filament_id] = toolchange_temp_override;
            config.set_key_value("temperature", new ConfigOptionInts(temps));
            config.set_key_value("nozzle_temperature", new ConfigOptionInts(temps));
            if (new_filament_id < first_layer_temps.size())
                first_layer_temps[new_filament_id] = toolchange_temp_override;
            config.set_key_value("first_layer_temperature", new ConfigOptionInts(first_layer_temps));
            config.set_key_value("nozzle_temperature_initial_layer", new ConfigOptionInts(first_layer_temps));
        }
        gcode += this->placeholder_parser_process("filament_start_gcode", filament_start_gcode, new_filament_id, &config);
        if (add_change_filament_624) {
            gcode += "M625\n";
            add_change_filament_624 = false;
        }
        check_add_eol(gcode);
    }
    // Set the new extruder to the operating temperature. With defer_temp_wait the target was
    // already raised before the tool change and the blocking wait belongs to the wipe tower
    // generator, so there is nothing left to restore here.
    if (m_ooze_prevention.enable && !defer_temp_wait)
        gcode += m_ooze_prevention.post_toolchange(*this);
 
    // See the note on the single-extruder path above: -1 outside IMEX parallel modes.
    gcode += set_filament_pressure_advance(new_filament_id,
        imex_pem_tool_for((int) new_filament_id, m_imex_parallel_mode, m_config.physical_extruder_map));
    //Orca: tool changer or IDEX's firmware may change Z position, so we set it to unknown/undefined
    m_last_pos_defined = false;
    if (position_before_toolchange)
        this->synchronize_toolchange_position(*position_before_toolchange, gcode);
 
    return gcode;
}

References capture_toolchange_position(), Slic3r::cast(), Slic3r::change_filament_gcode(), Slic3r::check_add_eol(), config(), Slic3r::ConfigOptionFloat, Slic3r::ConfigOptionString, Slic3r::custom_gcode_changes_tool(), EPSILON, Slic3r::g_max_flush_count, Slic3r::g_purge_volume_one_time, get_extruder_id(), get_filament_config_index(), Slic3r::get_flush_volumes_matrix(), Slic3r::GCodeProcessor::get_last_z_from_gcode(), Slic3r::get_nozzle_diameters_by_nozzle_id(), Slic3r::get_nozzle_volume_types_by_nozzle_id(), Slic3r::get_outer_wall_volumetric_speed(), Slic3r::hotend_id_for_gcode_placeholder(), Slic3r::imex_pem_tool_for(), Slic3r::imex_suppresses_bare_toolchange(), m_config, m_filament_instances_code, m_imex_parallel_mode, m_last_pos_defined, m_layer, m_layer_index, m_max_layer_z, m_ooze_prevention, M_PI, m_print, m_start_gcode_filament, m_toolchange_count, m_wipe, m_writer, Slic3r::nozzle_id_for_gcode_placeholder(), on_first_layer(), placeholder_parser(), placeholder_parser_process(), Slic3r::pvmFast, retract(), Slic3r::PlaceholderParser::set(), set_filament_pressure_advance(), Slic3r::DynamicConfig::set_key_value(), Slic3r::SpiralLift, synchronize_toolchange_position(), Slic3r::travel_point_1, Slic3r::travel_point_2, Slic3r::travel_point_3, Slic3r::wrap_custom_gcode_for_fan_mover(), and writer().

Referenced by _do_export(), Slic3r::WipeTowerIntegration::append_tcr2(), and process_belt_brim_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

set_extruders()

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

protectedinherited

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

References m_config, m_wipe, and m_writer.

Referenced by _do_export().

Here is the caller graph for this function:

set_filament_pressure_advance()

std::string Slic3r::GCode::set_filament_pressure_advance ( unsigned int filament_id, int tool = -1 )

inherited

{
    const size_t fi = get_filament_config_index(filament_id);
    if (!m_config.enable_pressure_advance.get_at(fi))
        return {};
    // Orca: Adaptive PA
    // Reset Adaptive PA processor last PA value
    m_pa_processor->resetPreviousPA(m_config.pressure_advance.get_at(fi));
    // tool >= 0 addresses one IMEX carriage explicitly; -1 omits the qualifier, so every
    // caller that does not pass one emits exactly what it did before.
    return m_writer.set_pressure_advance(m_config.pressure_advance.get_at(fi), tool);
}

References get_filament_config_index(), m_config, m_pa_processor, and m_writer.

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_gcode_offset()

void Slic3r::GCode::set_gcode_offset ( double x, double y )

inlineinherited

{ m_writer.set_xy_offset(x, y); m_processor.set_xy_offset(x, y);}

References m_processor, and m_writer.

set_gcode_offset_with_imex_shift()

void Slic3r::GCode::set_gcode_offset_with_imex_shift ( double x, double y, double imex_x, double imex_y )

inlineinherited

                                                                                            {
        m_writer.set_xy_offset(x + imex_x, y + imex_y);
        m_processor.set_xy_offset(x, y);
    }

References m_processor, and m_writer.

set_last_pos() [1/2]

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

inlineprotectedinherited

                                                   {
        m_last_pos = Point3(pos, 0);
        m_last_pos_defined = true;
        m_pending_start_gcode_position.reset();
    }

References m_last_pos, m_last_pos_defined, and m_pending_start_gcode_position.

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

Here is the caller graph for this function:

set_last_pos() [2/2]

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

inlineprotectedinherited

                                                    {
        m_last_pos = pos;
        m_last_pos_defined = true;
        m_pending_start_gcode_position.reset();
    }

References m_last_pos, m_last_pos_defined, and m_pending_start_gcode_position.

set_layer_count()

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

inlineinherited

{ m_layer_count = value; }

References m_layer_count.

set_object_info()

std::string Slic3r::GCode::set_object_info ( Print * print )

inherited

                                             {
    const auto gflavor = print->config().gcode_flavor.value;
    if (print->is_BBL_printer() ||
        (gflavor != gcfKlipper && gflavor != gcfMarlinLegacy && gflavor != gcfMarlinFirmware && gflavor != gcfRepRapFirmware))
        return "";
    std::ostringstream gcode;
    // Orca: check if we are in pa calib mode
    if (print->calib_mode() == CalibMode::Calib_PA_Pattern) {
        BoundingBoxf bbox_bed(print->config().printable_area.values);
        bbox_bed.offset(-25.0);
        Polygon polygon_bed;
        polygon_bed.append(Point(bbox_bed.min.x(), bbox_bed.min.y()));
        polygon_bed.append(Point(bbox_bed.max.x(), bbox_bed.min.y()));
        polygon_bed.append(Point(bbox_bed.max.x(), bbox_bed.max.y()));
        polygon_bed.append(Point(bbox_bed.min.x(), bbox_bed.max.y()));
        gcode << "EXCLUDE_OBJECT_DEFINE NAME="
              << "Orca-PA-Calibration-Test"
              << " CENTER=" << 0 << "," << 0 << " POLYGON=" << polygon_to_string(polygon_bed, print, true) << "\n";
    } else if (print->calib_mode() == CalibMode::Calib_PA_Line) {
        // PA_Line has only one object, no EXCLUDE_OBJECT_DEFINE needed
    } else {
        for (PrintObject* object : print->objects()) {
            for (PrintInstance& inst : object->instances()) {
                // Outlines are in plate coordinates. On a belt printer that is the frame after
                // the slicing rotation has been undone and before the G-code axis remap and
                // machine-frame shear: where the object stands on the belt, which is what an
                // object picker shows. Klipper cancels by name, so nothing depends on more.
                auto bbox      = inst.get_bounding_box();
                auto center    = print->translate_to_print_space(Vec2d(bbox.center().x(), bbox.center().y()));
                const std::string &inst_name = instance_name(inst);
                if (gflavor == gcfKlipper) {
                    gcode << "EXCLUDE_OBJECT_DEFINE NAME=" << inst_name << " CENTER=" << center.x() << "," << center.y()
                          << " POLYGON=" << polygon_to_string(inst.get_convex_hull_2d(), print) << "\n";
                } else if (gflavor == gcfMarlinLegacy || gflavor == gcfMarlinFirmware || gflavor == gcfRepRapFirmware) {
                    gcode << "M486 S" << std::to_string(inst.unique_id);
                    if (gflavor == gcfRepRapFirmware)
                        gcode << " A"
                              << "\"" << inst_name << "\"";
                    else
                        gcode << "\nM486 A" << inst_name;
                    gcode << "\nM486 S-1\n";
                }
            }
        }
    }
 
    return gcode.str();
}

References Slic3r::MultiPoint::append(), Slic3r::Print::calib_mode(), Slic3r::Calib_PA_Line, Slic3r::Calib_PA_Pattern, Slic3r::center(), Slic3r::Print::config(), Slic3r::gcfKlipper, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepRapFirmware, instance_name(), Slic3r::Print::is_BBL_printer(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::Print::objects(), Slic3r::BoundingBoxBase< PointType, APointsType >::offset(), Slic3r::polygon_to_string(), Print, and Slic3r::Print::translate_to_print_space().

Referenced by _do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

set_origin() [1/2]

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

inlineinherited

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

References set_origin().

Referenced by set_origin().

Here is the call graph for this function:

Here is the caller graph for this function:

set_origin() [2/2]

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

inherited

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

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

Referenced by _do_export(), emit_belt_brim_bands(), generate_object_brim(), generate_skirt(), and Slic3r::BeltGCode::on_set_origin().

Here is the call graph for this function:

Here is the caller graph for this function:

should_disable_arc_fitting()

virtual bool Slic3r::GCode::should_disable_arc_fitting ( ) const

inlineprotectedvirtualinherited

        { return ! m_writer.kinematics().supports_arc_moves(); }

References m_writer.

sort_print_object_instances()

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

protectedinherited

{
    std::vector<InstanceToPrint> out;
 
    if (ordering == nullptr) {
        // Sequential print, single object is being printed.
        for (ObjectByExtruder &object_by_extruder : objects_by_extruder) {
            const size_t       layer_id     = &object_by_extruder - objects_by_extruder.data();
            //BBS:add the support of shared print object
            const PrintObject *print_object = layers[layer_id].original_object;
            //const PrintObject *print_object = layers[layer_id].object();
            if (print_object)
                out.emplace_back(object_by_extruder, layer_id, *print_object, single_object_instance_idx, print_object->instances()[single_object_instance_idx].model_instance->get_labeled_id());
        }
    } else {
        // Create mapping from PrintObject* to ObjectByExtruder*.
        std::vector<std::pair<const PrintObject*, ObjectByExtruder*>> sorted;
        sorted.reserve(objects_by_extruder.size());
        for (ObjectByExtruder &object_by_extruder : objects_by_extruder) {
            const size_t       layer_id     = &object_by_extruder - objects_by_extruder.data();
            //BBS:add the support of shared print object
            const PrintObject *print_object = layers[layer_id].original_object;
            //const PrintObject *print_object = layers[layer_id].object();
            if (print_object)
                sorted.emplace_back(print_object, &object_by_extruder);
        }
        std::sort(sorted.begin(), sorted.end());
 
        if (! sorted.empty()) {
            out.reserve(sorted.size());
            for (const PrintInstance *instance : *ordering) {
                const PrintObject &print_object = *instance->print_object;
                //BBS:add the support of shared print object
                //const PrintObject* print_obj_ptr = &print_object;
                //if (print_object.get_shared_object())
                //    print_obj_ptr = print_object.get_shared_object();
                std::pair<const PrintObject*, ObjectByExtruder*> key(&print_object, nullptr);
                auto it = std::lower_bound(sorted.begin(), sorted.end(), key);
                if (it != sorted.end() && it->first == &print_object)
                    // ObjectByExtruder for this PrintObject was found.
                    out.emplace_back(*it->second, it->second - objects_by_extruder.data(), print_object, instance - print_object.instances().data(), instance->model_instance->get_labeled_id());
            }
        }
    }
    return out;
}

References Slic3r::PrintObject::instances(), layer_id(), and object_by_extruder.

Referenced by process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

synchronize_toolchange_position()

void Slic3r::GCode::synchronize_toolchange_position ( const ToolchangePositionState & before, const std::string & emitted_gcode )

protectedinherited

{
    if (m_writer.filament() == nullptr)
        return;
 
    const std::optional<Vec2d> emitted_xy = emitted_xy_after_gcode(emitted_gcode, before.emitted_xy);
    if (!emitted_xy)
        return;
 
    // GCodeWriter stores coordinates before applying the per-plate output
    // offset. Convert the parsed file coordinates back into that space, then
    // into model space using the newly active nozzle offset.
    const Vec2d writer_xy = *emitted_xy + m_writer.get_xy_offset().cast<double>();
    Vec3d       writer_position = m_writer.get_position();
    writer_position.head<2>() = writer_xy;
    m_writer.set_position(writer_position);
    // Updating the known XY origin must not cancel Orca's deliberate
    // post-toolchange Z restore. set_last_pos() normally marks the entire
    // position as defined, so preserve the caller's state across the XY sync.
    const bool last_pos_defined = m_last_pos_defined;
    this->set_last_pos(this->gcode_to_point(writer_xy));
    m_last_pos_defined = last_pos_defined;
}

References Slic3r::GCode::ToolchangePositionState::emitted_xy, gcode_to_point(), last_pos_defined(), m_last_pos_defined, m_writer, and set_last_pos().

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

Here is the call graph for this function:

Here is the caller graph for this function:

timelapse_gcode_config()

DynamicConfig Slic3r::GCode::timelapse_gcode_config ( const Print & print, coordf_t print_z, int most_used_extruder, const std::vector< const PrintObject * > * printed_objects, bool skip_pos_pick )

protectedinherited

{
    assert(m_writer.filament());
    PosPickCtx ctx;
    ctx.curr_pos = { (coord_t)(scale_(m_writer.get_position().x())),(coord_t)(scale_(m_writer.get_position().y())) };
    ctx.curr_layer = this->layer();
    ctx.curr_extruder_id = m_writer.filament()->extruder_id();
    ctx.picture_extruder_id = most_used_extruder;
    if (m_farthest_point_timelapse.enabled) {
        // farthest_point is stored in the global print frame (includes plate origin); the picker works in
        // the plate-relative frame, so subtract the plate origin here.
        Vec3d po = print.get_plate_origin();
        ctx.farthest_point = m_farthest_point_timelapse.farthest_point - Point(scale_(po.x()), scale_(po.y()));
    }
    if (m_config.print_sequence == PrintSequence::ByObject && printed_objects)
        ctx.printed_objects = *printed_objects;
 
    auto timelapse_pos = (skip_pos_pick || !m_timelapse_uses_pos) ? DefaultTimelapsePos : m_timelapse_pos_picker.pick_pos(ctx);
 
    DynamicConfig config;
    config.set_key_value("layer_num", new ConfigOptionInt(m_layer_index));
    config.set_key_value("layer_z", new ConfigOptionFloat(print_z));
    config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
    config.set_key_value("most_used_physical_extruder_id", new ConfigOptionInt(m_config.physical_extruder_map.get_at(most_used_extruder)));
    config.set_key_value("curr_physical_extruder_id", new ConfigOptionInt(m_config.physical_extruder_map.get_at(ctx.curr_extruder_id)));
    config.set_key_value("timelapse_pos_x", new ConfigOptionInt((int)timelapse_pos.x()));
    config.set_key_value("timelapse_pos_y", new ConfigOptionInt((int)timelapse_pos.y()));
    config.set_key_value("has_timelapse_safe_pos", new ConfigOptionBool(timelapse_pos != DefaultTimelapsePos));
    config.set_key_value("timelapse_inline_photo", new ConfigOptionBool(skip_pos_pick));
    config.set_key_value("farthest_point_timelapse_enabled", new ConfigOptionBool(m_farthest_point_timelapse.enabled));
    config.set_key_value("clear_to_x0", new ConfigOptionBool(m_timelapse_uses_clear_to_x0 && m_timelapse_pos_picker.get_is_clear_to_x0(ctx)));
    return config;
}

References Slic3r::ByObject, config(), Slic3r::ConfigOptionFloat, Slic3r::PosPickCtx::curr_extruder_id, Slic3r::PosPickCtx::curr_layer, Slic3r::PosPickCtx::curr_pos, Slic3r::DefaultTimelapsePos, Slic3r::PosPickCtx::farthest_point, Slic3r::Print::get_plate_origin(), layer(), m_config, m_farthest_point_timelapse, m_layer_index, m_max_layer_z, m_timelapse_pos_picker, m_timelapse_uses_clear_to_x0, m_timelapse_uses_pos, m_writer, Slic3r::PosPickCtx::picture_extruder_id, Print, Slic3r::PosPickCtx::printed_objects, and scale_.

Referenced by generate_timelapse_gcode(), and process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

to_lift_type()

LiftType Slic3r::GCode::to_lift_type ( ZHopType z_hop_types )

protectedinherited

                                                 {
    switch (z_hop_types)
    {
    case ZHopType::zhtNormal:
        return LiftType::NormalLift;
    case ZHopType::zhtSlope:
        return LiftType::SlopeLift;
    case ZHopType::zhtSpiral:
        return LiftType::SpiralLift;
    default:
        // if no corresponding lift type, use normal lift
        return LiftType::NormalLift;
    }
};

References Slic3r::NormalLift, Slic3r::SlopeLift, Slic3r::SpiralLift, Slic3r::zhtNormal, Slic3r::zhtSlope, and Slic3r::zhtSpiral.

Referenced by Slic3r::WipeTowerIntegration::append_tcr2(), change_layer(), and needs_retraction().

Here is the caller graph for this function:

travel_to()

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

inherited

{
    const std::optional<GCodeProcessor::PositionState> start_gcode_position =
        !m_exclusion_volume_travel_avoidance.empty() && !m_last_pos_defined &&
        !m_writer.is_current_position_clear() && m_pending_start_gcode_position.has_value() ?
        m_pending_start_gcode_position : std::nullopt;
 
    /*  Define the travel move as a line between current position and the taget point.
        This is expressed in print coordinates, so it will need to be translated by
        this->origin in order to get G-code coordinates.  */
    const Point travel_start = start_gcode_position ?
        this->gcode_to_point(to_2d(start_gcode_position->position)) : this->last_pos();
    Polyline travel { travel_start, point };
 
    // check whether a straight travel move would need retraction
    LiftType lift_type = LiftType::SpiralLift;
    bool needs_retraction = this->needs_retraction(travel, role, lift_type);
    // check whether wipe could be disabled without causing visible stringing
    bool could_be_wipe_disabled       = false;
    // Save state of use_external_mp_once for the case that will be needed to call twice m_avoid_crossing_perimeters.travel_to.
    const bool used_external_mp_once  = m_avoid_crossing_perimeters.used_external_mp_once();
    std::string gcode;
    bool exclusion_volume_travel_rerouted = false;
 
    const auto active_extruder_id = [this]() {
        if (m_writer.filament() == nullptr)
            return -1;
        const size_t id = m_writer.filament()->extruder_id();
        return id < m_config.nozzle_diameter.size() ? int(id) : -1;
    };
    const auto to_gcode_point = [this](const Point &local_point) {
        const Vec2d point = this->point_to_gcode(local_point);
        return Point(scale_(point.x()), scale_(point.y()));
    };
    const auto to_local_point = [this](const Point &gcode_point) {
        return this->gcode_to_point(unscaled(gcode_point));
    };
    const auto to_gcode_polyline = [&to_gcode_point](const Polyline &local_path) {
        Polyline result;
        result.points.reserve(local_path.points.size());
        for (const Point &local_point : local_path.points)
            result.append(to_gcode_point(local_point));
        return result;
    };
    const auto to_local_polyline = [&to_local_point](const Polyline &gcode_path) {
        Polyline result;
        result.points.reserve(gcode_path.points.size());
        for (const Point &gcode_point : gcode_path.points)
            result.append(to_local_point(gcode_point));
        return result;
    };
    const auto nominal_writer_z = [this]() {
        return m_writer.get_position().z() - m_writer.get_zhop();
    };
    const auto route_around_exclusion_volumes = [&](
        Polyline &path,
        const std::optional<double> &start_z_override,
        const bool include_planned_lift = false) {
        if (m_exclusion_volume_travel_avoidance.empty() || path.size() < 2)
            return false;
 
        const double target_z = z == DBL_MAX ? m_nominal_z : z;
        double route_start_z = start_z_override.value_or(nominal_writer_z());
        double route_end_z = target_z;
        if (include_planned_lift) {
            const Vec2d destination_xy = this->point_to_gcode(path.back());
            std::tie(route_start_z, route_end_z) = m_writer.planned_travel_z(
                Vec3d(destination_xy.x(), destination_xy.y(), target_z),
                m_need_change_layer_lift_z);
        }
        const ExclusionVolumeTravelAvoidance::Result result =
            m_exclusion_volume_travel_avoidance.route(
                to_gcode_polyline(path),
                route_start_z,
                route_end_z,
                active_extruder_id());
        if (!result.rerouted())
            return false;
 
        path = to_local_polyline(result.path);
        return true;
    };
 
    // Orca: we don't need to optimize the Klipper as only set once
    double jerk_to_set = 0.0;
    unsigned int acceleration_to_set = 0;
    
    if (this->on_first_layer()) {
        unsigned int initial_layer_travel_acceleration = m_config.get_abs_value_at("initial_layer_travel_acceleration", get_nozzle_config_index(m_writer.filament()->id()));
        double initial_layer_travel_jerk = m_config.get_abs_value_at("initial_layer_travel_jerk", get_nozzle_config_index(m_writer.filament()->id()));
    
        if (NOZZLE_CONFIG(default_acceleration) > 0 && initial_layer_travel_acceleration > 0) {
            acceleration_to_set = (unsigned int) floor(initial_layer_travel_acceleration + 0.5);
        }
        if (NOZZLE_CONFIG(default_jerk)> 0 && initial_layer_travel_jerk > 0) {
            jerk_to_set = initial_layer_travel_jerk;
        }
    } else { // ORCA: Handle short-travel acceleration and jerk for outer perimeters (if applicable)
        const bool is_short_travel = travel.length() < scale_(EXTRUDER_CONFIG(retraction_minimum_travel));
 
        if (NOZZLE_CONFIG(default_acceleration) > 0) {
            if (role == erOverhangPerimeter && is_short_travel) {
                const double bridge_acceleration  = m_config.get_abs_value_at("bridge_acceleration", get_nozzle_config_index(m_writer.filament()->id()));
 
                if (bridge_acceleration > 0)
                    acceleration_to_set = (unsigned int) floor(bridge_acceleration + 0.5);
            } else if (role == erExternalPerimeter && is_short_travel) {
                if (NOZZLE_CONFIG(outer_wall_acceleration) > 0)
                    acceleration_to_set = (unsigned int) floor(NOZZLE_CONFIG(outer_wall_acceleration) + 0.5);
            } else {
                if (NOZZLE_CONFIG(travel_acceleration) > 0)
                    acceleration_to_set = (unsigned int) floor(NOZZLE_CONFIG(travel_acceleration) + 0.5);
            }
        }
 
        if (NOZZLE_CONFIG(default_jerk) > 0) {
            if ((role == erExternalPerimeter || role == erOverhangPerimeter) && is_short_travel) {
                if (NOZZLE_CONFIG(outer_wall_jerk) > 0)
                    jerk_to_set = NOZZLE_CONFIG(outer_wall_jerk);
            } else {
                if (NOZZLE_CONFIG(travel_jerk) > 0)
                    jerk_to_set = NOZZLE_CONFIG(travel_jerk);
            }
        }
    }
    
    if (m_writer.get_gcode_flavor() == gcfKlipper) {
        gcode += m_writer.set_accel_and_jerk(acceleration_to_set, jerk_to_set);
    } else {
        gcode += m_writer.set_travel_acceleration(acceleration_to_set);
        gcode += m_writer.set_jerk_xy(jerk_to_set);
    }
 
    // if a retraction would be needed, try to use reduce_crossing_wall to plan a
    // multi-hop travel path inside the configuration space
    if (m_config.reduce_crossing_wall
        && !m_avoid_crossing_perimeters.disabled_once()
        && m_layer != nullptr   // A brim apron layer has no Layer to avoid crossing
        && m_writer.is_current_position_clear())
        //BBS: don't generate detour travel paths when current position is unclea
    {
        travel = m_avoid_crossing_perimeters.travel_to(*this, point, &could_be_wipe_disabled);
        // check again whether the new travel path still needs a retraction
        needs_retraction = this->needs_retraction(travel, role, lift_type);
        //if (needs_retraction && m_layer_index > 1) exit(0);
    }
 
    const std::optional<double> start_gcode_z =
        start_gcode_position && start_gcode_position->has_known_z() ?
        std::optional<double>(start_gcode_position->position.z()) : std::nullopt;
    if (route_around_exclusion_volumes(travel, start_gcode_z)) {
        exclusion_volume_travel_rerouted = true;
        needs_retraction = this->needs_retraction(travel, role, lift_type);
    }
 
    // Re-allow reduce_crossing_wall for the next travel moves
    m_avoid_crossing_perimeters.reset_once_modifiers();
 
    // generate G-code for the travel move
    if (needs_retraction) {
        // ORCA: Fix scenario where wipe is disabled when avoid crossing perimeters was enabled even though a retraction move was performed.
        // This replicates the existing behaviour of always wiping when retracting
        /*if (m_config.reduce_crossing_wall && could_be_wipe_disabled)
            m_wipe.reset_path();*/
 
        Point last_post_before_retract = this->last_pos();
        gcode += this->retract(false, false, lift_type, false, role);
        // When "Wipe while retracting" is enabled, then extruder moves to another position, and travel from this position can cross perimeters.
        // Because of it, it is necessary to call avoid crossing perimeters again with new starting point after calling retraction()
        // FIXME Lukas H.: Try to predict if this second calling of avoid crossing perimeters will be needed or not. It could save computations.
        if (last_post_before_retract != this->last_pos()) {
            travel = Polyline { this->last_pos(), point };
            if (m_config.reduce_crossing_wall && m_layer != nullptr) { // Belt brim apron layers have no Layer.
                // If in the previous call of m_avoid_crossing_perimeters.travel_to was use_external_mp_once set to true restore this value for next call.
                if (used_external_mp_once)
                    m_avoid_crossing_perimeters.use_external_mp_once();
                travel = m_avoid_crossing_perimeters.travel_to(*this, point);
                // If state of use_external_mp_once was changed reset it to right value.
                if (used_external_mp_once)
                    m_avoid_crossing_perimeters.reset_once_modifiers();
            }
        }
 
        exclusion_volume_travel_rerouted =
            route_around_exclusion_volumes(travel, std::nullopt, true) ||
            (last_post_before_retract == this->last_pos() && exclusion_volume_travel_rerouted);
    } else {
        // Reset the wipe path when traveling, so one would not wipe along an old path.
        m_wipe.reset_path();
        // if (m_config.reduce_crossing_wall) {
        //     // If in the previous call of m_avoid_crossing_perimeters.travel_to was use_external_mp_once set to true restore this value for next call.
        //     if (used_external_mp_once) m_avoid_crossing_perimeters.use_external_mp_once();
        //     travel = m_avoid_crossing_perimeters.travel_to(*this, point);
        //     // If state of use_external_mp_once was changed reset it to right value.
        //     if (used_external_mp_once) m_avoid_crossing_perimeters.reset_once_modifiers();
        // }
    }
 
 
    // if needed, write the gcode_label_objects_end then gcode_label_objects_start
    m_writer.add_object_change_labels(gcode);
 
    // use G1 because we rely on paths being straight (G0 may make round paths)
    if (travel.size() >= 2) {
        // Orca: use `travel_to_xyz` to ensure we start at the correct z, in case we moved z in custom/filament change gcode
        if (false/*m_spiral_vase*/) {
            // No lazy z lift for spiral vase mode
            for (size_t i = 1; i < travel.size(); ++i) {
                gcode += m_writer.travel_to_xy(this->point_to_gcode(travel.points[i]), comment);
            }
        } else {
            if (travel.size() == 2) {
                // No extra movements emitted by avoid_crossing_perimeters, simply move to the end point with z change
                const auto& dest2d = this->point_to_gcode(travel.points.back());
                Vec3d dest3d(dest2d(0), dest2d(1), z == DBL_MAX ? m_nominal_z : z);
                gcode += m_writer.travel_to_xyz(dest3d, comment, m_need_change_layer_lift_z);
                m_need_change_layer_lift_z = false;
            } else if (exclusion_volume_travel_rerouted && z != DBL_MAX) {
                // Preserve the original sloped-Z move over the longer detour.
                // The router activates every volume touched by the complete Z
                // range, so this interpolation remains conservative.
                const double start_z = m_writer.get_position().z();
                const double total_length = std::max(travel.length(), 1.0);
                double traveled = 0.0;
                for (size_t i = 1; i < travel.size(); ++i) {
                    traveled += (travel.points[i] - travel.points[i - 1]).cast<double>().norm();
                    const Vec2d dest2d = this->point_to_gcode(travel.points[i]);
                    const Vec3d dest3d(
                        dest2d.x(),
                        dest2d.y(),
                        start_z + (z - start_z) * std::min(1.0, traveled / total_length));
                    gcode += m_writer.travel_to_xyz(dest3d, comment, i == 1 && m_need_change_layer_lift_z);
                    if (i == 1)
                        m_need_change_layer_lift_z = false;
                }
            } else {
                // Extra movements emitted by avoid_crossing_perimeters, lift the z to normal height at the beginning, then apply the z
                // ratio at the last point
                for (size_t i = 1; i < travel.size(); ++i) {
                    if (i == 1) {
                        // Lift to normal z at beginning
                        Vec2d dest2d = this->point_to_gcode(travel.points[i]);
                        Vec3d dest3d(dest2d(0), dest2d(1), m_nominal_z);
                        gcode += m_writer.travel_to_xyz(dest3d, comment, m_need_change_layer_lift_z);
                        m_need_change_layer_lift_z = false;
                    } else if (z != DBL_MAX && i == travel.size() - 1) {
                        // Apply z_ratio for the very last point
                        Vec2d dest2d = this->point_to_gcode(travel.points[i]);
                        Vec3d dest3d(dest2d(0), dest2d(1), z);
                        gcode += m_writer.travel_to_xyz(dest3d, comment);
                    } else {
                        // For all points in between, no z change
                        gcode += m_writer.travel_to_xy(this->point_to_gcode(travel.points[i]), comment);
                    }
                }
            }
        }
        this->set_last_pos(travel.points.back());
    }
 
    return gcode;
}

References Slic3r::Polyline::append(), Slic3r::MultiPoint::back(), Slic3r::cast(), Slic3r::erExternalPerimeter, Slic3r::erOverhangPerimeter, EXTRUDER_CONFIG, Slic3r::gcfKlipper, gcode_to_point(), get_nozzle_config_index(), Slic3r::initial_layer_travel_jerk(), last_pos(), Slic3r::MultiPoint::length(), m_avoid_crossing_perimeters, m_config, m_exclusion_volume_travel_avoidance, m_last_pos_defined, m_layer, m_need_change_layer_lift_z, m_nominal_z, m_pending_start_gcode_position, m_wipe, m_writer, needs_retraction(), NOZZLE_CONFIG, on_first_layer(), Slic3r::ExclusionVolumeTravelAvoidance::Result::path, point_to_gcode(), Slic3r::MultiPoint::points, Slic3r::ExclusionVolumeTravelAvoidance::Result::rerouted(), retract(), scale_, set_last_pos(), Slic3r::MultiPoint::size(), Slic3r::SpiralLift, Slic3r::to_2d(), Slic3r::total_length(), and Slic3r::unscaled().

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

Here is the call graph for this function:

Here is the caller graph for this function:

unretract()

std::string Slic3r::GCode::unretract ( float extra_retract = 0.f )

inlineinherited

{ return m_writer.unlift() + m_writer.unretract(extra_retract); }

References m_writer.

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

Here is the caller graph for this function:

update_layer_related_config()

void Slic3r::GCode::update_layer_related_config ( int layer_id )

protectedinherited

                                                   {
    auto group_result = m_print->get_layered_nozzle_group_result();
    // Orca: defensive — with no published group result the statically applied config maps stay
    // authoritative.
    if(!group_result)
        return;
 
    auto extruder_map = group_result->get_extruder_map(false,layer_id);
    auto volume_map = group_result->get_volume_map(layer_id);
    auto nozzle_map = group_result->get_nozzle_map(layer_id);
 
    m_config.filament_map.values = extruder_map;
    m_config.filament_volume_map.values = volume_map;
    m_config.filament_nozzle_map.values = nozzle_map;
 
    m_writer.config.filament_map.values = extruder_map;
    m_writer.config.filament_volume_map.values = volume_map;
    m_writer.config.filament_nozzle_map.values = nozzle_map;
 
}

References layer_id(), m_config, m_print, and m_writer.

Referenced by _do_export(), and process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

update_placeholder_parser_with_variant_params()

void Slic3r::GCode::update_placeholder_parser_with_variant_params ( )

protectedinherited

{
    if (!m_print)
        return;
 
    size_t num_filaments = m_config.filament_type.values.size();
    if (num_filaments == 0)
        return;
 
    // Helper: remap config arrays from variant index space to filament_id index space.
    // After remapping, gcode templates can use param[filament_id] directly.
    std::vector<size_t> config_index(num_filaments);
    for (size_t i = 0; i < num_filaments; ++i)
        config_index[i] = get_filament_config_index(i);
    auto remap_by_filament = [&](const auto &src) {
        std::decay_t<decltype(src.values)> dst(num_filaments);
        for (size_t i = 0; i < num_filaments; ++i)
            dst[i] = src.get_at(config_index[i]);
        return dst;
    };
 
    // --- filament_options_with_variant: gcode indexes by filament_id ---
    this->placeholder_parser().set("filament_max_volumetric_speed",       new ConfigOptionFloats(remap_by_filament(m_config.filament_max_volumetric_speed)));
    this->placeholder_parser().set("filament_pre_cooling_temperature",    new ConfigOptionInts(remap_by_filament(m_config.filament_pre_cooling_temperature)));
    this->placeholder_parser().set("filament_pre_cooling_temperature_nc", new ConfigOptionInts(remap_by_filament(m_config.filament_pre_cooling_temperature_nc)));
    this->placeholder_parser().set("filament_cooling_before_tower",       new ConfigOptionFloats(remap_by_filament(m_config.filament_cooling_before_tower)));
    this->placeholder_parser().set("nozzle_temperature_initial_layer",    new ConfigOptionInts(remap_by_filament(m_config.nozzle_temperature_initial_layer)));
    this->placeholder_parser().set("nozzle_temperature",                  new ConfigOptionInts(remap_by_filament(m_config.nozzle_temperature)));
    // first_layer_temperature is a legacy alias of nozzle_temperature_initial_layer
    this->placeholder_parser().set("first_layer_temperature",             new ConfigOptionInts(remap_by_filament(m_config.nozzle_temperature_initial_layer)));
    this->placeholder_parser().set("pressure_advance",                    new ConfigOptionFloats(remap_by_filament(m_config.pressure_advance)));
    this->placeholder_parser().set("enable_pressure_advance",             new ConfigOptionBools(remap_by_filament(m_config.enable_pressure_advance)));
    this->placeholder_parser().set("fan_min_speed",                       new ConfigOptionFloats(remap_by_filament(m_config.fan_min_speed)));
    this->placeholder_parser().set("fan_max_speed",                       new ConfigOptionFloats(remap_by_filament(m_config.fan_max_speed)));
    this->placeholder_parser().set("additional_cooling_fan_speed",        new ConfigOptionInts(remap_by_filament(m_config.additional_cooling_fan_speed)));
    this->placeholder_parser().set("filament_minimal_purge_on_wipe_tower", new ConfigOptionFloats(remap_by_filament(m_config.filament_minimal_purge_on_wipe_tower)));
    this->placeholder_parser().set("filament_multitool_ramming",          new ConfigOptionBools(remap_by_filament(m_config.filament_multitool_ramming)));
    this->placeholder_parser().set("filament_multitool_ramming_volume",   new ConfigOptionFloats(remap_by_filament(m_config.filament_multitool_ramming_volume)));
    this->placeholder_parser().set("filament_multitool_ramming_flow",     new ConfigOptionFloats(remap_by_filament(m_config.filament_multitool_ramming_flow)));
    this->placeholder_parser().set("nozzle_temperature_range_low",        new ConfigOptionInts(remap_by_filament(m_config.nozzle_temperature_range_low)));
    const auto nozzle_temperature_range_high = remap_by_filament(m_config.nozzle_temperature_range_high);
    this->placeholder_parser().set("nozzle_temperature_range_high",       new ConfigOptionInts(nozzle_temperature_range_high));
 
    // --- printer_options_with_variant_1: in m_config these are already merged as filament-indexed ---
    this->placeholder_parser().set("retraction_distances_when_cut",       new ConfigOptionFloats(remap_by_filament(m_config.retraction_distances_when_cut)));
    // hotend_cooling_rate / hotend_heating_rate: gcode uses [filament_map[x]-1] (extruder_id), no remap needed
 
    // --- filament_map: per-layer dynamic, sync from m_config to placeholder_parser ---
    this->placeholder_parser().set("filament_map", new ConfigOptionInts(m_config.filament_map));
 
    // --- flush_volumetric_speeds / flush_temperatures: derived with fallback ---
    {
        // Fast purge mode uses filament_flush_temp_fast; Default is inert.
        bool use_fast_flush = m_config.prime_volume_mode == PrimeVolumeMode::pvmFast;
        auto flush_v_speed  = remap_by_filament(m_config.filament_flush_volumetric_speed);
        auto filament_max_v = remap_by_filament(m_config.filament_max_volumetric_speed);
        auto flush_temps    = remap_by_filament(use_fast_flush ? m_config.filament_flush_temp_fast
                                                               : m_config.filament_flush_temp);
        for (size_t i = 0; i < num_filaments; ++i) {
            if (flush_v_speed[i] == 0)
                flush_v_speed[i] = filament_max_v[i];
            if (flush_temps[i] == 0)
                flush_temps[i] = nozzle_temperature_range_high[i];
        }
        this->placeholder_parser().set("flush_volumetric_speeds", new ConfigOptionFloats(flush_v_speed));
        this->placeholder_parser().set("flush_temperatures",      new ConfigOptionInts(flush_temps));
    }
}

References get_filament_config_index(), m_config, m_print, Slic3r::nozzle_temperature_range_high(), placeholder_parser(), Slic3r::pvmFast, and Slic3r::PlaceholderParser::set().

Referenced by _do_export(), and process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

wipe_tower_type()

WipeTowerType Slic3r::GCode::wipe_tower_type ( )

inherited

{
    if (m_curr_print)
        return m_curr_print->wipe_tower_type();
    return WipeTowerType::Type2;
}

References m_curr_print, and Slic3r::Type2.

Referenced by _do_export(), Slic3r::WipeTowerIntegration::finalize(), Slic3r::WipeTowerIntegration::prime(), and Slic3r::WipeTowerIntegration::tool_change().

Here is the caller graph for this function:

write_belt_header()

void Slic3r::BeltGCode::write_belt_header ( GCodeOutputStream & file, const Print & print )

overrideprotectedvirtual

Reimplemented from Slic3r::GCode.

{
    const auto &full_cfg = print.full_print_config();
    // Slicing rotation: the belt tilt (axis + angle) and the single source of truth
    // for the physical tilt the G-code viewer uses to enable belt view.
    file.write_format("; belt_slice_rotation = %s\n", full_cfg.opt_serialize("belt_slice_rotation").c_str());
    file.write_format("; belt_slice_rotation_angle = %.1f\n", print.config().belt_slice_rotation_angle.value);
    // Machine-frame transform: shear (cot) + scale (1/|sin|) derived from the belt
    // tilt angle (or belt_frame_tilt_angle when decoupled).
    file.write_format("; belt_frame_tilt_decouple = %d\n", print.config().belt_frame_tilt_decouple.value ? 1 : 0);
    file.write_format("; belt_frame_tilt_angle = %.1f\n", print.config().belt_frame_tilt_angle.value);
}

References Slic3r::Print::config(), Slic3r::PrintBase::full_print_config(), Slic3r::GCode::Print, and Slic3r::GCode::GCodeOutputStream::write_format().

Here is the call graph for this function:

writer() [1/2]

GCodeWriter & Slic3r::GCode::writer ( )

inlineinherited

{ return m_writer; }

References m_writer.

Referenced by Slic3r::CoolingBuffer::CoolingBuffer(), _do_export(), _extrude(), Slic3r::OozePrevention::_get_temp(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), Slic3r::Wipe::calculateWipeRetractionLengths(), Slic3r::ProcessLayer::emit_custom_gcode_per_print_z(), Slic3r::WipeTowerIntegration::finalize(), Slic3r::GCode::PlaceholderParserIntegration::init(), Slic3r::WipeTowerIntegration::is_empty_wipe_tower_gcode(), Slic3r::need_wipe(), needs_retraction(), Slic3r::OozePrevention::post_toolchange(), Slic3r::OozePrevention::pre_toolchange(), print_machine_envelope(), process_layer(), set_extruder(), Slic3r::WipeTowerIntegration::tool_change(), Slic3r::GCode::PlaceholderParserIntegration::update_from_gcodewriter(), and Slic3r::Wipe::wipe().

Here is the caller graph for this function:

writer() [2/2]

const GCodeWriter & Slic3r::GCode::writer ( ) const

inlineinherited

{ return m_writer; }

References m_writer.

Member Data Documentation

m_avoid_crossing_perimeters

AvoidCrossingPerimeters Slic3r::GCode::m_avoid_crossing_perimeters

protectedinherited

Referenced by _do_export(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), emit_belt_brim_bands(), generate_object_brim(), generate_skirt(), and travel_to().

m_belt_brim_z

std::optional<coordf_t> Slic3r::GCode::m_belt_brim_z

protectedinherited

Referenced by _extrude(), and process_belt_brim_layer().

m_belt_floor_object

const PrintObject* Slic3r::GCode::m_belt_floor_object {nullptr}

protectedinherited

{nullptr};

Referenced by belt_height_above_floor(), emit_belt_brim_bands(), and generate_object_brim().

m_belt_in_band

bool Slic3r::GCode::m_belt_in_band {false}

protectedinherited

{false};

Referenced by _do_export(), and _extrude().

m_brim_done

bool Slic3r::GCode::m_brim_done

protectedinherited

Referenced by GCode(), and _do_export().

m_calib_config

DynamicConfig Slic3r::GCode::m_calib_config

protectedinherited

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

m_config

FullPrintConfig Slic3r::GCode::m_config

protectedinherited

Referenced by _do_export(), _extrude(), _needSAFC(), _print_first_layer_bed_temperature(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), apply_print_config(), change_layer(), compute_farthest_point(), config(), do_export(), emit_belt_brim_bands(), export_layer_filaments(), extrude_infill(), extrude_loop(), extrude_perimeters(), first_layer_band_mm(), gcode_to_point(), generate_object_brim(), get_bed_temperature(), get_highest_bed_temperature(), interpolate_value_across_layers(), needs_retraction(), on_first_layer(), Slic3r::BeltGCode::on_set_origin(), preamble(), process_belt_brim_layer(), process_layer(), process_layer_change_gcode(), process_layers(), retract(), set_extruder(), set_extruders(), set_filament_pressure_advance(), timelapse_gcode_config(), travel_to(), Slic3r::WipeTowerIntegration::travel_to_tower_gap(), update_layer_related_config(), and update_placeholder_parser_with_variant_params().

m_cooling_buffer

std::unique_ptr<CoolingBuffer> Slic3r::GCode::m_cooling_buffer

protectedinherited

Referenced by _do_export().

m_cur_layer_idx

size_t Slic3r::GCode::m_cur_layer_idx {0}

protectedinherited

{0};

Referenced by get_filament_config_index(), get_nozzle_config_index(), process_belt_brim_layer(), and process_layer().

m_curr_print

Print* Slic3r::GCode::m_curr_print = nullptr

protectedinherited

Referenced by _extrude(), do_export(), is_BBL_Printer(), needs_retraction(), and wipe_tower_type().

m_enable_cooling_markers

bool Slic3r::GCode::m_enable_cooling_markers

protectedinherited

Referenced by GCode(), _do_export(), _extrude(), enable_cooling_markers(), process_layer(), process_layers(), and process_layers().

m_enable_exclude_object

bool Slic3r::GCode::m_enable_exclude_object

protectedinherited

Referenced by _do_export(), apply_print_config(), and do_export().

m_enable_extrusion_role_markers

bool Slic3r::GCode::m_enable_extrusion_role_markers

protectedinherited

Referenced by GCode(), _do_export(), and _extrude().

m_enable_loop_clipping

bool Slic3r::GCode::m_enable_loop_clipping

protectedinherited

Referenced by GCode(), extrude_loop(), and process_layer().

m_exclusion_volume_travel_avoidance

ExclusionVolumeTravelAvoidance Slic3r::GCode::m_exclusion_volume_travel_avoidance

protectedinherited

Referenced by capture_toolchange_position(), do_export(), and travel_to().

m_extrusion_quality_estimator

ExtrusionQualityEstimator Slic3r::GCode::m_extrusion_quality_estimator

protectedinherited

Referenced by _extrude(), process_layer(), and process_layers().

m_fan_mover

std::unique_ptr<FanMover> Slic3r::GCode::m_fan_mover

protectedinherited

Referenced by _do_export().

m_farthest_point_timelapse

FarthestPointTimelapseContext Slic3r::GCode::m_farthest_point_timelapse

protectedinherited

Referenced by _extrude(), compute_farthest_point(), process_layer(), and timelapse_gcode_config().

m_filament_index_cache

ConfigIndexCache Slic3r::GCode::m_filament_index_cache

mutableprotectedinherited

Referenced by get_filament_config_index().

m_filament_instances_code

std::string Slic3r::GCode::m_filament_instances_code

protectedinherited

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

m_imex_head_filament_map

std::map<int,int> Slic3r::GCode::m_imex_head_filament_map

protectedinherited

Referenced by _do_export(), and process_layer().

m_imex_parallel_mode

std::string Slic3r::GCode::m_imex_parallel_mode

protectedinherited

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

m_initial_layer_extruders

std::set<unsigned int> Slic3r::GCode::m_initial_layer_extruders

protectedinherited

Referenced by do_export().

m_instance_names

std::unordered_map<const PrintInstance*, std::string> Slic3r::GCode::m_instance_names

protectedinherited

Referenced by assign_object_label_ids(), and instance_name().

m_is_role_based_fan_on

std::array<bool, ExtrusionRole::erCount> Slic3r::GCode::m_is_role_based_fan_on

protectedinherited

Referenced by _do_export(), and _extrude().

m_label_objects_ids

std::vector<size_t> Slic3r::GCode::m_label_objects_ids

protectedinherited

Referenced by _do_export(), and _encode_label_ids_to_base64().

m_last_extrusion_role

ExtrusionRole Slic3r::GCode::m_last_extrusion_role

protectedinherited

Referenced by GCode(), and _extrude().

m_last_height

float Slic3r::GCode::m_last_height { 0.0f }

protectedinherited

{ 0.0f };

Referenced by _do_export(), _extrude(), process_belt_brim_layer(), process_layer(), and Slic3r::WipeTowerIntegration::tower_height_tag().

m_last_layer_accumulated_mass

double Slic3r::GCode::m_last_layer_accumulated_mass { 0.0 }

protectedinherited

{ 0.0 };

Referenced by _do_export(), and process_layer_change_gcode().

m_last_layer_z

float Slic3r::GCode::m_last_layer_z { 0.0f }

protectedinherited

{ 0.0f };

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

m_last_mm3_mm

double Slic3r::GCode::m_last_mm3_mm = 0

protectedinherited

Referenced by _extrude().

m_last_notgapfill_extrusion_role

ExtrusionRole Slic3r::GCode::m_last_notgapfill_extrusion_role

protectedinherited

Referenced by _extrude(), and retract().

m_last_obj_copy

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

protectedinherited

Referenced by GCode().

m_last_pos

Point3 Slic3r::GCode::m_last_pos

protectedinherited

Referenced by _extrude(), capture_toolchange_position(), extrude_infill(), extrude_support(), last_pos(), set_last_pos(), set_last_pos(), and set_origin().

m_last_pos_defined

bool Slic3r::GCode::m_last_pos_defined

protectedinherited

Referenced by GCode(), _do_export(), _extrude(), capture_toolchange_position(), last_pos_defined(), set_extruder(), set_last_pos(), set_last_pos(), synchronize_toolchange_position(), and travel_to().

m_last_processor_extrusion_role

ExtrusionRole Slic3r::GCode::m_last_processor_extrusion_role

protectedinherited

Referenced by GCode(), _extrude(), and needs_retraction().

m_last_width

float Slic3r::GCode::m_last_width { 0.0f }

protectedinherited

{ 0.0f };

Referenced by GCode(), _do_export(), and _extrude().

m_layer

const Layer* Slic3r::GCode::m_layer

protectedinherited

Referenced by GCode(), _extrude(), belt_height_above_floor(), extrude_loop(), interpolate_value_across_layers(), layer(), layer_id(), needs_retraction(), on_first_layer(), process_belt_brim_layer(), process_layer(), set_extruder(), and travel_to().

m_layer_count

unsigned int Slic3r::GCode::m_layer_count

protectedinherited

Referenced by GCode(), _do_export(), change_layer(), interpolate_value_across_layers(), layer_count(), and set_layer_count().

m_layer_index

int Slic3r::GCode::m_layer_index

protectedinherited

Referenced by GCode(), _do_export(), _extrude(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), change_layer(), generate_timelapse_gcode(), interpolate_value_across_layers(), process_belt_brim_layer(), process_layer(), process_layer_change_gcode(), retract(), set_extruder(), and timelapse_gcode_config().

m_max_layer_z

float Slic3r::GCode::m_max_layer_z { 0.0f }

protectedinherited

{ 0.0f };

Referenced by _do_export(), Slic3r::WipeTowerIntegration::append_tcr(), process_belt_brim_layer(), process_layer(), process_layer_change_gcode(), set_extruder(), and timelapse_gcode_config().

m_multi_flow_segment_path_average_mm3_per_mm

double Slic3r::GCode::m_multi_flow_segment_path_average_mm3_per_mm = 0

protectedinherited

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

m_multi_flow_segment_path_pa_set

bool Slic3r::GCode::m_multi_flow_segment_path_pa_set = false

protectedinherited

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

m_need_change_layer_lift_z

bool Slic3r::GCode::m_need_change_layer_lift_z = false

protectedinherited

Referenced by _extrude(), Slic3r::WipeTowerIntegration::append_tcr2(), change_layer(), and travel_to().

m_nominal_z

coordf_t Slic3r::GCode::m_nominal_z

protectedinherited

Referenced by GCode(), _extrude(), change_layer(), and travel_to().

m_nozzle_index_cache

ConfigIndexCache Slic3r::GCode::m_nozzle_index_cache

mutableprotectedinherited

Referenced by get_nozzle_config_index().

m_object_layer_over_raft

bool Slic3r::GCode::m_object_layer_over_raft

protectedinherited

Referenced by GCode(), object_layer_over_raft(), and process_layer().

m_objsWithBrim

std::set<ObjectInstanceID> Slic3r::GCode::m_objsWithBrim

protectedinherited

Referenced by _do_export(), and generate_object_brim().

m_ooze_prevention

OozePrevention Slic3r::GCode::m_ooze_prevention

protectedinherited

Referenced by _do_export(), _print_first_layer_extruder_temperatures(), process_layer(), and set_extruder().

m_ordering_cache

std::map<unsigned int, IslandOrderCacheEntry> Slic3r::GCode::m_ordering_cache

protectedinherited

Referenced by _do_export(), and process_layer().

m_origin

Vec2d Slic3r::GCode::m_origin

protectedinherited

Referenced by GCode(), _do_export(), _extrude(), gcode_to_point(), needs_retraction(), origin(), point_to_gcode(), point_to_gcode(), and set_origin().

m_pa_processor

std::unique_ptr<AdaptivePAProcessor> Slic3r::GCode::m_pa_processor

protectedinherited

Referenced by _do_export(), and set_filament_pressure_advance().

m_pending_start_gcode_position

std::optional<GCodeProcessor::PositionState> Slic3r::GCode::m_pending_start_gcode_position

protectedinherited

Referenced by _do_export(), do_export(), set_last_pos(), set_last_pos(), and travel_to().

m_placeholder_parser_integration

struct Slic3r::GCode::PlaceholderParserIntegration Slic3r::GCode::m_placeholder_parser_integration

protectedinherited

Referenced by _do_export(), check_placeholder_parser_failed(), placeholder_parser(), placeholder_parser(), and placeholder_parser_process().

m_pressure_equalizer

std::unique_ptr<PressureEqualizer> Slic3r::GCode::m_pressure_equalizer

protectedinherited

Referenced by _do_export(), process_layers(), and process_layers().

m_print

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

protectedinherited

{nullptr};

Referenced by _do_export(), _extrude(), Slic3r::WipeTowerIntegration::append_tcr(), do_export(), export_layer_filaments(), get_extruder_id(), get_filament_config_index(), get_filament_config_index(), get_nozzle_config_index(), Slic3r::OozePrevention::pre_toolchange(), process_layer_change_gcode(), set_extruder(), Slic3r::WipeTowerIntegration::shared_printable_area(), update_layer_related_config(), and update_placeholder_parser_with_variant_params().

m_printed_objects

std::vector<const PrintObject*> Slic3r::GCode::m_printed_objects

protectedinherited

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

m_processor

GCodeProcessor Slic3r::GCode::m_processor

protectedinherited

Referenced by _do_export(), do_export(), extrude_loop(), set_gcode_offset(), and set_gcode_offset_with_imex_shift().

m_resonance_avoidance

bool Slic3r::GCode::m_resonance_avoidance

protectedinherited

Referenced by GCode(), and _extrude().

m_retract_when_crossing_perimeters

RetractWhenCrossingPerimeters Slic3r::GCode::m_retract_when_crossing_perimeters

protectedinherited

Referenced by needs_retraction().

m_role_based_fan_marker_layer

std::array<int, ExtrusionRole::erCount> Slic3r::GCode::m_role_based_fan_marker_layer

protectedinherited

Referenced by _do_export(), and _extrude().

m_scaled_resolution

double Slic3r::GCode::m_scaled_resolution

protectedinherited

Referenced by apply_print_config().

m_seam_placer

SeamPlacer Slic3r::GCode::m_seam_placer

protectedinherited

Referenced by _do_export(), and extrude_loop().

m_second_layer_things_done

bool Slic3r::GCode::m_second_layer_things_done

protectedinherited

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

m_skirt_group_done

std::vector<std::vector<coordf_t> > Slic3r::GCode::m_skirt_group_done

protectedinherited

Referenced by do_export(), and generate_object_skirt_group().

m_small_area_infill_flow_compensator

std::unique_ptr<SmallAreaInfillFlowCompensator> Slic3r::GCode::m_small_area_infill_flow_compensator

protectedinherited

Referenced by _do_export(), _extrude(), and _needSAFC().

m_sorted_layer_filaments

std::vector<std::vector<unsigned int> > Slic3r::GCode::m_sorted_layer_filaments

protectedinherited

Referenced by _do_export(), and export_layer_filaments().

m_spiral_vase

std::unique_ptr<SpiralVase> Slic3r::GCode::m_spiral_vase

protectedinherited

Referenced by _do_export(), change_layer(), do_export(), process_layer(), process_layers(), and retract().

m_start_gcode_filament

int Slic3r::GCode::m_start_gcode_filament = -1

protectedinherited

Referenced by _do_export(), and set_extruder().

m_sub_layer_flow_ratio

double Slic3r::GCode::m_sub_layer_flow_ratio = 0.0

protectedinherited

Referenced by _extrude().

m_sub_layer_height

double Slic3r::GCode::m_sub_layer_height = 0.0

protectedinherited

Referenced by _extrude().

m_support_traditional_timelapse

bool Slic3r::GCode::m_support_traditional_timelapse = true

protectedinherited

Referenced by do_export().

m_timelapse_pos_picker

TimelapsePosPicker Slic3r::GCode::m_timelapse_pos_picker

protectedinherited

Referenced by _do_export(), and timelapse_gcode_config().

m_timelapse_uses_clear_to_x0

bool Slic3r::GCode::m_timelapse_uses_clear_to_x0 { false }

protectedinherited

{ false };

Referenced by _do_export(), and timelapse_gcode_config().

m_timelapse_uses_pos

bool Slic3r::GCode::m_timelapse_uses_pos { false }

protectedinherited

{ false };

Referenced by _do_export(), and timelapse_gcode_config().

m_timelapse_warning_code

int Slic3r::GCode::m_timelapse_warning_code = 0

protectedinherited

Referenced by do_export().

m_toolchange_count

unsigned int Slic3r::GCode::m_toolchange_count

protectedinherited

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

m_wipe

Wipe Slic3r::GCode::m_wipe

protectedinherited

Referenced by Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), extrude_loop(), extrude_multi_path(), extrude_path(), extrude_perimeters(), retract(), set_extruder(), set_extruders(), set_origin(), and travel_to().

m_wipe_tower

std::unique_ptr<WipeTowerIntegration> Slic3r::GCode::m_wipe_tower

protectedinherited

Referenced by _do_export(), process_belt_brim_layer(), process_layer(), and process_layers().

m_writer

GCodeWriter Slic3r::GCode::m_writer

protectedinherited

Referenced by _do_export(), _extrude(), _print_first_layer_bed_temperature(), _print_first_layer_extruder_temperatures(), Slic3r::WipeTowerIntegration::append_tcr(), apply_print_config(), capture_toolchange_position(), change_layer(), cur_extruder_index(), do_export(), extrude_loop(), extrude_support(), gcode_to_point(), generate_timelapse_gcode(), Slic3r::BeltGCode::init_belt_writer(), needs_retraction(), placeholder_parser_process(), point_to_gcode_quantized(), point_to_gcode_quantized(), preamble(), print_machine_envelope(), process_belt_brim_layer(), process_layer(), process_layer_change_gcode(), retract(), set_extruder(), set_extruders(), set_filament_pressure_advance(), set_gcode_offset(), set_gcode_offset_with_imex_shift(), should_disable_arc_fitting(), synchronize_toolchange_position(), timelapse_gcode_config(), travel_to(), unretract(), update_layer_related_config(), writer(), and writer().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/BeltGCode.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/BeltGCode.cpp