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

Collaboration diagram for Slic3r::WipeTowerIntegration:

Public Member Functions
	WipeTowerIntegration (const PrintConfig &print_config, const int plate_idx, const Vec3d plate_origin, const std::vector< WipeTower::ToolChangeResult > &priming, const std::vector< std::vector< WipeTower::ToolChangeResult > > &tool_changes, const WipeTower::ToolChangeResult &final_purge, const std::vector< unsigned int > &slice_used_filaments)
std::string	prime (GCode &gcodegen)
void	next_layer ()
std::string	tool_change (GCode &gcodegen, int extruder_id, bool finish_layer)
bool	is_empty_wipe_tower_gcode (GCode &gcodegen, int extruder_id, bool finish_layer)
std::string	finalize (GCode &gcodegen)
std::vector< float >	used_filament_length () const
bool	is_first_print () const
void	set_is_first_print (bool is)
bool	enable_timelapse_print () const
void	set_wipe_tower_depth (float depth)
void	set_wipe_tower_bbx (const BoundingBoxf &bbx)
void	set_rib_offset (const Vec2f &rib_offset)

Private Member Functions
WipeTowerIntegration &	operator= (const WipeTowerIntegration &)
std::string	append_tcr (GCode &gcodegen, const WipeTower::ToolChangeResult &tcr, int new_extruder_id, double z=-1.) const
std::string	tower_height_tag (GCode &gcodegen, const WipeTower::ToolChangeResult &tcr, const std::string &tcr_gcode) const
Polyline	generate_path_to_wipe_tower (const Point &start_pos, const Point &end_pos, const BoundingBox &avoid_polygon, const Polygons &bed_polygons) const
std::string	append_tcr2 (GCode &gcodegen, const WipeTower::ToolChangeResult &tcr, int new_extruder_id, double z=-1.) const
std::string	travel_to_tower_gap (GCode &gcodegen, const Point &route_start, const Point &start_wipe_pos) const
Vec2f	transform_wt2_pt (const Vec2f &pt) const
Polygons	shared_printable_area (GCode &gcodegen) const
std::string	post_process_wipe_tower_moves (const WipeTower::ToolChangeResult &tcr, const Vec2f &translation, float angle) const

Private Attributes
const float	m_left
const float	m_right
const Vec2f	m_wipe_tower_pos
const float	m_wipe_tower_rotation
std::vector< Vec2d >	m_extruder_offsets
const std::vector< WipeTower::ToolChangeResult > &	m_priming
const std::vector< std::vector< WipeTower::ToolChangeResult > > &	m_tool_changes
const WipeTower::ToolChangeResult &	m_final_purge
int	m_layer_idx
int	m_tool_change_idx
double	m_last_wipe_tower_print_z
Vec3d	m_plate_origin
bool	m_single_extruder_multi_material
bool	m_enable_timelapse_print
bool	m_enable_wrapping_detection
bool	m_is_first_print
const PrintConfig *	m_print_config
float	m_wipe_tower_depth
BoundingBoxf	m_wipe_tower_bbx
Vec2f	m_rib_offset {Vec2f(0, 0)}
const bool	m_sparse_layers_skipped
const bool	m_sparse_layers_combined
std::vector< float >	m_compacted_tower_z

Detailed Description

Constructor & Destructor Documentation

◆ WipeTowerIntegration()

Slic3r::WipeTowerIntegration::WipeTowerIntegration	(	const PrintConfig &	print_config,
		const int	plate_idx,
		const Vec3d	plate_origin,
		const std::vector< WipeTower::ToolChangeResult > &	priming,
		const std::vector< std::vector< WipeTower::ToolChangeResult > > &	tool_changes,
		const WipeTower::ToolChangeResult &	final_purge,
		const std::vector< unsigned int > &	slice_used_filaments )

inline

                                                                                         :
        m_left(/*float(print_config.wipe_tower_x.value)*/ 0.f),
        m_right(float(/*print_config.wipe_tower_x.value +*/ print_config.prime_tower_width.value)),
        m_wipe_tower_pos(float(print_config.wipe_tower_x.get_at(plate_idx)), float(print_config.wipe_tower_y.get_at(plate_idx))),
        m_wipe_tower_rotation(float(print_config.wipe_tower_rotation_angle)),
        m_priming(priming),
        m_tool_changes(tool_changes),
        m_final_purge(final_purge),
        m_layer_idx(-1),
        m_tool_change_idx(0),
        m_plate_origin(plate_origin),
        m_single_extruder_multi_material(print_config.single_extruder_multi_material),
        m_enable_timelapse_print(print_config.timelapse_type.value == TimelapseType::tlSmooth),
        m_enable_wrapping_detection(print_config.enable_wrapping_detection && (print_config.wrapping_exclude_area.values.size() > 2) && (slice_used_filaments.size() <= 1)),
        m_is_first_print(true),
        m_print_config(&print_config),
        m_last_wipe_tower_print_z(print_config.z_offset.value),
        m_sparse_layers_skipped(wipe_tower_sparse_layers_skipped(print_config)),
        m_sparse_layers_combined(wipe_tower_sparse_layers_combined(print_config))
    {
        // Precomputed rather than accumulated while emitting, so that the clearance validator and
        // the emitter cannot disagree about where the compacted tower sits on any given layer.
        if (m_sparse_layers_skipped)
            m_compacted_tower_z = compute_compacted_wipe_tower_z(tool_changes, float(print_config.z_offset.value));
        // initialize with the extruder offset of master extruder id
        m_extruder_offsets.resize(print_config.filament_map.size(), print_config.extruder_offset.get_at(print_config.master_extruder_id.value - 1));
        const auto& filament_map = print_config.filament_map.values; // 1 based idx
        for (size_t idx = 0; idx < filament_map.size(); ++idx)
            m_extruder_offsets[idx] = print_config.extruder_offset.get_at(filament_map[idx] - 1);
    }

References Slic3r::compute_compacted_wipe_tower_z(), Slic3r::filament_map(), m_compacted_tower_z, m_enable_timelapse_print, m_enable_wrapping_detection, m_extruder_offsets, m_final_purge, m_is_first_print, m_last_wipe_tower_print_z, m_layer_idx, m_left, m_plate_origin, m_priming, m_print_config, m_right, m_single_extruder_multi_material, m_sparse_layers_combined, m_sparse_layers_skipped, m_tool_change_idx, m_tool_changes, m_wipe_tower_pos, m_wipe_tower_rotation, Slic3r::single_extruder_multi_material(), Slic3r::tlSmooth, Slic3r::wipe_tower_sparse_layers_combined(), Slic3r::wipe_tower_sparse_layers_skipped(), and Slic3r::wipe_tower_y().

Referenced by operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

◆ append_tcr()

std::string Slic3r::WipeTowerIntegration::append_tcr	(	GCode &	gcodegen,
		const WipeTower::ToolChangeResult &	tcr,
		int	new_extruder_id,
		double	z = -1. ) const

private

    {
        if (new_filament_id != -1 && new_filament_id != tcr.new_tool)
            throw Slic3r::InvalidArgument("Error: WipeTowerIntegration::append_tcr was asked to do a toolchange it didn't expect.");
 
        const std::optional<GCode::ToolchangePositionState> position_before_toolchange =
            gcodegen.capture_toolchange_position();
 
        int new_extruder_id = get_extruder_index(*m_print_config, new_filament_id);
 
        // Logical nozzle grouping for this print (null on paths that don't populate it).
        auto group_result = gcodegen.m_print->get_layered_nozzle_group_result();
 
        bool is_nozzle_change = !tcr.nozzle_change_result.gcode.empty() && (gcodegen.config().nozzle_diameter.size() > 1);
 
        std::string gcode;
 
        // Toolchangeresult.gcode assumes the wipe tower corner is at the origin (except for priming lines)
        // We want to rotate and shift all extrusions (gcode postprocessing) and starting and ending position
        float alpha = m_wipe_tower_rotation / 180.f * float(M_PI);
 
        auto transform_wt_pt = [&alpha, this](const Vec2f& pt) -> Vec2f {
            Vec2f out = Eigen::Rotation2Df(alpha) * pt;
            out += m_wipe_tower_pos + m_rib_offset;
            return out;
        };
 
        Vec2f start_pos = tcr.start_pos;
        Vec2f end_pos   = tcr.end_pos;
        Vec2f tool_change_start_pos = start_pos;
        if (tcr.is_tool_change)
            tool_change_start_pos = tcr.tool_change_start_pos;
        if (!tcr.priming) {
            start_pos = transform_wt_pt(start_pos);
            end_pos   = transform_wt_pt(end_pos);
            tool_change_start_pos = transform_wt_pt(tool_change_start_pos);
        }
 
        Vec2f wipe_tower_offset   = (tcr.priming ? Vec2f::Zero() : m_wipe_tower_pos) + m_rib_offset;
        float wipe_tower_rotation = tcr.priming ? 0.f : alpha;
 
        std::string tcr_rotated_gcode = post_process_wipe_tower_moves(tcr, wipe_tower_offset, wipe_tower_rotation);
 
        // BBS: add partplate logic
        Vec2f plate_origin_2d(m_plate_origin(0), m_plate_origin(1));
 
        // BBS: toolchange gcode will move to start_pos,
        // so only perform movement when printing sparse partition to support upper layer.
        // start_pos is the position in plate coordinate.
        if (!tcr.priming && tcr.is_finish_first) {
            // Move over the wipe tower.
            gcode += gcodegen.retract();
            gcodegen.m_avoid_crossing_perimeters.use_external_mp_once();
            gcode += gcodegen.travel_to(wipe_tower_point_to_object_point(gcodegen, start_pos + plate_origin_2d), erMixed,
                                        "Travel to a Wipe Tower");
            gcode += gcodegen.unretract();
        }
 
 
        double current_z = gcodegen.writer().get_position().z();
        if (z == -1.) // in case no specific z was provided, print at current_z pos
            z = current_z;
        // Orca: wipe_tower_no_sparse_layers crash guard. With sparse layers skipped the tower is
        // compacted far below the object, so descending to it is only safe once the nozzle is parked
        // over the tower - which is what the is_finish_first travel above does. Otherwise the nozzle
        // is still over the model and this descent would drive it into the print, so defer it to the
        // re-descents below, which run after the travel to the tower.
        const bool defer_compacted_descend = m_sparse_layers_skipped
            && !tcr.priming && !tcr.is_finish_first && (current_z - z) > EPSILON;
        if (!is_approx(z, current_z) && !defer_compacted_descend) {
            gcode += gcodegen.writer().retract();
            gcode += gcodegen.writer().travel_to_z(z, "Travel down to the last wipe tower layer.");
            gcode += gcodegen.writer().unretract();
        }
        // Tower compacted below the object, so any extrusion emitted without an explicit z has to be
        // pulled back down to it first.
        const bool compacted_below_object = m_sparse_layers_skipped && z >= 0. && (tcr.print_z - z) > EPSILON;
 
        // Process the end filament gcode.
        bool        add_change_filament_624 = false;
        std::string end_filament_gcode_str;
        if (gcodegen.writer().filament() != nullptr) {
            // Process the custom filament_end_gcode in case of single_extruder_multi_material.
            unsigned int        old_filament_id = gcodegen.writer().filament()->id();
            const std::string& filament_end_gcode = gcodegen.config().filament_end_gcode.get_at(old_filament_id);
            if (gcodegen.writer().filament() != nullptr && !filament_end_gcode.empty()) {
                DynamicConfig config;
                config.set_key_value("filament_extruder_id", new ConfigOptionInt((int) old_filament_id));
                config.set_key_value("current_filament_id", new ConfigOptionInt((int) old_filament_id));
                config.set_key_value("current_nozzle_id", new ConfigOptionInt(nozzle_id_for_gcode_placeholder(group_result, (int) old_filament_id, (int) gcodegen.writer().filament()->extruder_id(), m_layer_idx)));
                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(gcodegen.m_layer_index));
                config.set_key_value("layer_z", new ConfigOptionFloat(tcr.print_z));
                config.set_key_value("max_layer_z", new ConfigOptionFloat(gcodegen.m_max_layer_z));
                if (!gcodegen.m_filament_instances_code.empty()) {
                    end_filament_gcode_str += ("M624 " + gcodegen.m_filament_instances_code + "\n");
                    gcodegen.m_filament_instances_code = "";
                    add_change_filament_624 = true;
                }
                end_filament_gcode_str += gcodegen.placeholder_parser_process("filament_end_gcode", filament_end_gcode, old_filament_id, &config);
                check_add_eol(end_filament_gcode_str);
            }
        }
 
        std::string toolchange_gcode_str;
 
        ZHopType z_hope_type = ZHopType(gcodegen.config().z_hop_types.get_at(gcodegen.get_filament_config_index((int)gcodegen.writer().filament()->id())));
        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: should be placed before toolchange parsing
        std::string toolchange_retract_str = gcodegen.retract(tcr.is_tool_change && !is_nozzle_change, false, auto_lift_type, true);
        check_add_eol(toolchange_retract_str);
 
        //BBS: if needed, write the gcode_label_objects_end then priming tower, if the retract, didn't did it.
        std::string object_end_label_temp;
        gcodegen.m_writer.add_object_end_labels(object_end_label_temp);
 
        // Process the custom change_filament_gcode. If it is empty, provide a simple Tn command to change the filament.
        // Otherwise, leave control to the user completely.
        std::string change_filament_gcode = gcodegen.config().change_filament_gcode.value;
 
        bool is_used_travel_avoid_perimeter = gcodegen.m_config.prime_tower_skip_points.value;
        if (is_nozzle_change && !tcr.nozzle_change_result.is_extruder_change) is_used_travel_avoid_perimeter = false;
 
        // add nozzle change gcode into change filament gcode
        std::string nozzle_change_gcode_trans;
        if (is_nozzle_change) {
            // move to start_pos before nozzle change
            // Orca: travel_to() lifts to the object layer height to clear the print. That lift is
            // needed when arriving from the model, but is a wasted full-height Z bounce when the
            // nozzle already sits on the compacted tower, so travel at the compacted z instead.
            const bool compact_intower_nc_travel = compacted_below_object
                && (tcr.print_z - gcodegen.writer().get_position().z()) > EPSILON;
            std::string start_pos_str;
            start_pos_str = gcodegen.travel_to(wipe_tower_point_to_object_point(gcodegen, transform_wt_pt(tcr.nozzle_change_result.start_pos) + plate_origin_2d), erMixed,
                "Move to nozzle change start pos", compact_intower_nc_travel ? z : DBL_MAX);
            check_add_eol(start_pos_str);
            nozzle_change_gcode_trans += start_pos_str;
            // The nozzle-change wipe below carries no explicit z, so it would extrude at the object
            // layer height and float above the compacted tower. Descend unless the travel stayed down.
            if (!compact_intower_nc_travel && compacted_below_object) {
                std::string nc_z_descend = gcodegen.writer().travel_to_z(z, "Descend to compacted wipe tower z (no sparse layers)");
                check_add_eol(nc_z_descend);
                nozzle_change_gcode_trans += nc_z_descend;
            }
            nozzle_change_gcode_trans += gcodegen.unretract();
            nozzle_change_gcode_trans += transform_gcode(tcr.nozzle_change_result.gcode, tcr.nozzle_change_result.start_pos, wipe_tower_offset, wipe_tower_rotation);
            gcodegen.set_last_pos(wipe_tower_point_to_object_point(gcodegen, transform_wt_pt(tcr.nozzle_change_result.end_pos) + plate_origin_2d));
            gcodegen.m_wipe.reset_path();
            for (const Vec2f& wipe_pt : tcr.nozzle_change_result.wipe_path)
                gcodegen.m_wipe.path.points.emplace_back(wipe_tower_point_to_object_point(gcodegen, transform_wt_pt(wipe_pt) + plate_origin_2d));
            nozzle_change_gcode_trans += gcodegen.retract(tcr.is_tool_change, false, auto_lift_type, true);
            end_filament_gcode_str = nozzle_change_gcode_trans + end_filament_gcode_str;
        }
 
        end_filament_gcode_str = toolchange_retract_str + object_end_label_temp + end_filament_gcode_str;
 
        std::string wipe_next_start_point_str;
        bool        need_travel_after_change_filament_gcode = false; // travel need be after the filament changed to get the correct "m_curr_extruder_id"
        if (! change_filament_gcode.empty()) {
            DynamicConfig config;
            int old_filament_id = gcodegen.writer().filament() ? (int)gcodegen.writer().filament()->id() : -1;
            int old_extruder_id = gcodegen.writer().filament() ? (int)gcodegen.writer().filament()->extruder_id() : -1;
            // Logical nozzle ids for old/new filament (null-safe -> extruder id).
            int old_nozzle_id  = nozzle_id_for_gcode_placeholder(group_result, old_filament_id, old_extruder_id, m_layer_idx);
            int next_nozzle_id = nozzle_id_for_gcode_placeholder(group_result, new_filament_id, new_extruder_id, m_layer_idx);
 
            config.set_key_value("previous_extruder", new ConfigOptionInt(old_filament_id));
            config.set_key_value("next_extruder", new ConfigOptionInt(new_filament_id));
            const bool is_bbl_printer = gcodegen.m_print->is_BBL_printer();
            config.set_key_value("current_hotend", new ConfigOptionInt(
                hotend_id_for_gcode_placeholder(group_result, is_bbl_printer, old_filament_id, old_extruder_id, m_layer_idx)));
            config.set_key_value("next_hotend", new ConfigOptionInt(
                hotend_id_for_gcode_placeholder(group_result, is_bbl_printer, new_filament_id, (int) gcodegen.get_extruder_id(new_filament_id), m_layer_idx)));
            config.set_key_value("current_nozzle_id", new ConfigOptionInt(old_nozzle_id));
            config.set_key_value("next_nozzle_id", new ConfigOptionInt(next_nozzle_id));
            config.set_key_value("current_filament_id", new ConfigOptionInt(old_filament_id));
            config.set_key_value("next_filament_id", new ConfigOptionInt(new_filament_id));
            // Orca: nozzle-volume variant of the old/new extruder (e.g. "Direct Drive TPU High Flow"),
            // consumed by H2D's variant-aware change_filament_gcode. Null-safe: old_extruder_id may be -1.
            {
                const auto &extruder_variants = m_print_config->printer_extruder_variant.values;
                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()));
                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()));
            }
            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(gcodegen.m_layer_index));
            config.set_key_value("layer_z", new ConfigOptionFloat(tcr.print_z));
            config.set_key_value("toolchange_z", new ConfigOptionFloat(z));
            //            config.set_key_value("max_layer_z", new ConfigOptionFloat(m_max_layer_z));
            // BBS
            {
                GCodeWriter& gcode_writer = gcodegen.m_writer;
                FullPrintConfig& full_config = gcodegen.m_config;
 
                // Per-variant filament arrays can hold one column per variant a filament uses
                // under a per-layer nozzle grouping; resolve the column instead of the raw id.
                // The old filament resolves at the current layer, which is safe because the
                // per-layer maps are gap-filled carry-forward.
                size_t old_fi = (old_filament_id != -1) ? gcodegen.get_filament_config_index(old_filament_id) : 0;
                size_t new_fi = gcodegen.get_filament_config_index(new_filament_id);
 
                // set volumetric speed of outer wall ,ignore per obejct,just use default setting
                float outer_wall_volumetric_speed = get_outer_wall_volumetric_speed(full_config, *gcodegen.m_print, new_filament_id, (int)new_fi, gcodegen.get_extruder_id(new_filament_id));
                config.set_key_value("outer_wall_volumetric_speed", new ConfigOptionFloat(outer_wall_volumetric_speed));
 
                float old_retract_length = (old_filament_id != -1) ? full_config.retraction_length.get_at(old_fi) : 0;
                float new_retract_length = full_config.retraction_length.get_at(new_fi);
                float old_retract_length_toolchange = (old_filament_id != -1) ? full_config.retract_length_toolchange.get_at(old_fi) : 0;
                float new_retract_length_toolchange = full_config.retract_length_toolchange.get_at(new_fi);
                int old_filament_temp = (old_filament_id != -1) ? (gcodegen.on_first_layer()? full_config.nozzle_temperature_initial_layer.get_at(old_fi) : full_config.nozzle_temperature.get_at(old_fi)) : 210;
                int new_filament_temp = gcodegen.on_first_layer() ? full_config.nozzle_temperature_initial_layer.get_at(new_fi) : full_config.nozzle_temperature.get_at(new_fi);
                Vec3d nozzle_pos = gcode_writer.get_position();
 
                float purge_volume = tcr.purge_volume < EPSILON ? 0 : std::max(tcr.purge_volume, g_min_purge_volume);
                float filament_area = float((M_PI / 4.f) * pow(full_config.filament_diameter.get_at(new_filament_id), 2));
                float purge_length = purge_volume / filament_area;
 
                int old_filament_e_feedrate = (old_filament_id != -1) ? (int)(60.0 * full_config.filament_max_volumetric_speed.get_at(old_fi) / filament_area) : 200;
                old_filament_e_feedrate = old_filament_e_feedrate == 0 ? 100 : old_filament_e_feedrate;
                int new_filament_e_feedrate = (int)(60.0 * full_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;
                float wipe_avoid_pos_x      = 0.f;
                {
                    //set wipe_avoid_pos_x
                    Vec2f box_min = transform_wt_pt(m_wipe_tower_bbx.min.cast<float>());
                    Vec2f box_max = transform_wt_pt(m_wipe_tower_bbx.max.cast<float>());
                    wipe_avoid_pos_x = get_wipe_avoid_pos_x(box_min, box_max, 3.f);
                }
 
                // Position where the nozzle waits to heat, just outside the wipe tower. Clamp X to the
                // region every extruder can reach (shared printable polygon), which equals the full
                // printable_area for all current single/dual printers, so existing output is unchanged.
                Vec2f stop_pos = tool_change_start_pos;
                {
                    BoundingBoxf bbx = m_wipe_tower_bbx;
                    bbx.translate((m_wipe_tower_pos + m_rib_offset).cast<double>());
                    stop_pos.x() += (stop_pos.x() < bbx.center().x()) ? -2.f : 2.f;
                    auto printer_bbx = unscaled(get_extents(gcodegen.m_print->get_extruder_shared_printable_polygon()));
                    if (stop_pos.x() < printer_bbx.min[0]) stop_pos.x() = float(printer_bbx.min[0]);
                    if (stop_pos.x() > printer_bbx.max[0]) stop_pos.x() = float(printer_bbx.max[0]);
                }
                config.set_key_value("wipe_tower_wait_pos_x", new ConfigOptionFloat(stop_pos.x()));
                config.set_key_value("wipe_tower_wait_pos_y", new ConfigOptionFloat(stop_pos.y()));
                config.set_key_value("wipe_tower_wait_pos_valid", new ConfigOptionBool(true));
                // Bambu Studio's names for the wait position, used by its profiles.
                config.set_key_value("wipe_tower_center_pos_x", new ConfigOptionFloat(stop_pos.x()));
                config.set_key_value("wipe_tower_center_pos_y", new ConfigOptionFloat(stop_pos.y()));
                config.set_key_value("wipe_tower_center_pos_valid", new ConfigOptionBool(true));
 
                config.set_key_value("max_layer_z", new ConfigOptionFloat(gcodegen.m_max_layer_z));
                config.set_key_value("relative_e_axis", new ConfigOptionBool(full_config.use_relative_e_distances));
                config.set_key_value("toolchange_count", new ConfigOptionInt((int) gcodegen.m_toolchange_count + 1));
                // 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
                config.set_key_value("fan_speed", new ConfigOptionInt((int) 0));
                config.set_key_value("old_retract_length", new ConfigOptionFloat(old_retract_length));
                config.set_key_value("new_retract_length", new ConfigOptionFloat(new_retract_length));
                // Expose the old filament's nozzle-change retract length (filament_retract_length_nc; nil/-1 -> 0).
                config.set_key_value("filament_retract_length_nc", new ConfigOptionFloat(
                    (old_filament_id != -1) ? (float) full_config.filament_retract_length_nc.get_at(old_fi) : 0.f));
                config.set_key_value("old_retract_length_toolchange", new ConfigOptionFloat(old_retract_length_toolchange));
                config.set_key_value("new_retract_length_toolchange", new ConfigOptionFloat(new_retract_length_toolchange));
                // Current parked-retract length of the incoming filament's extruder.
                config.set_key_value("new_extruder_retracted_length",
                    new ConfigOptionFloat(gcode_writer.get_extruder_retracted_length((int) new_filament_id)));
                config.set_key_value("old_filament_temp", new ConfigOptionInt(old_filament_temp));
                int interface_temp = full_config.filament_tower_interface_print_temp.get_at(new_filament_id);
                if (interface_temp == -1)
                    interface_temp = full_config.nozzle_temperature_range_high.get_at(new_fi);
                if (full_config.enable_tower_interface_features && tcr.is_contact)
                    new_filament_temp = interface_temp;
                config.set_key_value("new_filament_temp", new ConfigOptionInt(new_filament_temp));
                if (full_config.enable_tower_interface_features && tcr.is_contact) {
                    // 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 = full_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 = gcodegen.get_filament_config_index((int)i);
                        temps[i]             = full_config.nozzle_temperature.get_at(fi_i);
                        first_layer_temps[i] = full_config.nozzle_temperature_initial_layer.get_at(fi_i);
                    }
                    if (new_filament_id >= 0 && new_filament_id < (int)temps.size())
                        temps[new_filament_id] = interface_temp;
                    config.set_key_value("temperature", new ConfigOptionInts(temps));
                    if (new_filament_id >= 0 && new_filament_id < (int)first_layer_temps.size())
                        first_layer_temps[new_filament_id] = interface_temp;
                    config.set_key_value("first_layer_temperature", new ConfigOptionInts(first_layer_temps));
                }
                config.set_key_value("x_after_toolchange", new ConfigOptionFloat(tool_change_start_pos(0)));
                config.set_key_value("y_after_toolchange", new ConfigOptionFloat(tool_change_start_pos(1)));
                config.set_key_value("z_after_toolchange", new ConfigOptionFloat(nozzle_pos(2)));
                config.set_key_value("first_flush_volume", new ConfigOptionFloat(purge_length / 2.f));
                config.set_key_value("second_flush_volume", new ConfigOptionFloat(purge_length / 2.f));
                config.set_key_value("old_filament_e_feedrate", new ConfigOptionInt(old_filament_e_feedrate));
                config.set_key_value("new_filament_e_feedrate", new ConfigOptionInt(new_filament_e_feedrate));
                config.set_key_value("travel_point_1_x", new ConfigOptionFloat(float(travel_point_1.x())));
                config.set_key_value("travel_point_1_y", new ConfigOptionFloat(float(travel_point_1.y())));
                config.set_key_value("travel_point_2_x", new ConfigOptionFloat(float(travel_point_2.x())));
                config.set_key_value("travel_point_2_y", new ConfigOptionFloat(float(travel_point_2.y())));
                config.set_key_value("travel_point_3_x", new ConfigOptionFloat(float(travel_point_3.x())));
                config.set_key_value("travel_point_3_y", new ConfigOptionFloat(float(travel_point_3.y())));
 
                {
                    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 = gcodegen.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);
                    }
                    if (tcr.is_contact || gcodegen.m_layer_index == 0)
                        std::fill(filament_cooling_before_tower.begin(), filament_cooling_before_tower.end(), 0);
                    config.set_key_value("flush_volumetric_speeds", new ConfigOptionFloats(flush_v_speed));
                    config.set_key_value("flush_temperatures", new ConfigOptionInts(flush_temps));
                    config.set_key_value("filament_cooling_before_tower", new ConfigOptionFloats(filament_cooling_before_tower));
                }
                config.set_key_value("flush_length", new ConfigOptionFloat(purge_length));
                config.set_key_value("wipe_avoid_perimeter", new ConfigOptionBool(is_used_travel_avoid_perimeter));
                config.set_key_value("wipe_avoid_pos_x", new ConfigOptionFloat(wipe_avoid_pos_x));
                config.set_key_value("is_prime_tower_interface", new ConfigOptionBool(tcr.is_contact));
                config.set_key_value("filament_tower_interface_purge_volume", new ConfigOptionFloat(full_config.filament_tower_interface_purge_volume.get_at(new_filament_id)));
                config.set_key_value("filament_tower_interface_print_temp", new ConfigOptionInt(interface_temp));
 
                int   flush_count = std::min(g_max_flush_count, (int) std::round(purge_volume / g_purge_volume_one_time));
                float flush_unit  = purge_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);
                    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);
                    config.set_key_value(key_value, new ConfigOptionFloat(0.f));
                }
            }
            toolchange_gcode_str = gcodegen.placeholder_parser_process("change_filament_gcode", change_filament_gcode, new_filament_id, &config);
 
            check_add_eol(toolchange_gcode_str);
            // Type1 wipe tower path (every BBL printer): bracket the same way set_extruder() does,
            // so FanMover doesn't split a G1 inside this custom gcode either.
            toolchange_gcode_str = wrap_custom_gcode_for_fan_mover(gcodegen.config(), toolchange_gcode_str);
 
            //BBS
            {
                //BBS: current position and fan_speed is unclear after interting change_filament_gcode
                check_add_eol(toolchange_gcode_str);
                toolchange_gcode_str += ";_FORCE_RESUME_FAN_SPEED\n";
                gcodegen.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_str, temp_z_after_tool_change)) {
                    Vec3d pos = gcodegen.writer().get_position();
                    pos(2)    = temp_z_after_tool_change;
                    gcodegen.writer().set_position(pos);
                }
            }
            need_travel_after_change_filament_gcode = true;
        }
 
        std::string toolchange_command;
        if (tcr.priming || (new_filament_id >= 0 && gcodegen.writer().need_toolchange(new_filament_id)))
            // Orca: null-safe, layer-aware nozzle lookup — group_result may be null on
            // non-multi-nozzle paths (the helper falls back to the extruder id).
            toolchange_command = gcodegen.writer().toolchange(new_filament_id,
                nozzle_id_for_gcode_placeholder(group_result, new_filament_id, new_extruder_id, m_layer_idx));
        if (!custom_gcode_changes_tool(toolchange_gcode_str, gcodegen.writer().toolchange_prefix(), new_filament_id))
            toolchange_gcode_str += toolchange_command;
        else {
            // We have informed the m_writer about the current extruder_id, we can ignore the generated G-code.
        }
 
        // The change G-code may move the carriage even when the incoming
        // filament uses the same physical nozzle (the common AMS case).
        // Synchronize before planning the tower-entry travel so exclusion
        // avoidance starts from the emitted position, not the stale one.
        if (position_before_toolchange)
            gcodegen.synchronize_toolchange_position(*position_before_toolchange, toolchange_gcode_str);
 
        if (need_travel_after_change_filament_gcode) {
            // move to start_pos for wiping after toolchange
            if (!is_used_travel_avoid_perimeter) {
                std::string start_pos_str = gcodegen.travel_to(wipe_tower_point_to_object_point(gcodegen, tool_change_start_pos + plate_origin_2d), erMixed, "Move to start pos");
                check_add_eol(start_pos_str);
                wipe_next_start_point_str = start_pos_str;
            } else {
                // BBS:change travel_path
                Vec3f gcode_last_pos;
                GCodeProcessor::get_last_position_from_gcode(toolchange_gcode_str, gcode_last_pos);
                Vec2f       gcode_last_pos2d{gcode_last_pos[0], gcode_last_pos[1]};
                Point       gcode_last_pos2d_object = gcodegen.gcode_to_point(gcode_last_pos2d.cast<double>() + plate_origin_2d.cast<double>());
                Point       start_wipe_pos          = wipe_tower_point_to_object_point(gcodegen, tool_change_start_pos + plate_origin_2d);
                BoundingBox avoid_bbx;
                {
                    // set avoid_bbx
                    avoid_bbx            = scaled(m_wipe_tower_bbx);
                    Polygon avoid_points = avoid_bbx.polygon();
                    for (auto &p : avoid_points.points) {
                        Vec2f pp = transform_wt_pt(unscale(p).cast<float>());
                        p        = wipe_tower_point_to_object_point(gcodegen, pp + plate_origin_2d);
                    }
                    avoid_bbx = BoundingBox(avoid_points.points);
                }
                std::string travel_to_wipe_tower_gcode;
                Polyline    travel_polyline = generate_path_to_wipe_tower(gcode_last_pos2d_object, start_wipe_pos, avoid_bbx, shared_printable_area(gcodegen));
 
                for (size_t i = 0; i < travel_polyline.points.size(); ++i) {
                    const auto &p = travel_polyline.points[i];
                    if (i == travel_polyline.points.size() - 1) {
                        wipe_next_start_point_str = gcodegen.travel_to(p, erMixed, "Move to start pos");
                        check_add_eol(wipe_next_start_point_str);
                        break;
                    }
                    travel_to_wipe_tower_gcode += gcodegen.travel_to(p, erMixed, "Move to start pos");
                    check_add_eol(travel_to_wipe_tower_gcode);
                }
                toolchange_gcode_str += travel_to_wipe_tower_gcode;
                gcodegen.set_last_pos(start_wipe_pos);
            }
        }
 
        // do unretract after setting current extruder_id
        // BBS pattern: the wipe tower shifts the toolchange start position outward for the
        // tower-interface (contact) pre-extrusion and for the PETG-with-filament-switcher case;
        // the pre-extrusion material itself is laid down here as extra unretract on the approach.
        // has_filament_switcher is a develop-only key read defensively from the full config (Orca
        // does not carry it as a static PrintConfig member — same convention as
        // enable_filament_dynamic_map); no shipping profile sets it, so is_petg_pre_extrusion is
        // always false fleet-wide.
        const ConfigOptionBool* has_filament_switcher_opt = gcodegen.m_print->full_print_config().option<ConfigOptionBool>("has_filament_switcher");
        bool is_contact_pre_extrusion = tcr.is_contact && gcodegen.m_config.enable_tower_interface_features;
        bool is_petg_pre_extrusion    = !is_contact_pre_extrusion
                                        && gcodegen.config().filament_type.get_at(tcr.new_tool) == "PETG"
                                        && has_filament_switcher_opt && has_filament_switcher_opt->value;
        float extra_unretract = 0.f;
        if (is_contact_pre_extrusion)
            extra_unretract = gcodegen.m_config.filament_tower_interface_pre_extrusion_length.get_at(tcr.new_tool);
        else if (is_petg_pre_extrusion)
            extra_unretract = 2.f;
        std::string toolchange_unretract_str = (extra_unretract > 0.f) ? gcodegen.unretract(extra_unretract) : gcodegen.unretract();
        check_add_eol(toolchange_unretract_str);
 
        gcodegen.placeholder_parser().set("current_extruder", new_filament_id);
        gcodegen.placeholder_parser().set("current_filament_id", new_filament_id);
        gcodegen.placeholder_parser().set("current_extruder_id", new_extruder_id);
        gcodegen.placeholder_parser().set("current_nozzle_id",
            nozzle_id_for_gcode_placeholder(group_result, new_filament_id, new_extruder_id, m_layer_idx));
        gcodegen.placeholder_parser().set("current_hotend",
            hotend_id_for_gcode_placeholder(group_result, gcodegen.m_print->is_BBL_printer(), new_filament_id, new_extruder_id, m_layer_idx));
        {
            size_t fi = gcodegen.get_filament_config_index(new_filament_id);
            gcodegen.placeholder_parser().set("retraction_distance_when_cut", gcodegen.m_config.retraction_distances_when_cut.get_at(fi));
            gcodegen.placeholder_parser().set("long_retraction_when_cut", gcodegen.m_config.long_retractions_when_cut.get_at(fi));
            gcodegen.placeholder_parser().set("retraction_distance_when_ec", gcodegen.m_config.retraction_distances_when_ec.get_at(fi));
            gcodegen.placeholder_parser().set("long_retraction_when_ec", gcodegen.m_config.long_retractions_when_ec.get_at(fi));
        }
 
        // Process the start filament gcode.
        std::string start_filament_gcode_str;
        const std::string &filament_start_gcode = gcodegen.config().filament_start_gcode.get_at(new_filament_id);
        if (!filament_start_gcode.empty()) {
            // Process the filament_start_gcode for the active filament only.
            DynamicConfig config;
            config.set_key_value("filament_extruder_id", new ConfigOptionInt(new_filament_id));
            config.set_key_value("current_filament_id", new ConfigOptionInt(new_filament_id));
            config.set_key_value("current_nozzle_id", new ConfigOptionInt(nozzle_id_for_gcode_placeholder(group_result, new_filament_id, new_extruder_id, m_layer_idx)));
            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(gcodegen.m_layer_index));
            config.set_key_value("layer_z", new ConfigOptionFloat(tcr.print_z));
            config.set_key_value("max_layer_z", new ConfigOptionFloat(gcodegen.m_max_layer_z));
            start_filament_gcode_str = gcodegen.placeholder_parser_process("filament_start_gcode", filament_start_gcode, new_filament_id, &config);
            if (add_change_filament_624) {
                start_filament_gcode_str += "M625\n";
                add_change_filament_624 = false;
            }
            check_add_eol(start_filament_gcode_str);
        }
 
        start_filament_gcode_str = start_filament_gcode_str + wipe_next_start_point_str + toolchange_unretract_str;
 
        // Orca: the custom change_filament_gcode lifts to the object layer height and the unretract
        // de-hops back to it, so every tower extrusion emitted after it (purge moves, and the wall
        // when it prints after the toolchange) would float above the compacted tower. Descend first.
        if (compacted_below_object) {
            std::string z_descend = gcodegen.writer().travel_to_z(z, "Descend to compacted wipe tower z (no sparse layers)");
            check_add_eol(z_descend);
            start_filament_gcode_str += z_descend;
        }
 
        // Insert the end filament, toolchange, and start filament gcode into the generated gcode.
        DynamicConfig config;
        config.set_key_value("filament_end_gcode", new ConfigOptionString(end_filament_gcode_str));
        config.set_key_value("change_filament_gcode", new ConfigOptionString(toolchange_gcode_str));
        config.set_key_value("filament_start_gcode", new ConfigOptionString(start_filament_gcode_str));
        std::string tcr_gcode, tcr_escaped_gcode = gcodegen.placeholder_parser_process("tcr_rotated_gcode", tcr_rotated_gcode, new_filament_id, &config);
        unescape_string_cstyle(tcr_escaped_gcode, tcr_gcode);
        gcode += tower_height_tag(gcodegen, tcr, tcr_gcode);
        gcode += tcr_gcode;
        // Count the toolchange only when the emitted block really changed the tool —
        // tower visits without a filament change must not advance the ordinal.
        if (custom_gcode_changes_tool(tcr_gcode, gcodegen.writer().toolchange_prefix(), new_filament_id))
            gcodegen.m_toolchange_count++;
        check_add_eol(toolchange_gcode_str);
 
        // SoftFever: set new PA for new filament
        gcode += gcodegen.set_filament_pressure_advance(new_filament_id);
 
        // A phony move to the end position at the wipe tower.
        gcodegen.writer().travel_to_xy((end_pos + plate_origin_2d).cast<double>());
        gcodegen.set_last_pos(wipe_tower_point_to_object_point(gcodegen, end_pos + plate_origin_2d));
        if (!is_approx(z, current_z)) {
            gcode += gcodegen.writer().retract();
            gcode += gcodegen.writer().travel_to_z(current_z, "Travel back up to the topmost object layer.");
            gcode += gcodegen.writer().unretract();
        }
 
        else {
            // Prepare a future wipe.
            gcodegen.m_wipe.reset_path();
            for (const Vec2f &wipe_pt : tcr.wipe_path)
                gcodegen.m_wipe.path.points.emplace_back(wipe_tower_point_to_object_point(gcodegen, transform_wt_pt(wipe_pt)));
            gcode += gcodegen.retract(false, false, auto_lift_type, true);
        }
 
        // Let the planner know we are traveling between objects.
        gcodegen.m_avoid_crossing_perimeters.use_external_mp_once();
        if (position_before_toolchange)
            gcodegen.synchronize_toolchange_position(*position_before_toolchange, gcode);
        return gcode;
    }

Referenced by tool_change().

Here is the caller graph for this function:

◆ append_tcr2()

std::string Slic3r::WipeTowerIntegration::append_tcr2	(	GCode &	gcodegen,
		const WipeTower::ToolChangeResult &	tcr,
		int	new_extruder_id,
		double	z = -1. ) const

private

    {
        if (new_extruder_id != -1 && new_extruder_id != tcr.new_tool)
            throw Slic3r::InvalidArgument("Error: WipeTowerIntegration::append_tcr was asked to do a toolchange it didn't expect.");
 
        const std::optional<GCode::ToolchangePositionState> position_before_toolchange =
            gcodegen.capture_toolchange_position();
 
        std::string gcode;
 
        // Toolchangeresult.gcode assumes the wipe tower corner is at the origin (except for priming lines)
        // We want to rotate and shift all extrusions (gcode postprocessing) and starting and ending position
        float alpha = m_wipe_tower_rotation / 180.f * float(M_PI);
 
        // Priming lines are absolute bed moves; everything else is tower-local
        // (transform_wt2_pt).
        Vec2f start_pos = tcr.start_pos;
        Vec2f end_pos   = tcr.end_pos;
        if (!tcr.priming) {
            start_pos = transform_wt2_pt(start_pos);
            end_pos   = transform_wt2_pt(end_pos);
        }
 
        Vec2f wipe_tower_offset   = tcr.priming ? Vec2f::Zero() : Vec2f(m_wipe_tower_pos + Eigen::Rotation2Df(alpha) * m_rib_offset);
        float wipe_tower_rotation = tcr.priming ? 0.f : alpha;
        Vec2f plate_origin_2d(m_plate_origin(0), m_plate_origin(1));
 
 
        std::string tcr_rotated_gcode = post_process_wipe_tower_moves(tcr, wipe_tower_offset, wipe_tower_rotation);
 
        gcode += gcodegen.writer().unlift(); // Make sure there is no z-hop (in most cases, there isn't).
 
        double current_z = gcodegen.writer().get_position().z();
 
 
        if (z == -1.) // in case no specific z was provided, print at current_z pos
            z = current_z;
 
        const bool needs_toolchange = gcodegen.writer().need_toolchange(new_extruder_id);
        const bool will_go_down     = !is_approx(z, current_z);
        const bool is_ramming       = (gcodegen.config().single_extruder_multi_material) ||
                                (!gcodegen.config().single_extruder_multi_material &&
                                 gcodegen.config().filament_multitool_ramming.get_at(gcodegen.get_filament_config_index(tcr.initial_tool)));
        // Orca: user-facing override (Printer Settings > Wipe tower > "Tool change on wipe tower").
        // Forces the toolhead to travel over the wipe tower before issuing Tx even on multi-toolhead
        // printers without ramming, where Orca would otherwise emit Tx in place (potentially over the part).
        const bool tool_change_on_wipe_tower = gcodegen.config().tool_change_on_wipe_tower.value;
        const bool should_travel_to_tower = !tcr.priming && (tcr.force_travel     // wipe tower says so
                                                             || !needs_toolchange // this is just finishing the tower with no toolchange
                                                             || will_go_down // Make sure to move to prime tower before moving down
                                                             || is_ramming
                                                             || tool_change_on_wipe_tower);
 
        const Point start_wipe_pos     = wipe_tower_point_to_object_point(gcodegen, start_pos + plate_origin_2d);
        const bool travel_to_tower_now = should_travel_to_tower || gcodegen.m_need_change_layer_lift_z;
        if (travel_to_tower_now) {
            // FIXME: It would be better if the wipe tower set the force_travel flag for all toolchanges,
            // then we could simplify the condition and make it more readable.
 
            // Orca: pass the configured lift type, as append_tcr does above. lazy_lift() keeps
            // the first type it is given, so the NormalLift default would pin this hop to a
            // standing move. Slope and spiral both need a known head position.
            LiftType lift_type = LiftType::NormalLift;
            if (gcodegen.writer().filament() != nullptr && gcodegen.writer().is_current_position_clear()) {
                ZHopType z_hop_type = ZHopType(gcodegen.config().z_hop_types.get_at(
                    gcodegen.get_filament_config_index((int) gcodegen.writer().filament()->id())));
                if (z_hop_type == ZHopType::zhtAuto)
                    z_hop_type = ZHopType::zhtSpiral;
                lift_type = gcodegen.to_lift_type(z_hop_type);
            }
            gcode += gcodegen.retract(false, false, lift_type);
            gcodegen.m_avoid_crossing_perimeters.use_external_mp_once();
            if (!tcr.priming && gcodegen.last_pos_defined())
                gcode += travel_to_tower_gap(gcodegen, gcodegen.last_pos(), start_wipe_pos);
            gcode += gcodegen.travel_to(start_wipe_pos, erMixed, "Travel to a Wipe Tower");
            gcode += gcodegen.unretract();
        } else {
            // When this is multiextruder printer without any ramming, we can just change
            // the tool without travelling to the tower. The tower entry travel then lives
            // inside the tcr gcode; with skip points on it is rerouted below, once the
            // toolchange gcode (and the head position it ends at) is known.
        }
 
        if (will_go_down) {
            gcode += gcodegen.writer().retract();
            gcode += gcodegen.writer().travel_to_z(z, "Travel down to the last wipe tower layer.");
            gcode += gcodegen.writer().unretract();
        }
 
        std::string toolchange_gcode_str;
        std::string deretraction_str;
        int toolchange_temp_override = -1;
        int interface_temp = -1;
        if (tcr.priming || (new_extruder_id >= 0 && needs_toolchange)) {
            if (is_ramming)
                gcodegen.m_wipe.reset_path();                                           // We don't want wiping on the ramming lines.
            if (gcodegen.config().enable_tower_interface_features && tcr.is_contact) {
                interface_temp = gcodegen.config().filament_tower_interface_print_temp.get_at(new_extruder_id);
                if (interface_temp == -1)
                    interface_temp = gcodegen.config().nozzle_temperature_range_high.get_at(gcodegen.get_filament_config_index(new_extruder_id));
                toolchange_temp_override = interface_temp;
            }
            toolchange_gcode_str = gcodegen.set_extruder(new_extruder_id, tcr.print_z, false, toolchange_temp_override,
                                                         WipeTower2::wait_for_temp_enabled(gcodegen.m_config)); // TODO: toolchange_z vs print_z
            if (!travel_to_tower_now && !tcr.priming && WipeTower2::use_gap_wall(gcodegen.m_config)) {
                // The tool changed in place (multi-tool printer without ramming), so the
                // tower entry is the tcr's own positioning move — a straight line across
                // the printed wall. Route it around the tower and in through the wall
                // opening instead, riding at the end of the change_filament_gcode
                // substitution so the generator's positioning move degrades to a
                // zero-length one (append_tcr parity: travel after the filament change,
                // retracted, with the new filament).
                Vec3f last_gcode_pos = gcodegen.writer().get_position().cast<float>();
                Point route_start;
                bool  have_start = false;
                if (GCodeProcessor::get_last_position_from_gcode(toolchange_gcode_str, last_gcode_pos)) {
                    // A custom change_filament_gcode may have moved the head (tool docks
                    // etc.); recover the real position from the emitted gcode.
                    route_start = gcodegen.gcode_to_point(Vec2d(last_gcode_pos.x(), last_gcode_pos.y()) + plate_origin_2d.cast<double>());
                    have_start  = true;
                } else if (gcodegen.last_pos_defined()) {
                    route_start = gcodegen.last_pos();
                    have_start  = true;
                }
                if (have_start) {
                    gcodegen.set_last_pos(route_start);
                    gcodegen.m_avoid_crossing_perimeters.use_external_mp_once();
                    std::string travel = travel_to_tower_gap(gcodegen, route_start, start_wipe_pos);
                    travel += gcodegen.travel_to(start_wipe_pos, erMixed, "Travel to a Wipe Tower");
                    check_add_eol(travel);
                    toolchange_gcode_str += travel;
                    gcodegen.set_last_pos(start_wipe_pos);
                }
            }
            if (gcodegen.config().enable_prime_tower) {
                deretraction_str += gcodegen.writer().travel_to_z(z, "Force restore layer Z", true);
                Vec3d position{gcodegen.writer().get_position()};
                position.z() = z;
                gcodegen.writer().set_position(position);
                deretraction_str += gcodegen.unretract();
            }
        }
 
        if (toolchange_temp_override > 0) {
            // new_extruder_id is the incoming filament id; resolve its per-variant config column.
            size_t new_fi = gcodegen.get_filament_config_index(new_extruder_id);
            int base_temp = gcodegen.on_first_layer() ? gcodegen.config().nozzle_temperature_initial_layer.get_at(new_fi)
                                                      : gcodegen.config().nozzle_temperature.get_at(new_fi);
            if (std::abs(tcr.print_z) < EPSILON)
                base_temp = gcodegen.config().nozzle_temperature_initial_layer.get_at(new_fi);
            // This pass strips the M109 that OozePrevention::post_toolchange just emitted into
            // toolchange_gcode_str, so it must look for the tool index that emission actually
            // wrote -- physical, translated by GCodeWriter::set_temperature -- not the logical
            // id the temperature lookups above use. Matching on the logical id would leave the
            // blocking M109 in place and silently defeat the tower interface temperature.
            // (The sibling scan further down reads WipeTower2 output, whose set_extruder_temp
            // emits no T at all, so it is deliberately left alone.)
            const int heater_id = imex_physical_heater_for(
                gcodegen.config().is_imex.value, gcodegen.config().physical_extruder_map, new_extruder_id);
            const std::string t_token = " T" + std::to_string(heater_id);
            std::string out;
            out.reserve(toolchange_gcode_str.size());
            size_t pos = 0;
            while (pos < toolchange_gcode_str.size()) {
                size_t line_end = toolchange_gcode_str.find('\n', pos);
                if (line_end == std::string::npos)
                    line_end = toolchange_gcode_str.size();
                std::string line = toolchange_gcode_str.substr(pos, line_end - pos);
                std::string trimmed = line;
                trimmed.erase(0, trimmed.find_first_not_of(" \t"));
                bool skip_line = false;
                if (boost::starts_with(trimmed, "M109")) {
                    bool matches_extruder = trimmed.find(t_token) != std::string::npos;
                    if (!matches_extruder) {
                        size_t t_pos = trimmed.find('T');
                        if (t_pos != std::string::npos) {
                            size_t t_end = trimmed.find_first_not_of("0123456789", t_pos + 1);
                            const std::string t_val = trimmed.substr(t_pos + 1, t_end == std::string::npos ? std::string::npos : t_end - (t_pos + 1));
                            if (!t_val.empty()) {
                                try {
                                    matches_extruder = std::stoi(t_val) == heater_id;
                                } catch (...) {
                                    matches_extruder = false;
                                }
                            }
                        }
                    }
                    if (matches_extruder) {
                        size_t s_pos = trimmed.find('S');
                        if (s_pos != std::string::npos) {
                            size_t s_end = trimmed.find_first_not_of("0123456789", s_pos + 1);
                            const std::string s_val = trimmed.substr(s_pos + 1, s_end == std::string::npos ? std::string::npos : s_end - (s_pos + 1));
                            if (!s_val.empty()) {
                                try {
                                    skip_line = std::stoi(s_val) == base_temp;
                                } catch (...) {
                                    skip_line = false;
                                }
                            }
                        }
                    }
                }
                if (!skip_line) {
                    out.append(line);
                    if (line_end < toolchange_gcode_str.size())
                        out.push_back('\n');
                }
                pos = line_end + 1;
            }
            toolchange_gcode_str.swap(out);
        }
 
        if (toolchange_temp_override > 0 && interface_temp > 0) {
            const std::string t_token = " T" + std::to_string(new_extruder_id);
            std::string out;
            out.reserve(tcr_rotated_gcode.size());
            size_t pos = 0;
            while (pos < tcr_rotated_gcode.size()) {
                size_t line_end = tcr_rotated_gcode.find('\n', pos);
                if (line_end == std::string::npos)
                    line_end = tcr_rotated_gcode.size();
                std::string line = tcr_rotated_gcode.substr(pos, line_end - pos);
                std::string trimmed = line;
                trimmed.erase(0, trimmed.find_first_not_of(" \t"));
                bool skip_line = false;
                if (boost::starts_with(trimmed, "M109") && trimmed.find(WipeTower2::wait_for_temp_tag()) == std::string::npos) {
                    bool matches_extruder = true;
                    if (trimmed.find('T') != std::string::npos)
                        matches_extruder = trimmed.find(t_token) != std::string::npos;
                    if (matches_extruder) {
                        size_t s_pos = trimmed.find('S');
                        if (s_pos != std::string::npos) {
                            size_t s_end = trimmed.find_first_not_of("0123456789", s_pos + 1);
                            const std::string s_val = trimmed.substr(s_pos + 1, s_end == std::string::npos ? std::string::npos : s_end - (s_pos + 1));
                            if (!s_val.empty()) {
                                try {
                                    skip_line = std::stoi(s_val) == interface_temp;
                                } catch (...) {
                                    skip_line = false;
                                }
                            }
                        }
                    }
                }
                if (!skip_line) {
                    out.append(line);
                    if (line_end < tcr_rotated_gcode.size())
                        out.push_back('\n');
                }
                pos = line_end + 1;
            }
            tcr_rotated_gcode.swap(out);
        }
 
        // Insert the toolchange and deretraction gcode into the generated gcode.
 
        DynamicConfig config;
        config.set_key_value("change_filament_gcode", new ConfigOptionString(toolchange_gcode_str));
        config.set_key_value("deretraction_from_wipe_tower_generator", new ConfigOptionString(deretraction_str));
        config.set_key_value("layer_num", new ConfigOptionInt(gcodegen.m_layer_index));
        config.set_key_value("layer_z", new ConfigOptionFloat(tcr.print_z));
        config.set_key_value("toolchange_z", new ConfigOptionFloat(z));
 
        std::string tcr_gcode,
            tcr_escaped_gcode = gcodegen.placeholder_parser_process("tcr_rotated_gcode", tcr_rotated_gcode, new_extruder_id, &config);
        unescape_string_cstyle(tcr_escaped_gcode, tcr_gcode);
        gcode += tower_height_tag(gcodegen, tcr, tcr_gcode);
        gcode += tcr_gcode;
        check_add_eol(toolchange_gcode_str);
 
        // SoftFever: set new PA for new filament
        if (new_extruder_id != -1)
            gcode += gcodegen.set_filament_pressure_advance(new_extruder_id);
 
        // A phony move to the end position at the wipe tower.
        gcodegen.writer().travel_to_xy((end_pos + plate_origin_2d).cast<double>());
        gcodegen.set_last_pos(wipe_tower_point_to_object_point(gcodegen, end_pos + plate_origin_2d));
        if (!is_approx(z, current_z)) {
            gcode += gcodegen.writer().retract();
            gcode += gcodegen.writer().travel_to_z(current_z, "Travel back up to the topmost object layer.");
            gcode += gcodegen.writer().unretract();
        }
 
        else {
            // Prepare a future wipe.
            gcodegen.m_wipe.reset_path();
            for (const Vec2f& wipe_pt : tcr.wipe_path)
                gcodegen.m_wipe.path.points.emplace_back(wipe_tower_point_to_object_point(gcodegen, transform_wt2_pt(wipe_pt) + plate_origin_2d));
        }
 
        // Let the planner know we are traveling between objects.
        gcodegen.m_avoid_crossing_perimeters.use_external_mp_once();
        if (position_before_toolchange)
            gcodegen.synchronize_toolchange_position(*position_before_toolchange, gcode);
        return gcode;
    }

Referenced by finalize(), prime(), and tool_change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ enable_timelapse_print()

bool Slic3r::WipeTowerIntegration::enable_timelapse_print ( ) const

inline

154{ return m_enable_timelapse_print; }

References m_enable_timelapse_print.

◆ finalize()

std::string Slic3r::WipeTowerIntegration::finalize ( GCode & gcodegen )

    {
        std::string gcode;
        if (gcodegen.wipe_tower_type() == WipeTowerType::Type2 && !m_final_purge.gcode.empty()) {
            if (std::abs(gcodegen.writer().get_position().z() - m_final_purge.print_z) > EPSILON)
                gcode += gcodegen.change_layer(m_final_purge.print_z);
            gcode += append_tcr2(gcodegen, m_final_purge, -1);
        }
 
        return gcode;
    }

References append_tcr2(), Slic3r::GCode::change_layer(), EPSILON, Slic3r::GCodeWriter::get_position(), m_final_purge, Slic3r::Type2, Slic3r::GCode::wipe_tower_type(), and Slic3r::GCode::writer().

Here is the call graph for this function:

◆ generate_path_to_wipe_tower()

Polyline Slic3r::WipeTowerIntegration::generate_path_to_wipe_tower	(	const Point &	start_pos,
		const Point &	end_pos,
		const BoundingBox &	avoid_polygon,
		const Polygons &	bed_polygons ) const

private

    {
        Polyline    res;
        coord_t         alpha = scaled(wipe_tower_routing_clearance); // offset distance
        BoundingBox avoid_polygon_inner = avoid_polygon;
        avoid_polygon_inner.offset(alpha);
        coord_t width = avoid_polygon_inner.max[0] - avoid_polygon_inner.min[0];
        Vec2f v(1, 0);                                                      // the first print direction of end_pos.
        if (abs(end_pos[0] - avoid_polygon_inner.min[0]) < width / 2) v = -v; // judge whether the wipe tower's infill goes to the left or right.
        // Judge whether the avoid_polygon_inner is outside the bed. The real printable
        // outline is tested (not its bounding box), so on circular/custom beds corners
        // hanging off the bed are rejected.
        // If so, do nothing and just go directly to the end_pos.
        Points avoid_points  = avoid_polygon_inner.polygon().points;
        const bool is_bbx_in_bed = std::all_of(avoid_points.begin(), avoid_points.end(),
            [&bed_polygons](const Point &pt) { return contains(bed_polygons, pt, /*border_result=*/false); });
        if (!is_bbx_in_bed) {
            res.points.push_back(end_pos);
            return res;
        }
        // Ray-Line Segment Intersection
        auto ray_intersetion_line = [](const Vec2d &a, const Vec2d &v1, const Vec2d &b, const Vec2d &c) -> std::pair<bool, Point> {
            const Vec2d v2    = c - b;
            double      denom = cross2(v1, v2);
            if (fabs(denom) < EPSILON) return {false, Point(0, 0)};
            const Vec2d v12    = (a - b);
            double      nume_a = cross2(v2, v12);
            double      nume_b = cross2(v1, v12);
            double      t1     = nume_a / denom;
            double      t2     = nume_b / denom;
            if (t1 >= 0 && t2 >= 0 && t2 <= 1.) {
                // Get the intersection point.
                Vec2d res = a + t1 * v1;
                return std::pair<bool, Point>(true, scaled(res));
            }
            return std::pair<bool, Point>(false, {0, 0});
        };
        struct Inter_info
        {
            int   inter_idx0 = -1;
            Point inter_p;
        };
        auto calc_path_len = [](Points &points, Inter_info &beg_info, Inter_info &end_info, bool is_add) -> std::pair<std::vector<Point>, double> {
            int                beg = is_add ? (beg_info.inter_idx0 + 1) % points.size() : beg_info.inter_idx0;
            int                end = is_add ? end_info.inter_idx0 : (end_info.inter_idx0 + 1) % points.size();
            int                i   = beg;
            double             len = 0;
            std::vector<Point> path;
            path.push_back(beg_info.inter_p);
            len += (unscale(beg_info.inter_p) - unscale(points[beg])).squaredNorm();
            while (i != end) {
                int  ni = is_add ? (i + 1) % points.size() : (i - 1 + points.size()) % points.size();
                auto a  = unscale(points[i]);
                auto b  = unscale(points[ni]);
                len += (a - b).squaredNorm();
                path.push_back(points[i]);
                i = ni;
            }
            path.push_back(points[end]);
            path.push_back(end_info.inter_p);
            len += (unscale(end_info.inter_p) - unscale(points[end])).squaredNorm();
            return {path, len};
        };
        // calculate the intersection point of end_pos along vector v with the avoid_polygon.
        // store in inter_info.
        // represent this intersection by 'p'.
        Inter_info inter_info;
        for (size_t i = 0; i < avoid_points.size(); i++) {
            const auto &a                  = avoid_points[i];
            const auto &b                  = avoid_points[(i + 1) % avoid_points.size()];
            auto [is_inter, inter_p] = ray_intersetion_line(unscale(end_pos), v.cast<double>(), unscale(a), unscale(b));
            if (is_inter) {
                inter_info.inter_idx0 = i;
                inter_info.inter_p    = inter_p;
                break;
            }
        }
        if (inter_info.inter_idx0 == -1) {
            res.points.push_back(end_pos);
            return res;
        }
        // calculate the other intersection of start_to_p with the avoid_polygon.
        // represent this intersection by 'p_'.
        Inter_info inter_info2;
        Linef      start_to_p(unscale(start_pos), unscale(inter_info.inter_p));
        for (size_t i = 0; i < avoid_points.size(); i++) {
            if (i == inter_info.inter_idx0) continue;
            Vec2d a = unscale(avoid_points[i]);
            Vec2d b = unscale(avoid_points[(i + 1) % avoid_points.size()]);
            Linef tower_edge(a, b);
            Vec2d inter;
            if (line_alg::intersection(start_to_p, tower_edge, &inter)) {
                inter_info2.inter_p    = scaled(inter);
                inter_info2.inter_idx0 = i;
                break;
            }
        }
        // if p_ does not exist, go directly to p.
        // else p travels along the shorter path on the wipe_tower_offset_polygon to p_
        if (inter_info2.inter_idx0 == -1) {
            res.points.push_back(inter_info.inter_p);
        } else {
            std::vector<Point> path;
            auto [path1, len1] = calc_path_len(avoid_points, inter_info2, inter_info, true);
            auto [path2, len2] = calc_path_len(avoid_points, inter_info2, inter_info, false);
            path               = len1 < len2 ? path1 : path2;
            for (size_t i = 0; i < path.size(); i++) {
                res.points.push_back(path[i]);
            }
        }
        res.points.push_back(end_pos);
        return res;
    }

References Slic3r::cross2(), EPSILON, Slic3r::line_alg::intersection(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::BoundingBoxBase< PointType, APointsType >::offset(), Slic3r::MultiPoint::points, Slic3r::BoundingBox::polygon(), Slic3r::ray_intersetion_line(), Slic3r::scaled(), Slic3r::unscale(), and Slic3r::wipe_tower_routing_clearance.

Referenced by append_tcr(), and travel_to_tower_gap().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_empty_wipe_tower_gcode()

bool Slic3r::WipeTowerIntegration::is_empty_wipe_tower_gcode	(	GCode &	gcodegen,
		int	extruder_id,
		bool	finish_layer )

    {
        assert(m_layer_idx >= 0);
        if (m_layer_idx >= (int) m_tool_changes.size())
            return true;
 
        bool   ignore_sparse = wipe_tower_layer_is_combined_away(m_tool_changes[m_layer_idx]);
        if (m_sparse_layers_skipped)
            ignore_sparse = wipe_tower_layer_is_sparse(m_tool_changes[m_layer_idx]);
 
        if ((m_enable_timelapse_print || m_enable_wrapping_detection) && m_is_first_print) {
            return false;
        }
 
        if (gcodegen.writer().need_toolchange(extruder_id) || finish_layer) {
            if (!(size_t(m_tool_change_idx) < m_tool_changes[m_layer_idx].size()))
                throw Slic3r::RuntimeError(_(L("Wipe tower generation failed, possibly due to empty first layer.")));
 
            if (!ignore_sparse) {
                return false;
            }
        }
 
        return true;
    }

References _, L, m_enable_timelapse_print, m_enable_wrapping_detection, m_is_first_print, m_layer_idx, m_sparse_layers_skipped, m_tool_change_idx, m_tool_changes, Slic3r::GCodeWriter::need_toolchange(), Slic3r::wipe_tower_layer_is_combined_away(), Slic3r::wipe_tower_layer_is_sparse(), and Slic3r::GCode::writer().

Here is the call graph for this function:

◆ is_first_print()

bool Slic3r::WipeTowerIntegration::is_first_print ( ) const

inline

151{ return m_is_first_print;}

References m_is_first_print.

◆ next_layer()

void Slic3r::WipeTowerIntegration::next_layer ( )

inline

145{ ++ m_layer_idx; m_tool_change_idx = 0; }

References m_layer_idx, and m_tool_change_idx.

◆ operator=()

WipeTowerIntegration & Slic3r::WipeTowerIntegration::operator= ( const WipeTowerIntegration & )

private

References WipeTowerIntegration(), and Slic3r::angle().

Here is the call graph for this function:

◆ post_process_wipe_tower_moves()

std::string Slic3r::WipeTowerIntegration::post_process_wipe_tower_moves	(	const WipeTower::ToolChangeResult &	tcr,
		const Vec2f &	translation,
		float	angle ) const

private

    {
        Vec2f extruder_offset;
        if (m_single_extruder_multi_material)
            extruder_offset = m_extruder_offsets[0].cast<float>();
        else
            extruder_offset = m_extruder_offsets[tcr.initial_tool].cast<float>();
 
        std::istringstream gcode_str(tcr.gcode);
        std::string gcode_out;
        std::string line;
        Vec2f pos = tcr.start_pos;
        auto  trans_pos = [wt_rot = Eigen::Rotation2Df(angle), &translation](const Vec2f& p) -> Vec2f { return wt_rot * p + translation; };
        Vec2f transformed_pos = trans_pos(pos);
        Vec2f old_pos(-1000.1f, -1000.1f);
 
        while (gcode_str) {
            std::getline(gcode_str, line);  // we read the gcode line by line
 
            // All G1 commands should be translated and rotated. X and Y coords are
            // only pushed to the output when they differ from last time.
            // WT generator can override this by appending the never_skip_tag
            if (line.find("G1 ") == 0 || line.find("G2 ") == 0 || line.find("G3 ") == 0) {
                std::string cur_gcode_start = line.find("G1 ") == 0 ? "G1 " : (line.find("G2 ") == 0 ? "G2 " : "G3 ");
                bool        never_skip      = false;
                auto        it              = line.find(WipeTower::never_skip_tag());
                if (it != std::string::npos) {
                    // remove the tag and remember we saw it
                    never_skip = true;
                    line.erase(it, it + WipeTower::never_skip_tag().size());
                }
                std::ostringstream line_out;
                std::istringstream line_str(line);
                line_str >> std::noskipws; // don't skip whitespace
                char ch = 0;
                while (line_str >> ch) {
                    if (ch == 'X' || ch == 'Y')
                        line_str >> (ch == 'X' ? pos.x() : pos.y());
                    else
                        line_out << ch;
                }
                // Strip original wipe tower X/Y even if position unchanged (fixes out of bed moves).
                line = line_out.str();
 
                transformed_pos = trans_pos(pos);
 
                if (transformed_pos != old_pos || never_skip) {
                    std::ostringstream oss;
                    oss << std::fixed << std::setprecision(3) << cur_gcode_start;
                    if (transformed_pos.x() != old_pos.x() || never_skip)
                        oss << " X" << transformed_pos.x() - extruder_offset.x();
                    if (transformed_pos.y() != old_pos.y() || never_skip)
                        oss << " Y" << transformed_pos.y() - extruder_offset.y();
                    oss << " ";
                    line.replace(line.find(cur_gcode_start), 3, oss.str());
                    old_pos = transformed_pos;
                }
            }
 
            gcode_out += line + "\n";
 
            // If this was a toolchange command, we should change current extruder offset
            if (line == "[change_filament_gcode]") {
                // BBS
                if (!m_single_extruder_multi_material) {
                    extruder_offset = m_extruder_offsets[tcr.new_tool].cast<float>();
 
                    // If the extruder offset changed, add an extra move so everything is continuous
                    if (extruder_offset != m_extruder_offsets[tcr.initial_tool].cast<float>()) {
                        std::ostringstream oss;
                        oss << std::fixed << std::setprecision(3)
                            << "G1 X" << transformed_pos.x() - extruder_offset.x()
                            << " Y" << transformed_pos.y() - extruder_offset.y()
                            << "\n";
                        gcode_out += oss.str();
                    }
                }
                old_pos = Vec2f{-1000.1f, -1000.1f};
                pos     = tcr.tool_change_start_pos;
                transformed_pos = trans_pos(pos);
            }
        }
        return gcode_out;
    }

References Slic3r::angle(), Slic3r::extruder_offset(), Slic3r::WipeTower::ToolChangeResult::gcode, Slic3r::WipeTower::ToolChangeResult::initial_tool, m_extruder_offsets, m_single_extruder_multi_material, Slic3r::WipeTower::never_skip_tag(), Slic3r::WipeTower::ToolChangeResult::new_tool, Slic3r::WipeTower::ToolChangeResult::start_pos, and Slic3r::WipeTower::ToolChangeResult::tool_change_start_pos.

Referenced by append_tcr(), and append_tcr2().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prime()

std::string Slic3r::WipeTowerIntegration::prime ( GCode & gcodegen )

    {
        std::string gcode;
        if (gcodegen.wipe_tower_type() == WipeTowerType::Type2) {
            for (const WipeTower::ToolChangeResult &tcr : m_priming) {
                if (!tcr.extrusions.empty())
                    gcode += append_tcr2(gcodegen, tcr, tcr.new_tool);
            }
        }
        return gcode;
    }

References append_tcr2(), m_priming, Slic3r::Type2, and Slic3r::GCode::wipe_tower_type().

Here is the call graph for this function:

◆ set_is_first_print()

void Slic3r::WipeTowerIntegration::set_is_first_print ( bool is )

inline

152{ m_is_first_print = is; }

References m_is_first_print.

◆ set_rib_offset()

void Slic3r::WipeTowerIntegration::set_rib_offset ( const Vec2f & rib_offset )

inline

157{ m_rib_offset = rib_offset; }

References m_rib_offset.

◆ set_wipe_tower_bbx()

void Slic3r::WipeTowerIntegration::set_wipe_tower_bbx ( const BoundingBoxf & bbx )

inline

156{ m_wipe_tower_bbx = bbx; }

References m_wipe_tower_bbx.

◆ set_wipe_tower_depth()

void Slic3r::WipeTowerIntegration::set_wipe_tower_depth ( float depth )

inline

155{ m_wipe_tower_depth = depth; }

Slic3r::WipeTowerIntegration::m_wipe_tower_depth

float m_wipe_tower_depth

Definition GCode.hpp:194

References m_wipe_tower_depth.

◆ shared_printable_area()

Polygons Slic3r::WipeTowerIntegration::shared_printable_area ( GCode & gcodegen ) const

private

    {
        // The frame change is a pure translation, so transform the origin once.
        const Point offset = wipe_tower_point_to_object_point(gcodegen, Vec2f(m_plate_origin(0), m_plate_origin(1)));
        Polygons    bed_polygons = gcodegen.m_print->get_extruder_shared_printable_polygon();
        for (Polygon &poly : bed_polygons)
            poly.translate(offset);
        return bed_polygons;
    }

References Slic3r::Print::get_extruder_shared_printable_polygon(), m_plate_origin, Slic3r::GCode::m_print, Slic3r::offset(), and Slic3r::wipe_tower_point_to_object_point().

Referenced by append_tcr(), and travel_to_tower_gap().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tool_change()

std::string Slic3r::WipeTowerIntegration::tool_change	(	GCode &	gcodegen,
		int	extruder_id,
		bool	finish_layer )

    {
        std::string gcode;
 
        assert(m_layer_idx >= 0);
        if (m_layer_idx >= (int) m_tool_changes.size())
            return gcode;
        if (gcodegen.wipe_tower_type() == WipeTowerType::Type2) {
            if (gcodegen.writer().need_toolchange(extruder_id) || finish_layer) {
                if (m_layer_idx < (int) m_tool_changes.size()) {
                    if (!(size_t(m_tool_change_idx) < m_tool_changes[m_layer_idx].size()))
                        throw Slic3r::RuntimeError(_(L("Wipe tower generation failed, possibly due to empty first layer.")));
 
                    // Calculate where the wipe tower layer will be printed. -1 means that print z will not change,
                    // resulting in a wipe tower with sparse layers.
                    double wipe_tower_z  = -1;
                    // Folded into a later, thicker layer that prints at its own z: nothing to emit.
                    bool   ignore_sparse = wipe_tower_layer_is_combined_away(m_tool_changes[m_layer_idx]);
                    if (m_sparse_layers_skipped) {
                        wipe_tower_z  = m_last_wipe_tower_print_z;
                        ignore_sparse = wipe_tower_layer_is_sparse(m_tool_changes[m_layer_idx]) && m_layer_idx != 0;
                        if (m_tool_change_idx == 0 && !ignore_sparse)
                        wipe_tower_z = m_last_wipe_tower_print_z + m_tool_changes[m_layer_idx].front().layer_height;
                    }
 
                    if (!ignore_sparse) {
                        gcode += append_tcr2(gcodegen, m_tool_changes[m_layer_idx][m_tool_change_idx++], extruder_id, wipe_tower_z);
                        m_last_wipe_tower_print_z = wipe_tower_z;
                    }
                }
            }
        } else {
            // Calculate where the wipe tower layer will be printed. -1 means that print z will not change,
            // resulting in a wipe tower with sparse layers.
            double wipe_tower_z  = -1;
            // Folded into a later, thicker layer that prints at its own z: nothing to emit.
            bool   ignore_sparse = wipe_tower_layer_is_combined_away(m_tool_changes[m_layer_idx]);
            if (m_sparse_layers_skipped) {
                ignore_sparse = wipe_tower_layer_is_sparse(m_tool_changes[m_layer_idx]);
                wipe_tower_z  = m_compacted_tower_z[m_layer_idx];
            }
 
            if ((m_enable_timelapse_print || m_enable_wrapping_detection) && m_is_first_print) {
                gcode += append_tcr(gcodegen, m_tool_changes[m_layer_idx][0], m_tool_changes[m_layer_idx][0].new_tool, wipe_tower_z);
                m_tool_change_idx++;
                m_is_first_print = false;
            }
 
            if (gcodegen.writer().need_toolchange(extruder_id) || finish_layer) {
                if (!(size_t(m_tool_change_idx) < m_tool_changes[m_layer_idx].size()))
                    throw Slic3r::RuntimeError(_(L("Wipe tower generation failed, possibly due to empty first layer.")));
 
                if (!ignore_sparse)
                    gcode += append_tcr(gcodegen, m_tool_changes[m_layer_idx][m_tool_change_idx++], extruder_id, wipe_tower_z);
            }
        }
 
        return gcode;
    }

References _, append_tcr(), append_tcr2(), L, m_compacted_tower_z, m_enable_timelapse_print, m_enable_wrapping_detection, m_is_first_print, m_last_wipe_tower_print_z, m_layer_idx, m_sparse_layers_skipped, m_tool_change_idx, m_tool_changes, Slic3r::GCodeWriter::need_toolchange(), Slic3r::Type2, Slic3r::wipe_tower_layer_is_combined_away(), Slic3r::wipe_tower_layer_is_sparse(), Slic3r::GCode::wipe_tower_type(), and Slic3r::GCode::writer().

Here is the call graph for this function:

◆ tower_height_tag()

std::string Slic3r::WipeTowerIntegration::tower_height_tag	(	GCode &	gcodegen,
		const WipeTower::ToolChangeResult &	tcr,
		const std::string &	tcr_gcode ) const

private

    {
        const std::string tag = ";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height);
        if (! m_sparse_layers_combined || std::abs(gcodegen.m_last_height - tcr.layer_height) <= EPSILON ||
            tcr_gcode.find(tag) != std::string::npos)
            return {};
        // Keep m_last_height what the G-code last declared, so a second visit does not repeat it.
        gcodegen.m_last_height = tcr.layer_height;
        char buf[64];
        sprintf(buf, "%s%g\n", tag.c_str(), tcr.layer_height);
        return buf;
    }

References EPSILON, Slic3r::GCodeProcessor::Height, Slic3r::WipeTower::ToolChangeResult::layer_height, Slic3r::GCode::m_last_height, m_sparse_layers_combined, and Slic3r::GCodeProcessor::reserved_tag().

Referenced by append_tcr(), and append_tcr2().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ transform_wt2_pt()

Vec2f Slic3r::WipeTowerIntegration::transform_wt2_pt ( const Vec2f & pt ) const

private

    {
        const float alpha = m_wipe_tower_rotation / 180.f * float(M_PI);
        return Eigen::Rotation2Df(alpha) * (pt + m_rib_offset) + m_wipe_tower_pos;
    }

References M_PI, m_rib_offset, m_wipe_tower_pos, and m_wipe_tower_rotation.

Referenced by append_tcr2(), and travel_to_tower_gap().

Here is the caller graph for this function:

◆ travel_to_tower_gap()

std::string Slic3r::WipeTowerIntegration::travel_to_tower_gap	(	GCode &	gcodegen,
		const Point &	route_start,
		const Point &	start_wipe_pos ) const

private

    {
        if (!WipeTower2::use_gap_wall(gcodegen.m_config))
            return {};
        const Vec2f plate_origin_2d(m_plate_origin(0), m_plate_origin(1));
        // Transform tower-local corners exactly like the tcr points; a rotated tower gets a
        // conservative axis-aligned envelope from the result.
        auto tower_polygon = [&](const BoundingBoxf &bbx) {
            Polygon poly = scaled(bbx).polygon();
            for (Point &p : poly.points)
                p = wipe_tower_point_to_object_point(gcodegen, transform_wt2_pt(unscale(p).cast<float>()) + plate_origin_2d);
            return poly;
        };
        // The avoid envelope covers the first-layer brim (and rib flare), which a travel may
        // cross freely: early-out only when the approach already starts over the tower body
        // itself, so a start between the wall and the brim edge still gets routed in through
        // the wall opening. Test the rotated polygon, not its bounding box — at angles off the
        // axes the box's corner triangles cover most of the brim ring.
        const float body_width = gcodegen.m_config.wipe_tower_wall_type.value == WipeTowerWallType::wtwRib ? m_wipe_tower_depth : m_right;
        if (tower_polygon(BoundingBoxf(Vec2d(0., 0.), Vec2d(body_width, m_wipe_tower_depth))).contains(route_start))
            return {};
 
        const Polygons bed       = shared_printable_area(gcodegen);
        BoundingBox    avoid_bbx = get_extents(tower_polygon(m_wipe_tower_bbx));
        // The inflated corners must stay on the bed for the router to generate a route at all:
        // clamp the box against the bed shrunk by the clearance the router adds, so a tower
        // parked near the bed edge is still routed along the clamped side instead of always
        // travelling straight across the tower.
        BoundingBox clamp_bbx = get_extents(bed);
        clamp_bbx.offset(-(scaled(wipe_tower_routing_clearance) + SCALED_EPSILON));
        avoid_bbx.min = avoid_bbx.min.cwiseMax(clamp_bbx.min);
        avoid_bbx.max = avoid_bbx.max.cwiseMin(clamp_bbx.max);
        if (avoid_bbx.min.x() >= avoid_bbx.max.x() || avoid_bbx.min.y() >= avoid_bbx.max.y())
            return {};
 
        Polyline    travel_polyline = generate_path_to_wipe_tower(route_start, start_wipe_pos, avoid_bbx, bed);
        std::string gcode;
        // The polyline's last point is start_wipe_pos itself — emitted by the caller.
        for (size_t i = 0; i + 1 < travel_polyline.points.size(); ++i)
            gcode += gcodegen.travel_to(travel_polyline.points[i], erMixed, "Travel to a Wipe Tower");
        return gcode;
    }