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

Collaboration diagram for Slic3r::WipeTower2:

Classes
struct	FilamentParameters
struct	WipeTowerInfo

Public Member Functions
WipeTower::ToolChangeResult	construct_tcr (WipeTowerWriter2 &writer, bool priming, size_t old_tool, bool is_finish, bool is_contact=false) const
	WipeTower2 (const PrintConfig &config, const PrintRegionConfig &default_region_config, int plate_idx, Vec3d plate_origin, const std::vector< std::vector< float > > &wiping_matrix, size_t initial_tool)
void	set_extruder (size_t idx, const PrintConfig &config)
void	plan_toolchange (float z_par, float layer_height_par, unsigned int old_tool, unsigned int new_tool, float wipe_volume=0.f)
void	generate (std::vector< std::vector< WipeTower::ToolChangeResult > > &result)
float	get_depth () const
std::vector< std::pair< float, float > >	get_z_and_depth_pairs () const
float	get_brim_width () const
float	get_wipe_tower_height () const
BoundingBoxf	get_bbx () const
Vec2f	get_rib_offset () const
float	get_rib_width () const
float	get_rib_length () const
void	set_layer (float print_z, float layer_height, size_t max_tool_changes, bool, bool is_last_layer)
const Vec2f &	position () const
float	width () const
bool	finished () const
std::vector< WipeTower::ToolChangeResult >	prime (float first_layer_height, const std::vector< unsigned int > &tools, bool last_wipe_inside_wipe_tower)
WipeTower::ToolChangeResult	tool_change (size_t new_tool)
WipeTower::ToolChangeResult	finish_layer ()
bool	layer_finished () const
std::vector< float >	get_used_filament () const
std::vector< std::pair< float, std::vector< float > > >	get_used_filament_until_layer () const
int	get_number_of_toolchanges () const

Static Public Member Functions
static const std::string	never_skip_tag ()
static const std::string	wait_for_temp_tag ()
static std::pair< double, double >	get_wipe_tower_cone_base (double width, double height, double depth, double angle_deg)
static Polygon	cone_base_polygon (double width, double depth, double height, double angle_deg)
static std::vector< std::vector< float > >	extract_wipe_volumes (const ConfigBase &config)
static float	estimate_semm_flush_volume (const ConfigBase &config, size_t filaments_cnt)
static bool	use_gap_wall (const PrintConfig &config)
static bool	wait_for_temp_enabled (const PrintConfig &config)

Private Types
enum	wipe_shape { SHAPE_NORMAL = 1 , SHAPE_REVERSED = -1 }
enum	{ RectangularBed , CircularBed , CustomBed }

Private Member Functions
float	filament_area () const
bool	is_first_layer () const
float	wipe_row_spacing (bool first_layer) const
float	wipe_line_width () const
bool	tool_ramming_enabled (size_t tool) const
bool	boundary_wipe_start_enabled (size_t tool) const
float	wipe_start_offset_after_ram (float ramming_depth, bool first_layer) const
Vec2f	toolchange_entry_pos (float depth_traversed, float ramming_depth, bool first_layer) const
float	extrusion_flow (float layer_height=-1.f) const
void	plan_tower ()
void	save_on_last_wipe ()
int	first_toolchange_to_nonsoluble_nonsupport (const std::vector< WipeTowerInfo::ToolChange > &tool_changes) const
void	toolchange_Unload (WipeTowerWriter2 &writer, const WipeTower::box_coordinates &cleaning_box, const std::string &current_material, const int old_temperature, const int new_temperature)
void	toolchange_Change (WipeTowerWriter2 &writer, const size_t new_tool, const std::string &new_material, const int wait_for_temp, const bool wait_beside_tower)
void	toolchange_Load (WipeTowerWriter2 &writer, const WipeTower::box_coordinates &cleaning_box)
void	toolchange_Wipe (WipeTowerWriter2 &writer, const WipeTower::box_coordinates &cleaning_box, float wipe_volume, bool interface_layer, bool priming=false, bool fill_box=false)
Polygon	generate_support_rib_wall (WipeTowerWriter2 &writer, const WipeTower::box_coordinates &wt_box, double feedrate, bool first_layer, bool rib_wall, bool extrude_perimeter)
Polygon	generate_support_cone_wall (WipeTowerWriter2 &writer, const WipeTower::box_coordinates &wt_box, double feedrate, bool infill_cone, float spacing)
Polygon	generate_rib_polygon (const WipeTower::box_coordinates &wt_box)
void	compute_wall_skip_points ()
WipeTowerInfo::ToolChange	set_toolchange (size_t old_tool, size_t new_tool, float layer_height, float wipe_volume, bool first_layer_plan)

Private Attributes
const float	Width_To_Nozzle_Ratio = 1.25f
const float	WT_EPSILON = 1e-3f
bool	m_semm = true
bool	m_enable_filament_ramming = true
bool	m_is_mk4mmu3 = false
int	m_wipe_tower_filament = 0
Vec2f	m_wipe_tower_pos
float	m_wipe_tower_width
float	m_wipe_tower_depth = 0.f
float	m_wipe_tower_height = 0.f
float	m_wipe_tower_cone_angle = 0.f
float	m_wipe_tower_brim_width = 0.f
float	m_wipe_tower_brim_width_real = 0.f
BoundingBoxf	m_first_layer_bbx
float	m_wipe_tower_rotation_angle = 0.f
float	m_internal_rotation = 0.f
float	m_y_shift = 0.f
float	m_z_pos = 0.f
float	m_layer_height = 0.f
size_t	m_max_color_changes = 0
int	m_old_temperature = -1
float	m_travel_speed = 0.f
float	m_infill_speed = 0.f
float	m_wipe_tower_max_purge_speed = 90.f
float	m_perimeter_speed = 0.f
float	m_first_layer_speed = 0.f
size_t	m_first_layer_idx = size_t(-1)
bool	m_enable_tower_interface_features = false
bool	m_enable_tower_interface_cooldown_during_tower = false
bool	m_wait_for_temp_on_wipe_tower = false
bool	m_prev_layer_had_interface = false
bool	m_current_layer_has_interface = false
int	m_wall_type
bool	m_used_fillet = true
float	m_rib_width = 10
float	m_extra_rib_length = 0
float	m_rib_length = 0
Vec2f	m_rib_offset = Vec2f::Zero()
bool	m_use_gap_wall = false
std::vector< std::vector< Vec2f > >	m_wall_skip_points
bool	m_enable_arc_fitting = false
float	m_cooling_tube_retraction = 0.f
float	m_cooling_tube_length = 0.f
float	m_parking_pos_retraction = 0.f
float	m_extra_loading_move = 0.f
float	m_bridging = 0.f
bool	m_sparse_layers_skipped = false
bool	m_sparse_layers_combined = false
bool	m_set_extruder_trimpot = false
bool	m_adhesion = true
GCodeFlavor	m_gcode_flavor
enum Slic3r::WipeTower2:: { ... }	m_bed_shape
float	m_bed_width
Vec2f	m_bed_bottom_left
Polygon	m_bed_polygon
float	m_perimeter_width = 0.4f * Width_To_Nozzle_Ratio
float	m_extrusion_flow = 0.038f
std::vector< FilamentParameters >	m_filpar
unsigned int	m_num_layer_changes = 0
unsigned int	m_num_tool_changes = 0
wipe_shape	m_current_shape = SHAPE_NORMAL
size_t	m_current_tool = 0
const std::vector< std::vector< float > >	wipe_volumes
float	m_depth_traversed = 0.f
bool	m_current_layer_finished = false
bool	m_left_to_right = true
float	m_extra_flow = 1.f
float	m_extra_spacing_wipe = 1.f
float	m_extra_spacing_ramming = 1.f
std::vector< WipeTowerInfo >	m_plan
std::vector< WipeTowerInfo >::iterator	m_layer_info = m_plan.end()
float	m_current_height = 0.f
std::vector< float >	m_used_filament_length
std::vector< std::pair< float, std::vector< float > > >	m_used_filament_length_until_layer

Detailed Description

Class Documentation

◆ Slic3r::WipeTower2::FilamentParameters

struct Slic3r::WipeTower2::FilamentParameters

Collaboration diagram for Slic3r::WipeTower2::FilamentParameters:

Class Members
float	cooling_final_speed = 0.f
float	cooling_initial_speed = 0.f
int	cooling_moves = 0
float	delay = 0.f
float	filament_area
float	filament_minimal_purge_on_wipe_tower = 0.f
float	filament_stamping_distance = 0.f
float	filament_stamping_loading_speed = 0.f
int	first_layer_temperature = 0
int	interface_print_temperature = 0
bool	is_soluble = false
bool	is_support = false
float	loading_speed = 0.f
float	loading_speed_start = 0.f
string	material = "PLA"
float	max_e_speed = std::numeric_limits<float>::max()
float	max_layer_height = 0.f
bool	multitool_ramming
float	multitool_ramming_time = 0.f
float	nozzle_diameter
float	ramming_line_width_multiplicator = 1.f
vector< float >	ramming_speed
float	ramming_step_multiplicator = 1.f
float	retract_length
float	retract_speed
int	temperature = 0
float	tower_interface_pre_extrusion_dist = 0.f
float	tower_interface_pre_extrusion_length = 0.f
float	tower_interface_purge_length = 0.f
float	tower_ironing_area = 4.f
float	unloading_speed = 0.f
float	unloading_speed_start = 0.f

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

private

Enumerator
RectangularBed
CircularBed
CustomBed

         {
        RectangularBed,
        CircularBed,
        CustomBed
    } m_bed_shape;

◆ wipe_shape

enum Slic3r::WipeTower2::wipe_shape

private

Enumerator
SHAPE_NORMAL
SHAPE_REVERSED

  {
    SHAPE_NORMAL = 1,
    SHAPE_REVERSED = -1
  };

Constructor & Destructor Documentation

◆ WipeTower2()

Slic3r::WipeTower2::WipeTower2	(	const PrintConfig &	config,
		const PrintRegionConfig &	default_region_config,
		int	plate_idx,
		Vec3d	plate_origin,
		const std::vector< std::vector< float > > &	wiping_matrix,
		size_t	initial_tool )

                                                                                                                                                                                                         :
    m_semm(config.single_extruder_multi_material.value),
    m_enable_filament_ramming(config.enable_filament_ramming.value),
    m_wipe_tower_filament(config.wipe_tower_filament.value),
    m_wipe_tower_pos(config.wipe_tower_x.get_at(plate_idx), config.wipe_tower_y.get_at(plate_idx)),
    m_wipe_tower_width(float(config.prime_tower_width)),
    m_wipe_tower_rotation_angle(float(config.wipe_tower_rotation_angle)),
    m_wipe_tower_brim_width(float(config.prime_tower_brim_width)),
    m_wipe_tower_cone_angle(float(config.wipe_tower_cone_angle)),
    m_extra_flow(float(config.wipe_tower_extra_flow/100.)),
    m_extra_spacing_wipe(float(config.wipe_tower_extra_spacing/100. * config.wipe_tower_extra_flow/100.)),
    m_extra_spacing_ramming(float(config.wipe_tower_extra_spacing/100.)),
    m_y_shift(0.f),
    m_z_pos(0.f),
    m_bridging(float(config.wipe_tower_bridging)),
    m_sparse_layers_skipped(wipe_tower_sparse_layers_skipped(config)),
    m_sparse_layers_combined(wipe_tower_sparse_layers_combined(config)),
    m_gcode_flavor(config.gcode_flavor),
    m_travel_speed(config.travel_speed.get_at(get_extruder_index(config, (unsigned int)initial_tool))),
    m_infill_speed(default_region_config.sparse_infill_speed.get_at(get_extruder_index(config, (unsigned int)initial_tool))),
    m_perimeter_speed(default_region_config.inner_wall_speed.get_at(get_extruder_index(config, (unsigned int)initial_tool))),
    m_current_tool(initial_tool),
    wipe_volumes(wiping_matrix), m_wipe_tower_max_purge_speed(float(config.wipe_tower_max_purge_speed)),
    m_enable_arc_fitting(config.enable_arc_fitting.value == ArcFittingMode::Enabled), 
    m_used_fillet(config.wipe_tower_fillet_wall), 
    m_rib_width(config.wipe_tower_rib_width), 
    m_extra_rib_length(config.wipe_tower_extra_rib_length),
    m_wall_type((int)config.wipe_tower_wall_type),
    m_use_gap_wall(use_gap_wall(config)),
    m_enable_tower_interface_features(config.enable_tower_interface_features.value),
    m_enable_tower_interface_cooldown_during_tower(config.enable_tower_interface_cooldown_during_tower.value),
    m_wait_for_temp_on_wipe_tower(wait_for_temp_enabled(config))
{
    // Read absolute value of first layer speed, if given as percentage,
    // it is taken over following default. Speeds from config are not
    // easily accessible here.
    const float default_speed = 60.f;
    m_first_layer_speed = config.initial_layer_speed.get_at(get_extruder_index(config, (unsigned int)initial_tool));
    if (m_first_layer_speed == 0.f) // just to make sure autospeed doesn't break it.
        m_first_layer_speed = default_speed / 2.f;
 
    // Autospeed may be used...
    if (m_infill_speed == 0.f)
        m_infill_speed = 80.f;
    if (m_perimeter_speed == 0.f)
        m_perimeter_speed = 80.f;
 
 
    // If this is a single extruder MM printer, we will use all the SE-specific config values.
    // Otherwise, the defaults will be used to turn off the SE stuff.
    if (m_semm) {
        m_cooling_tube_retraction = float(config.cooling_tube_retraction);
        m_cooling_tube_length     = float(config.cooling_tube_length);
        m_parking_pos_retraction  = float(config.parking_pos_retraction);
        m_extra_loading_move      = float(config.extra_loading_move);
        m_set_extruder_trimpot    = config.high_current_on_filament_swap;
    }
 
    m_is_mk4mmu3 = boost::icontains(config.printer_notes.value, "PRINTER_MODEL_MK4") && boost::icontains(config.printer_notes.value, "MMU");
 
    // Calculate where the priming lines should be - very naive test not detecting parallelograms etc.
    const std::vector<Vec2d>& bed_points = config.printable_area.values;
    BoundingBoxf bb(bed_points);
    m_bed_width = float(bb.size().x());
    m_bed_shape = (bed_points.size() == 4 ? RectangularBed : CircularBed);
 
    if (m_bed_shape == CircularBed) {
        // this may still be a custom bed, check that the points are roughly on a circle
        double r2 = std::pow(m_bed_width/2., 2.);
        double lim2 = std::pow(m_bed_width/10., 2.);
        Vec2d center = bb.center();
        for (const Vec2d& pt : bed_points)
            if (std::abs(std::pow(pt.x()-center.x(), 2.) + std::pow(pt.y()-center.y(), 2.) - r2) > lim2) {
                m_bed_shape = CustomBed;
                break;
            }
    }
 
    m_bed_bottom_left = m_bed_shape == RectangularBed
                  ? Vec2f(bed_points.front().x(), bed_points.front().y())
                  : Vec2f::Zero();
    m_bed_polygon = Polygon::new_scale(bed_points);
}

References Slic3r::BoundingBoxBase< PointType, APointsType >::center(), Slic3r::center(), CircularBed, CustomBed, Slic3r::enable_filament_ramming(), Slic3r::enable_tower_interface_features(), Slic3r::gcode_flavor(), Slic3r::get_extruder_index(), Slic3r::inner_wall_speed(), m_bed_bottom_left, m_bed_polygon, m_bed_shape, m_bed_width, m_bridging, m_cooling_tube_length, m_cooling_tube_retraction, m_current_tool, m_enable_arc_fitting, m_enable_filament_ramming, m_enable_tower_interface_cooldown_during_tower, m_enable_tower_interface_features, m_extra_flow, m_extra_loading_move, m_extra_rib_length, m_extra_spacing_ramming, m_extra_spacing_wipe, m_first_layer_speed, m_gcode_flavor, m_infill_speed, m_is_mk4mmu3, m_parking_pos_retraction, m_perimeter_speed, m_rib_width, m_semm, m_set_extruder_trimpot, m_sparse_layers_combined, m_sparse_layers_skipped, m_travel_speed, m_use_gap_wall, m_used_fillet, m_wait_for_temp_on_wipe_tower, m_wall_type, m_wipe_tower_brim_width, m_wipe_tower_cone_angle, m_wipe_tower_filament, m_wipe_tower_max_purge_speed, m_wipe_tower_pos, m_wipe_tower_rotation_angle, m_wipe_tower_width, m_y_shift, m_z_pos, Slic3r::Polygon::new_scale(), Slic3r::prime_tower_brim_width(), Slic3r::PrintRegionConfig, RectangularBed, Slic3r::single_extruder_multi_material(), Slic3r::BoundingBoxBase< PointType, APointsType >::size(), Slic3r::sparse_infill_speed(), Slic3r::travel_speed(), use_gap_wall(), wait_for_temp_enabled(), Slic3r::wipe_tower_bridging(), Slic3r::wipe_tower_cone_angle(), Slic3r::wipe_tower_extra_rib_length(), Slic3r::wipe_tower_fillet_wall(), Slic3r::wipe_tower_max_purge_speed(), Slic3r::wipe_tower_sparse_layers_combined(), Slic3r::wipe_tower_sparse_layers_skipped(), Slic3r::wipe_tower_y(), and wipe_volumes.

Here is the call graph for this function:

Member Function Documentation

◆ boundary_wipe_start_enabled()

bool Slic3r::WipeTower2::boundary_wipe_start_enabled ( size_t tool ) const

inlineprivate

327{ return tool_ramming_enabled(tool) && !m_semm && m_use_gap_wall; }

Slic3r::WipeTower2::tool_ramming_enabled

bool tool_ramming_enabled(size_t tool) const

Definition WipeTower2.hpp:323

References m_semm, m_use_gap_wall, and tool_ramming_enabled().

Referenced by set_toolchange(), tool_change(), and toolchange_Unload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compute_wall_skip_points()

void Slic3r::WipeTower2::compute_wall_skip_points ( )

private

{
    m_wall_skip_points.assign(m_plan.size(), std::vector<Vec2f>());
    for (size_t layer_id = 0; layer_id < m_plan.size(); ++layer_id) {
        float depth_traversed = 0.f;
        for (const auto& toolchange : m_plan[layer_id].tool_changes) {
            m_wall_skip_points[layer_id].emplace_back(
                toolchange_entry_pos(depth_traversed, toolchange.ramming_depth, layer_id == m_first_layer_idx));
            depth_traversed += toolchange.required_depth;
        }
    }
}

References m_first_layer_idx, m_plan, m_wall_skip_points, and toolchange_entry_pos().

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cone_base_polygon()

Polygon Slic3r::WipeTower2::cone_base_polygon	(	double	width,
		double	depth,
		double	height,
		double	angle_deg )

static

{
    Polygon box({Point::new_scale(Vec2d(0., 0.)), Point::new_scale(Vec2d(width, 0.)),
                 Point::new_scale(Vec2d(width, depth)), Point::new_scale(Vec2d(0., depth))});
    if (angle_deg <= EPSILON || height <= EPSILON || width <= EPSILON || depth <= EPSILON)
        return box;
    const auto [R, x_scale] = get_wipe_tower_cone_base(width, height, depth, angle_deg);
    if (R <= EPSILON)
        return box;
    const Vec2d center(width / 2., depth / 2.);
    Polygon ellipse;
    for (double alpha = 0.; alpha < 2. * M_PI; alpha += M_PI / 20.)
        ellipse.points.push_back(Point::new_scale(center + R * Vec2d(std::cos(alpha) / x_scale, std::sin(alpha))));
    Polygons u = union_({box, ellipse});
    return u.empty() ? box : u.front();
}

References Slic3r::center(), EPSILON, get_wipe_tower_cone_base(), M_PI, Slic3r::Point::new_scale(), Slic3r::MultiPoint::points, Slic3r::union_(), and width().

Referenced by Slic3r::WipeTowerData::construct_mesh(), and Slic3r::estimate_wipe_tower_first_layer_outline().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ construct_tcr()

WipeTower::ToolChangeResult Slic3r::WipeTower2::construct_tcr	(	WipeTowerWriter2 &	writer,
		bool	priming,
		size_t	old_tool,
		bool	is_finish,
		bool	is_contact = false ) const

{
    WipeTower::ToolChangeResult result;
    result.priming      = priming;
    result.initial_tool = int(old_tool);
    result.new_tool     = int(m_current_tool);
    result.print_z      = m_z_pos;
    result.layer_height = m_layer_height;
    result.elapsed_time = writer.elapsed_time();
    result.start_pos    = writer.start_pos_rotated();
    result.end_pos      = priming ? writer.pos() : writer.pos_rotated();
    result.gcode        = std::move(writer.gcode());
    result.extrusions   = std::move(writer.extrusions());
    result.wipe_path    = std::move(writer.wipe_path());
    result.is_finish_first = is_finish;
    result.is_contact = is_contact;
    // ORCA: Always initialize the tool_change_start_pos with a valid position
    // to avoid undefined variable travel on X in Gcode.cpp function std::string WipeTowerIntegration::post_process_wipe_tower_moves
    result.tool_change_start_pos = result.start_pos;  // always valid fallback
 
    return result;
}

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ estimate_semm_flush_volume()

float Slic3r::WipeTower2::estimate_semm_flush_volume	(	const ConfigBase &	config,
		size_t	filaments_cnt )

static

{
    const std::vector<std::vector<float>> wipe_volumes = extract_wipe_volumes(config);
    if (wipe_volumes.empty()) // an empty flush matrix would make the average below 0/0
        return 0.f;
    float maximum = 0.f;
    for (const std::vector<float> &v : wipe_volumes)
        maximum += *std::max_element(v.begin(), v.end());
    maximum = maximum * filaments_cnt / wipe_volumes.size();
 
    // Orca: it's overshooting a bit, so let's reduce it a bit
    maximum *= 0.6;
    return maximum;
}

References extract_wipe_volumes(), and wipe_volumes.

Referenced by Slic3r::estimate_wipe_tower_footprint().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extract_wipe_volumes()

std::vector< std::vector< float > > Slic3r::WipeTower2::extract_wipe_volumes ( const ConfigBase & config )

static

{
    // flush_volumes_matrix holds one filaments x filaments block per nozzle (written by
    // PresetBundle::update_multi_material_filament_presets), so the filament count is
    // sqrt(size / nozzles). One tower serves every nozzle and the filament to nozzle assignment is
    // only decided later by ToolOrdering, so fold the blocks with std::max: the depth reserved here
    // has to cover the worst nozzle. With a single nozzle the fold has one term.
    const std::vector<double> &raw_matrix      = config.option<ConfigOptionFloats>("flush_volumes_matrix")->values;
    const auto                *nozzle_diameter = config.option<ConfigOptionFloats>("nozzle_diameter");
    size_t       nozzle_nums         = (nozzle_diameter == nullptr || nozzle_diameter->values.empty()) ? 1 : nozzle_diameter->values.size();
    unsigned int number_of_extruders = (unsigned int)(sqrt(raw_matrix.size() / nozzle_nums) + EPSILON);
    if (size_t(number_of_extruders) * number_of_extruders * nozzle_nums != raw_matrix.size()) {
        // Saved for a different nozzle count (older project, or the printer was just switched):
        // fall back to reading the whole option as one block, as this did before.
        nozzle_nums         = 1;
        number_of_extruders = (unsigned int)(sqrt(raw_matrix.size()) + EPSILON);
    }
 
    // The values shall only be used when SEMM is enabled. The purging for other printers
    // is determined by filament_minimal_purge_on_wipe_tower.
    const bool purge = config.option<ConfigOptionBool>("purge_in_prime_tower")->value
                    && config.option<ConfigOptionBool>("single_extruder_multi_material")->value;
 
    // Extract purging volumes for each extruder pair, each nozzle's block scaled by its own multiplier:
    std::vector<std::vector<float>> wipe_volumes(number_of_extruders, std::vector<float>(number_of_extruders, 0.f));
    if (purge) {
        const auto *multiplier = config.option<ConfigOptionFloats>("flush_multiplier");
        for (size_t nozzle_id = 0; nozzle_id < nozzle_nums; ++nozzle_id) {
            const std::vector<double> block = get_flush_volumes_matrix(raw_matrix, nozzle_id, nozzle_nums);
            const double              scale = multiplier->get_at(nozzle_id);
            for (unsigned int i = 0; i<number_of_extruders; ++i)
                for (unsigned int j = 0; j<number_of_extruders; ++j)
                    wipe_volumes[i][j] = std::max<float>(wipe_volumes[i][j], float(block[size_t(i) * number_of_extruders + j]) * scale);
        }
    }
 
    // Also include filament_minimal_purge_on_wipe_tower. This is needed for the preview.
    const auto *minimal_purge = config.option<ConfigOptionFloats>("filament_minimal_purge_on_wipe_tower");
    for (unsigned int i = 0; i<number_of_extruders; ++i)
        for (unsigned int j = 0; j<number_of_extruders; ++j)
            wipe_volumes[i][j] = std::max<float>(wipe_volumes[i][j], minimal_purge->get_at(j));
 
    return wipe_volumes;
}

References EPSILON, Slic3r::get_flush_volumes_matrix(), Slic3r::nozzle_diameter(), Slic3r::ConfigBase::option(), scale(), Slic3r::ConfigOptionSingle< T >::value, and wipe_volumes.

Referenced by estimate_semm_flush_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extrusion_flow()

float Slic3r::WipeTower2::extrusion_flow ( float layer_height = -1.f ) const

inlineprivate

  {
    if ( layer_height < 0 )
      return m_extrusion_flow;
    return layer_height * ( m_perimeter_width - layer_height * (1.f-float(M_PI)/4.f)) / filament_area();
  }

References filament_area(), Slic3r::layer_height(), m_extrusion_flow, m_perimeter_width, and M_PI.

Referenced by set_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ filament_area()

float Slic3r::WipeTower2::filament_area ( ) const

inlineprivate

                                {
        return m_filpar[0].filament_area; // all extruders are assumed to have the same filament diameter at this point
    }

References m_filpar.

Referenced by extrusion_flow(), set_extruder(), and toolchange_Unload().

Here is the caller graph for this function:

◆ finish_layer()

WipeTower::ToolChangeResult Slic3r::WipeTower2::finish_layer ( )

{
  assert(! this->layer_finished());
    m_current_layer_finished = true;
 
    size_t old_tool = m_current_tool;
 
  WipeTowerWriter2 writer(m_layer_height, m_perimeter_width, m_gcode_flavor, m_filpar, m_enable_arc_fitting);
  writer.set_extrusion_flow(m_extrusion_flow)
    .set_z(m_z_pos)
    .set_initial_tool(m_current_tool)
        .set_y_shift(m_y_shift - (m_current_shape == SHAPE_REVERSED ? m_layer_info->toolchanges_depth() : 0.f));
 
 
    // Slow down on the 1st layer.
    // If spare layers are excluded -> if 1 or less toolchange has been done, it must be still the first layer, too. So slow down.
    bool first_layer = is_first_layer() || (m_num_tool_changes <= 1 && m_sparse_layers_skipped);
    float                      feedrate      = first_layer ? m_first_layer_speed * 60.f : std::min(m_wipe_tower_max_purge_speed * 60.f, m_infill_speed * 60.f);
    if (m_enable_tower_interface_features && m_prev_layer_had_interface)
        feedrate = std::min(feedrate, 20.f * 60.f);
    float current_depth = m_layer_info->depth - m_layer_info->toolchanges_depth();
    WipeTower::box_coordinates fill_box(Vec2f(m_perimeter_width, m_layer_info->depth-(current_depth-m_perimeter_width)),
                             m_wipe_tower_width - 2 * m_perimeter_width, current_depth-m_perimeter_width);
 
 
    writer.set_initial_position((m_left_to_right ? fill_box.ru : fill_box.lu), // so there is never a diagonal travel
                                 m_wipe_tower_width, m_wipe_tower_depth, m_internal_rotation);
 
    bool toolchanges_on_layer = m_layer_info->toolchanges_depth() > WT_EPSILON;
 
    // inner perimeter of the sparse section, if there is space for it:
    if (fill_box.ru.y() - fill_box.rd.y() > m_perimeter_width - WT_EPSILON)
        writer.rectangle(fill_box.ld, fill_box.rd.x()-fill_box.ld.x(), fill_box.ru.y()-fill_box.rd.y(), feedrate);
 
    // we are in one of the corners, travel to ld along the perimeter:
    if (writer.x() > fill_box.ld.x()+EPSILON) writer.travel(fill_box.ld.x(),writer.y());
    if (writer.y() > fill_box.ld.y()+EPSILON) writer.travel(writer.x(),fill_box.ld.y());
 
    // Extrude infill to support the material to be printed above.
    const float dy = (fill_box.lu.y() - fill_box.ld.y() - m_perimeter_width);
    float left = fill_box.lu.x() + 2*m_perimeter_width;
    float right = fill_box.ru.x() - 2 * m_perimeter_width;
    if (dy > m_perimeter_width)
    {
        writer.travel(fill_box.ld + Vec2f(m_perimeter_width * 2, 0.f))
            .append(";--------------------\n"
                    "; CP EMPTY GRID START\n")
            .comment_with_value(" layer #", m_num_layer_changes + 1);
 
        // Is there a soluble filament wiped/rammed at the next layer?
        // If so, the infill should not be sparse.
        bool solid_infill = m_layer_info+1 == m_plan.end()
                          ? false
                          : std::any_of((m_layer_info+1)->tool_changes.begin(),
                                        (m_layer_info+1)->tool_changes.end(),
                                            [this](const WipeTowerInfo::ToolChange& tch) {
                                       return m_filpar[tch.new_tool].is_soluble
                                           || m_filpar[tch.old_tool].is_soluble;
                                            });
        solid_infill |= first_layer && m_adhesion;
 
        if (solid_infill) {
            float sparse_factor = 1.5f; // 1=solid, 2=every other line, etc.
            if (first_layer) { // the infill should touch perimeters
                left  -= m_perimeter_width;
                right += m_perimeter_width;
                sparse_factor = 1.f;
            }
            float y = fill_box.ld.y() + m_perimeter_width;
            int n = dy / (m_perimeter_width * sparse_factor);
            float spacing = (dy-m_perimeter_width)/(n-1);
            int i=0;
            for (i=0; i<n; ++i) {
                writer.extrude(writer.x(), y, feedrate)
                      .extrude(i%2 ? left : right, y);
                y = y + spacing;
            }
            writer.extrude(writer.x(), fill_box.lu.y());
        } else {
            // Extrude an inverse U at the left of the region and the sparse infill.
            writer.extrude(fill_box.lu + Vec2f(m_perimeter_width * 2, 0.f), feedrate);
 
            const int n = 1+int((right-left)/m_bridging);
            const float dx = (right-left)/n;
            for (int i=1;i<=n;++i) {
                float x=left+dx*i;
                writer.travel(x,writer.y());
                writer.extrude(x,i%2 ? fill_box.rd.y() : fill_box.ru.y());
            }
        }
 
        writer.append("; CP EMPTY GRID END\n"
                      ";------------------\n\n\n\n\n\n\n");
    }
 
    const float spacing = m_perimeter_width - m_layer_height*float(1.-M_PI_4);
    feedrate = first_layer ? m_first_layer_speed * 60.f : std::min(m_wipe_tower_max_purge_speed * 60.f, m_perimeter_speed * 60.f);
 
    Polygon poly;
    if (m_wall_type == (int)wtwCone) {
         WipeTower::box_coordinates wt_box(Vec2f(0.f, (m_current_shape == SHAPE_REVERSED ? m_layer_info->toolchanges_depth() : 0.f)),
                                           m_wipe_tower_width, m_layer_info->depth + m_perimeter_width);
        // outer contour (always)
        bool infill_cone = first_layer && m_wipe_tower_width > 2 * spacing && m_wipe_tower_depth > 2 * spacing;
        poly = generate_support_cone_wall(writer, wt_box, feedrate, infill_cone, spacing);
    } else {
        WipeTower::box_coordinates wt_box(Vec2f(0.f, 0.f), m_wipe_tower_width, m_layer_info->depth + m_perimeter_width);
        poly = generate_support_rib_wall(writer, wt_box, feedrate, first_layer, m_wall_type == (int)wtwRib, true);
    }
 
    // brim (first layer only)
    if (first_layer) {
        writer.append("; WIPE_TOWER_BRIM_START\n");
            float brim_width = m_wipe_tower_brim_width;
        if (brim_width < 0.f)
            brim_width = WipeTower::get_auto_brim_by_height(m_wipe_tower_height);
 
        size_t loops_num = (brim_width + spacing / 2.f) / spacing;
        
        for (size_t i = 0; i < loops_num; ++ i) {
            poly = offset(poly, scale_(spacing)).front();
            int cp = poly.closest_point_index(Point::new_scale(writer.x(), writer.y()));
            writer.travel(unscale(poly.points[cp]).cast<float>());
            for (int i=cp+1; true; ++i ) {
                if (i==int(poly.points.size()))
                    i = 0;
                writer.extrude(unscale(poly.points[i]).cast<float>());
                if (i == cp)
                    break;
            }
        }
        writer.append("; WIPE_TOWER_BRIM_END\n");
        // Save actual brim width to be later passed to the Print object, which will use it
        // for skirt calculation and pass it to GLCanvas for precise preview box
        m_wipe_tower_brim_width_real = loops_num * spacing;
 
        // Compute actual first-layer bounding box from the outermost brim polygon,
        // matching how WipeTower::get_bbx() uses m_outer_wall extents.
        BoundingBox first_layer_box = get_extents(poly);
        m_first_layer_bbx = BoundingBoxf(unscale(first_layer_box.min), unscale(first_layer_box.max));
    }
 
    // Now prepare future wipe.
    int i = poly.closest_point_index(Point::new_scale(writer.x(), writer.y()));
    writer.add_wipe_point(writer.pos());
    writer.add_wipe_point(unscale(poly.points[i==0 ? int(poly.points.size())-1 : i-1]).cast<float>());
 
    // Ask our writer about how much material was consumed.
    // Skip this in case the layer is sparse and config option to not print sparse layers is enabled.
    // A folded layer prints nothing, so it consumes nothing and adds no height of its own.
    const bool combined_away = m_layer_info != m_plan.end() && m_layer_info->combined_away;
    if ((! m_sparse_layers_skipped || toolchanges_on_layer || first_layer) && ! combined_away) {
        if (m_current_tool < m_used_filament_length.size())
            m_used_filament_length[m_current_tool] += writer.get_and_reset_used_filament_length();
        m_current_height += m_layer_info->height;
    }
 
    return construct_tcr(writer, false, old_tool, true, false);
}

Referenced by generate(), and save_on_last_wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finished()

bool Slic3r::WipeTower2::finished ( ) const

inline

146{ return m_max_color_changes == 0; }

Slic3r::WipeTower2::m_max_color_changes

size_t m_max_color_changes

Definition WipeTower2.hpp:244

References m_max_color_changes.

◆ first_toolchange_to_nonsoluble_nonsupport()

int Slic3r::WipeTower2::first_toolchange_to_nonsoluble_nonsupport ( const std::vector< WipeTowerInfo::ToolChange > & tool_changes ) const

private

{
    if (tool_changes.empty())
        return -1;
 
    // If a specific wipe tower filament is forced, use it to decide where to finish the layer.
    if (m_wipe_tower_filament > 0) {
        for (size_t idx = 0; idx < tool_changes.size(); ++idx) {
            if (!m_filpar[tool_changes[idx].new_tool].is_soluble)
                return idx;
        }
        return -1;
    }
 
    auto is_wall_filament = [this](size_t tool) {
        return !m_filpar[tool].is_soluble && !m_filpar[tool].is_support;
    };
    for (size_t idx = 0; idx < tool_changes.size(); ++idx)
        if (is_wall_filament(tool_changes[idx].new_tool))
            return idx;
    if (is_wall_filament(tool_changes.front().old_tool))
        return -1;
    // Only support/soluble filaments on this layer: keep the first toolchange so the
    // finish-layer saving and the minimal-purge clamp still apply to it (Orca depth
    // and wipe volume accounting, see save_on_last_wipe()).
    return 0;
}

References m_filpar, and m_wipe_tower_filament.

Referenced by generate(), and save_on_last_wipe().

Here is the caller graph for this function:

◆ generate()

void Slic3r::WipeTower2::generate ( std::vector< std::vector< WipeTower::ToolChangeResult > > & result )

{
  if (m_plan.empty())
        return;
 
    // Before planning: the layer heights this rewrites feed the extrusion flow of every later pass.
    if (m_sparse_layers_combined)
        combine_sparse_wipe_tower_plan(m_plan, m_filpar, m_first_layer_idx, m_current_tool);
 
  plan_tower();
#if 1
    for (int i=0;i<5;++i) {
        save_on_last_wipe();
        plan_tower();
    }
#endif
 
    if (m_wall_type == (int)wtwRib) {
        // Rib wall: force a square tower like WipeTower::plan_tower_new(), ignoring the
        // configured prime_tower_width (the GUI greys it out in rib mode). The planned depths
        // already include the extra-spacing factors, so sqrt(depth * width) preserves the
        // purge area. Replan every toolchange for the new width, then re-derive the depths.
        float max_depth = 0.f;
        for (const auto& current_plan : m_plan)
            max_depth = std::max(max_depth, current_plan.depth);
        if (max_depth > EPSILON) {
            m_wipe_tower_width = align_ceil(std::sqrt(max_depth * m_wipe_tower_width), m_perimeter_width);
            for (size_t idx = 0; idx < m_plan.size(); ++idx)
                for (auto& toolchange : m_plan[idx].tool_changes)
                    toolchange = set_toolchange(toolchange.old_tool, toolchange.new_tool,
                                                m_plan[idx].height, toolchange.wipe_volume,
                                                idx == m_first_layer_idx);
            plan_tower();
        }
 
        // Like WipeTower::plan_tower_new(): extend the ribs instead of the tower when the
        // tower is smaller than the height-based stability minimum.
        const float min_depth = WipeTower::get_limit_depth_by_height(m_wipe_tower_height);
        if (m_wipe_tower_depth + EPSILON < min_depth)
            m_rib_length = std::max(m_rib_length, min_depth * (float)std::sqrt(2.f));
    }
 
    const float diagonal = std::sqrt(m_wipe_tower_depth * m_wipe_tower_depth + m_wipe_tower_width * m_wipe_tower_width);
    m_rib_length = std::max(m_rib_length, diagonal);
    m_rib_length += m_extra_rib_length;
    m_rib_length = std::max(diagonal, m_rib_length); // a negative extra length must not shrink the ribs below the diagonal
    m_rib_width  = std::min(m_rib_width, std::min(m_wipe_tower_depth, m_wipe_tower_width) /
                                             2.f); // Ensure that the rib wall of the wipetower are attached to the infill.
 
    if (m_use_gap_wall)
        compute_wall_skip_points();
 
    m_layer_info = m_plan.begin();
    m_current_height = 0.f;
 
    // we don't know which extruder to start with - we'll set it according to the first toolchange
    for (const auto& layer : m_plan) {
        if (!layer.tool_changes.empty()) {
            m_current_tool = layer.tool_changes.front().old_tool;
            break;
        }
    }
 
    m_used_filament_length.assign(m_used_filament_length.size(), 0.f); // reset used filament stats
    assert(m_used_filament_length_until_layer.empty());
    m_used_filament_length_until_layer.emplace_back(0.f, m_used_filament_length);
 
    m_old_temperature = -1; // reset last temperature written in the gcode
 
  for (const WipeTower2::WipeTowerInfo& layer : m_plan)
  {
        std::vector<WipeTower::ToolChangeResult> layer_result;
        set_layer(layer.z, layer.height, 0, false/*layer.z == m_plan.front().z*/, layer.z == m_plan.back().z);
        m_internal_rotation += 180.f;
 
        if (m_layer_info->depth < m_wipe_tower_depth - m_perimeter_width)
      m_y_shift = (m_wipe_tower_depth-m_layer_info->depth-m_perimeter_width)/2.f;
 
        int idx = first_toolchange_to_nonsoluble_nonsupport(layer.tool_changes);
        WipeTower::ToolChangeResult finish_layer_tcr;
 
        if (idx == -1) {
            // if there is no toolchange switching to non-soluble, finish layer
            // will be called at the very beginning. That's the last possibility
            // where a nonsoluble tool can be.
            finish_layer_tcr = finish_layer();
        }
 
        for (int i=0; i<int(layer.tool_changes.size()); ++i) {
            layer_result.emplace_back(tool_change(layer.tool_changes[i].new_tool));
            if (i == idx) // finish_layer will be called after this toolchange
                finish_layer_tcr = finish_layer();
        }
 
        if (layer_result.empty()) {
            // there is nothing to merge finish_layer with
            layer_result.emplace_back(std::move(finish_layer_tcr));
        }
        else {
            if (idx == -1) {
                layer_result[0] = merge_tcr(finish_layer_tcr, layer_result[0]);
                layer_result[0].force_travel = true;
            }
            else
                layer_result[idx] = merge_tcr(layer_result[idx], finish_layer_tcr);
        }
 
        if (layer.combined_away)
            for (WipeTower::ToolChangeResult &tcr : layer_result)
                tcr.combined_away = true;
 
    result.emplace_back(std::move(layer_result));
 
        if (m_used_filament_length_until_layer.empty() || m_used_filament_length_until_layer.back().first != layer.z)
            m_used_filament_length_until_layer.emplace_back();
        m_used_filament_length_until_layer.back() = std::make_pair(layer.z, m_used_filament_length);
  }
}

References Slic3r::align_ceil(), Slic3r::combine_sparse_wipe_tower_plan(), Slic3r::WipeTower::ToolChangeResult::combined_away, compute_wall_skip_points(), EPSILON, finish_layer(), first_toolchange_to_nonsoluble_nonsupport(), Slic3r::WipeTower::get_limit_depth_by_height(), m_current_height, m_current_tool, m_extra_rib_length, m_filpar, m_first_layer_idx, m_internal_rotation, m_layer_info, m_old_temperature, m_perimeter_width, m_plan, m_rib_length, m_rib_width, m_sparse_layers_combined, m_use_gap_wall, m_used_filament_length, m_used_filament_length_until_layer, m_wall_type, m_wipe_tower_depth, m_wipe_tower_height, m_wipe_tower_width, m_y_shift, Slic3r::merge_tcr(), plan_tower(), save_on_last_wipe(), set_layer(), set_toolchange(), tool_change(), and Slic3r::wtwRib.

Referenced by Slic3r::Print::_make_wipe_tower().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_rib_polygon()

Polygon Slic3r::WipeTower2::generate_rib_polygon ( const WipeTower::box_coordinates & wt_box )

private

{
 
    auto get_current_layer_rib_len = [](float cur_height, float max_height, float max_len) -> float {
        return std::abs(max_height - cur_height) / max_height * max_len;
    };
    coord_t diagonal_width = scaled(m_rib_width) / 2;
    float   a = this->m_wipe_tower_width, b = this->m_wipe_tower_depth;
    Line    line_1(Point::new_scale(Vec2f{0, 0}), Point::new_scale(Vec2f{a, b}));
    Line    line_2(Point::new_scale(Vec2f{a, 0}), Point::new_scale(Vec2f{0, b}));
    float   diagonal_extra_length = std::max(0.f, m_rib_length - (float) unscaled(line_1.length())) / 2.f;
    diagonal_extra_length         = scaled(get_current_layer_rib_len(this->m_z_pos, this->m_wipe_tower_height, diagonal_extra_length));
    Point y_shift{0, scaled(this->m_y_shift)};
 
    line_1.extend(double(diagonal_extra_length));
    line_2.extend(double(diagonal_extra_length));
    line_1.translate(-y_shift);
    line_2.translate(-y_shift);
 
    Polygon poly_1 = generate_rectange(line_1, diagonal_width);
    Polygon poly_2 = generate_rectange(line_2, diagonal_width);
    Polygon poly;
    poly.points.push_back(Point::new_scale(wt_box.ld));
    poly.points.push_back(Point::new_scale(wt_box.rd));
    poly.points.push_back(Point::new_scale(wt_box.ru));
    poly.points.push_back(Point::new_scale(wt_box.lu));
 
    Polygons p_1_2 = union_({poly_1, poly_2, poly});
    // Polygon            res_poly = p_1_2.front();
    // for (auto &p : res_poly.points) res.push_back(unscale(p).cast<float>());
    /*if (p_1_2.front().points.size() != 16)
        std::cout << "error " << std::endl;*/
    return p_1_2.front();
};

References Slic3r::Line::extend(), Slic3r::generate_rectange(), Slic3r::WipeTower::box_coordinates::ld, Slic3r::Line::length(), Slic3r::WipeTower::box_coordinates::lu, m_rib_length, m_rib_width, m_wipe_tower_depth, m_wipe_tower_height, m_wipe_tower_width, m_y_shift, m_z_pos, Slic3r::Point::new_scale(), Slic3r::WipeTower::box_coordinates::rd, Slic3r::WipeTower::box_coordinates::ru, Slic3r::scaled(), Slic3r::Line::translate(), Slic3r::union_(), and Slic3r::unscaled().

Referenced by generate_support_rib_wall(), and toolchange_Change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_support_cone_wall()

Polygon Slic3r::WipeTower2::generate_support_cone_wall	(	WipeTowerWriter2 &	writer,
		const WipeTower::box_coordinates &	wt_box,
		double	feedrate,
		bool	infill_cone,
		float	spacing )

private

                                                                                                                       {
 
    const auto [R, support_scale] = get_wipe_tower_cone_base(m_wipe_tower_width, m_wipe_tower_height, m_wipe_tower_depth,
                                                             m_wipe_tower_cone_angle);
 
    double z = m_sparse_layers_skipped ?
                   (m_current_height + m_layer_info->height) :
                   m_layer_info->z; // the former should actually work in both cases, but let's stay on the safe side (the 2.6.0 is close)
 
    double r      = std::tan(Geometry::deg2rad(m_wipe_tower_cone_angle / 2.f)) * (m_wipe_tower_height - z);
    Vec2f  center = (wt_box.lu + wt_box.rd) / 2.;
    double w      = wt_box.lu.y() - wt_box.ld.y();
    enum Type { Arc, Corner, ArcStart, ArcEnd };
 
    // First generate vector of annotated point which form the boundary.
    std::vector<std::pair<Vec2f, Type>> pts = {{wt_box.ru, Corner}};
    if (double alpha_start = std::asin((0.5 * w) / r); !std::isnan(alpha_start) && r > 0.5 * w + 0.01) {
        for (double alpha = alpha_start; alpha < M_PI - alpha_start + 0.001; alpha += (M_PI - 2 * alpha_start) / 40.)
            pts.emplace_back(Vec2f(center.x() + r * std::cos(alpha) / support_scale, center.y() + r * std::sin(alpha)),
                             alpha == alpha_start ? ArcStart : Arc);
        pts.back().second = ArcEnd;
    }
    pts.emplace_back(wt_box.lu, Corner);
    pts.emplace_back(wt_box.ld, Corner);
    for (int i = int(pts.size()) - 3; i > 0; --i)
        pts.emplace_back(Vec2f(pts[i].first.x(), 2 * center.y() - pts[i].first.y()), i == int(pts.size()) - 3 ? ArcStart :
                                                                                     i == 1                   ? ArcEnd :
                                                                                                                Arc);
    pts.emplace_back(wt_box.rd, Corner);
 
    // Create a Polygon from the points.
    Polygon poly;
    for (const auto& [pt, tag] : pts)
        poly.points.push_back(Point::new_scale(pt));
 
    // Prepare polygons to be filled by infill.
    Polylines polylines;
    if (infill_cone && m_wipe_tower_width > 2 * spacing && m_wipe_tower_depth > 2 * spacing) {
        ExPolygons infill_areas;
        ExPolygon  wt_contour(poly);
        Polygon    wt_rectangle(
            Points{Point::new_scale(wt_box.ld), Point::new_scale(wt_box.rd), Point::new_scale(wt_box.ru), Point::new_scale(wt_box.lu)});
        wt_rectangle = offset(wt_rectangle, scale_(-spacing / 2.)).front();
        wt_contour   = offset_ex(wt_contour, scale_(-spacing / 2.)).front();
        infill_areas = diff_ex(wt_contour, wt_rectangle);
        if (infill_areas.size() == 2) {
            ExPolygon& bottom_expoly = infill_areas.front().contour.points.front().y() < infill_areas.back().contour.points.front().y() ?
                                           infill_areas[0] :
                                           infill_areas[1];
            std::unique_ptr<Fill> filler(Fill::new_from_type(ipMonotonicLine));
            filler->angle   = Geometry::deg2rad(45.f);
            filler->spacing = spacing;
            FillParams params;
            params.density = 1.f;
            Surface surface(stBottom, bottom_expoly);
            filler->bounding_box = get_extents(bottom_expoly);
            polylines            = filler->fill_surface(&surface, params);
            if (!polylines.empty()) {
                if (polylines.front().points.front().x() > polylines.back().points.back().x()) {
                    std::reverse(polylines.begin(), polylines.end());
                    for (Polyline& p : polylines)
                        p.reverse();
                }
            }
        }
    }
 
    // Find the closest corner and travel to it.
    int    start_i  = 0;
    double min_dist = std::numeric_limits<double>::max();
    for (int i = 0; i < int(pts.size()); ++i) {
        if (pts[i].second == Corner) {
            double dist = (pts[i].first - Vec2f(writer.x(), writer.y())).squaredNorm();
            if (dist < min_dist) {
                min_dist = dist;
                start_i  = i;
            }
        }
    }
    writer.travel(pts[start_i].first);
 
    // Now actually extrude the boundary (and possibly infill):
    int i = start_i + 1 == int(pts.size()) ? 0 : start_i + 1;
    while (i != start_i) {
        writer.extrude(pts[i].first, feedrate);
        if (pts[i].second == ArcEnd) {
            // Extrude the infill.
            if (!polylines.empty()) {
                // Extrude the infill and travel back to where we were.
                bool mirror = ((pts[i].first.y() - center.y()) * (unscale(polylines.front().points.front()).y() - center.y())) < 0.;
                for (const Polyline& line : polylines) {
                    writer.travel(center - (mirror ? 1.f : -1.f) * (unscale(line.points.front()).cast<float>() - center));
                    for (size_t i = 0; i < line.points.size(); ++i)
                        writer.extrude(center - (mirror ? 1.f : -1.f) * (unscale(line.points[i]).cast<float>() - center));
                }
                writer.travel(pts[i].first);
            }
        }
        if (++i == int(pts.size()))
            i = 0;
    }
    writer.extrude(pts[start_i].first, feedrate);
    return poly;
}

References Slic3r::center(), Slic3r::Geometry::deg2rad(), Slic3r::FillParams::density, Slic3r::diff_ex(), Slic3r::Geometry::dist(), Slic3r::WipeTowerWriter2::extrude(), Slic3r::get_extents(), get_wipe_tower_cone_base(), Slic3r::ipMonotonicLine, Slic3r::WipeTower::box_coordinates::ld, Slic3r::WipeTower::box_coordinates::lu, m_current_height, m_layer_info, M_PI, m_sparse_layers_skipped, m_wipe_tower_cone_angle, m_wipe_tower_depth, m_wipe_tower_height, m_wipe_tower_width, Slic3r::Fill::new_from_type(), Slic3r::Point::new_scale(), Slic3r::offset(), Slic3r::offset_ex(), Slic3r::WipeTower::box_coordinates::rd, Slic3r::WipeTower::box_coordinates::ru, scale_, Slic3r::stBottom, Slic3r::WipeTowerWriter2::travel(), Slic3r::unscale(), Slic3r::WipeTowerWriter2::x(), and Slic3r::WipeTowerWriter2::y().

Referenced by finish_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_support_rib_wall()

Polygon Slic3r::WipeTower2::generate_support_rib_wall	(	WipeTowerWriter2 &	writer,
		const WipeTower::box_coordinates &	wt_box,
		double	feedrate,
		bool	first_layer,
		bool	rib_wall,
		bool	extrude_perimeter )

private

{
 
    float     retract_length = m_filpar[m_current_tool].retract_length;
    float     retract_speed  = m_filpar[m_current_tool].retract_speed * 60;
    Polygon   wall_polygon   = rib_wall ? generate_rib_polygon(wt_box) : generate_rectange_polygon(wt_box.ld, wt_box.ru);
    Polylines result_wall;
    Polygon   insert_skip_polygon;
    if (m_used_fillet) {
        if (!rib_wall && m_y_shift > EPSILON) // do nothing because the fillet will cause it to be suspended.
        {
        } else {
            wall_polygon           = rib_wall ? rounding_polygon(wall_polygon) : wall_polygon; // rectangle_wall do nothing
            Polygon wt_box_polygon = generate_rectange_polygon(wt_box.ld, wt_box.ru);
            wall_polygon           = union_({wall_polygon, wt_box_polygon}).front();
        }
    }
    if (!extrude_perimeter)
        return wall_polygon;
 
    if (m_use_gap_wall) {
        // Cut the wall open at each toolchange's entry (see compute_wall_skip_points()).
        // The vector is empty during the save_on_last_wipe planning passes, which therefore
        // measure the un-gapped wall — same approximation as the BBL tower.
        static const std::vector<Vec2f> no_skip_points;
        const size_t layer_id = size_t(m_layer_info - m_plan.begin());
        const std::vector<Vec2f>& layer_skip_points =
            layer_id < m_wall_skip_points.size() ? m_wall_skip_points[layer_id] : no_skip_points;
        result_wall = construct_gap_for_skip_points(wall_polygon, layer_skip_points, m_wipe_tower_width, 2.5 * m_perimeter_width,
                                                   insert_skip_polygon);
    } else {
        result_wall.push_back(to_polyline(wall_polygon));
        insert_skip_polygon = wall_polygon;
    }
    writer.generate_path(result_wall, feedrate, retract_length, retract_speed, m_used_fillet);
    // Tower-local shift that puts the rib wall's protruding first-layer min corner at the
    // configured tower position, like WipeTower::generate_support_wall_new(). Measured on
    // the un-gapped outline so a wall gap cannot shift the tower.
    if (rib_wall && is_first_layer()) {
        BoundingBox bbox = get_extents(insert_skip_polygon);
        m_rib_offset     = Vec2f(-unscaled<float>(bbox.min.x()), -unscaled<float>(bbox.min.y()));
    }
 
    return insert_skip_polygon;
}

References Slic3r::construct_gap_for_skip_points(), EPSILON, Slic3r::WipeTowerWriter2::generate_path(), Slic3r::generate_rectange_polygon(), generate_rib_polygon(), Slic3r::get_extents(), is_first_layer(), Slic3r::WipeTower::box_coordinates::ld, m_current_tool, m_filpar, m_layer_info, m_perimeter_width, m_plan, m_rib_offset, m_use_gap_wall, m_used_fillet, m_wall_skip_points, m_wipe_tower_width, m_y_shift, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::rounding_polygon(), Slic3r::WipeTower::box_coordinates::ru, Slic3r::to_polyline(), Slic3r::union_(), and Slic3r::unscaled().

Referenced by finish_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_bbx()

BoundingBoxf Slic3r::WipeTower2::get_bbx ( ) const

inline

                                 {
        if (m_first_layer_bbx.defined)
            return m_first_layer_bbx;
        // Fallback: nominal rectangle (used if generate() hasn't run yet)
        const float brim = m_wipe_tower_brim_width_real;
        return BoundingBoxf(Vec2d(-brim, -brim), Vec2d(double(m_wipe_tower_width) + brim, double(m_wipe_tower_depth) + brim));
    }

References m_first_layer_bbx, m_wipe_tower_brim_width_real, m_wipe_tower_depth, and m_wipe_tower_width.

Referenced by Slic3r::Print::_make_wipe_tower().

Here is the caller graph for this function:

◆ get_brim_width()

float Slic3r::WipeTower2::get_brim_width ( ) const

inline

86{ return m_wipe_tower_brim_width_real; }

References m_wipe_tower_brim_width_real.

Referenced by Slic3r::Print::_make_wipe_tower().

Here is the caller graph for this function:

◆ get_depth()

float Slic3r::WipeTower2::get_depth ( ) const

inline

84{ return m_wipe_tower_depth; }

References m_wipe_tower_depth.

Referenced by Slic3r::Print::_make_wipe_tower().

Here is the caller graph for this function:

◆ get_number_of_toolchanges()

int Slic3r::WipeTower2::get_number_of_toolchanges ( ) const

inline

173{ return m_num_tool_changes; }

References m_num_tool_changes.

Referenced by Slic3r::Print::_make_wipe_tower().

Here is the caller graph for this function:

◆ get_rib_length()

float Slic3r::WipeTower2::get_rib_length ( ) const

inline

102{ return m_rib_length; }

References m_rib_length.

Referenced by Slic3r::Print::_make_wipe_tower().

Here is the caller graph for this function:

◆ get_rib_offset()

Vec2f Slic3r::WipeTower2::get_rib_offset ( ) const

inline

100{ return m_rib_offset; }

References m_rib_offset.

Referenced by Slic3r::Print::_make_wipe_tower().

Here is the caller graph for this function:

◆ get_rib_width()

float Slic3r::WipeTower2::get_rib_width ( ) const

inline

101{ return m_rib_width; }

References m_rib_width.

Referenced by Slic3r::Print::_make_wipe_tower().

Here is the caller graph for this function:

◆ get_used_filament()

std::vector< float > Slic3r::WipeTower2::get_used_filament ( ) const

inline

171{ return m_used_filament_length; }

References m_used_filament_length.

Referenced by Slic3r::Print::_make_wipe_tower().

Here is the caller graph for this function:

◆ get_used_filament_until_layer()

std::vector< std::pair< float, std::vector< float > > > Slic3r::WipeTower2::get_used_filament_until_layer ( ) const

inline

172{ return m_used_filament_length_until_layer; }

References m_used_filament_length_until_layer.

◆ get_wipe_tower_cone_base()

std::pair< double, double > Slic3r::WipeTower2::get_wipe_tower_cone_base	(	double	width,
		double	height,
		double	depth,
		double	angle_deg )

static

{
    double R = std::tan(Geometry::deg2rad(angle_deg/2.)) * height;
    double fake_width = 0.66 * width;
    double diag = std::hypot(fake_width / 2., depth / 2.);
    double support_scale = 1.;
    if (R > diag) {
        double w = fake_width;
        double sin = 0.5 * depth / diag;
        double tan = depth / w;
        double t = (R - diag) * sin;
        support_scale = (w / 2. + t / tan + t * tan) / (w / 2.);
    }
    return std::make_pair(R, support_scale);
}

References Slic3r::Geometry::deg2rad(), and width().

Referenced by cone_base_polygon(), Slic3r::Print::first_layer_wipe_tower_corners(), generate_support_cone_wall(), Slic3r::FakeWipeTower::getFakeExtrusionPathsFromWipeTower2(), and toolchange_Change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_wipe_tower_height()

float Slic3r::WipeTower2::get_wipe_tower_height ( ) const

inline

87{ return m_wipe_tower_height; }

References m_wipe_tower_height.

Referenced by Slic3r::Print::_make_wipe_tower().

Here is the caller graph for this function:

◆ get_z_and_depth_pairs()

std::vector< std::pair< float, float > > Slic3r::WipeTower2::get_z_and_depth_pairs ( ) const

{
    std::vector<std::pair<float, float>> out = {{0.f, m_wipe_tower_depth}};
    for (const WipeTowerInfo& wti : m_plan) {
        assert(wti.depth < wti.depth + WT_EPSILON);
        if (wti.depth < out.back().second - WT_EPSILON)
            out.emplace_back(wti.z, wti.depth);
    }
    if (out.back().first < m_wipe_tower_height - WT_EPSILON)
        out.emplace_back(m_wipe_tower_height, 0.f);
    return out;
}

References m_plan, m_wipe_tower_depth, m_wipe_tower_height, and WT_EPSILON.

Referenced by Slic3r::Print::_make_wipe_tower().

Here is the caller graph for this function:

◆ is_first_layer()

bool Slic3r::WipeTower2::is_first_layer ( ) const

inlineprivate

316{ return size_t(m_layer_info - m_plan.begin()) == m_first_layer_idx; }

References m_first_layer_idx, m_layer_info, and m_plan.

Referenced by finish_layer(), generate_support_rib_wall(), set_layer(), tool_change(), toolchange_Change(), toolchange_Unload(), and toolchange_Wipe().

Here is the caller graph for this function:

◆ layer_finished()

bool Slic3r::WipeTower2::layer_finished ( ) const

inline

                                    {
        return m_current_layer_finished;
  }

References m_current_layer_finished.

Referenced by Slic3r::Print::_make_wipe_tower(), and finish_layer().

Here is the caller graph for this function:

◆ never_skip_tag()

const std::string Slic3r::WipeTower2::never_skip_tag ( )

inlinestatic

31{ return "_GCODE_WIPE_TOWER_NEVER_SKIP_TAG"; }

Referenced by toolchange_Change().

Here is the caller graph for this function:

◆ plan_toolchange()

void Slic3r::WipeTower2::plan_toolchange	(	float	z_par,
		float	layer_height_par,
		unsigned int	old_tool,
		unsigned int	new_tool,
		float	wipe_volume = 0.f )

{
  assert(m_plan.empty() || m_plan.back().z <= z_par + WT_EPSILON);  // refuses to add a layer below the last one
 
  if (m_plan.empty() || m_plan.back().z + WT_EPSILON < z_par) // if we moved to a new layer, we'll add it to m_plan first
    m_plan.push_back(WipeTowerInfo(z_par, layer_height_par));
 
    if (m_first_layer_idx == size_t(-1) && (! m_sparse_layers_skipped || old_tool != new_tool || m_plan.size() == 1))
        m_first_layer_idx = m_plan.size() - 1;
 
    if (old_tool == new_tool) // new layer without toolchanges - we are done
        return;
 
    // this is an actual toolchange - let's calculate depth to reserve on the wipe tower
    const bool first_layer_plan = (m_plan.size() - 1) == m_first_layer_idx;
    m_plan.back().tool_changes.push_back(set_toolchange(old_tool, new_tool, layer_height_par, wipe_volume, first_layer_plan));
}

References m_first_layer_idx, m_plan, m_sparse_layers_skipped, set_toolchange(), and WT_EPSILON.

Referenced by Slic3r::Print::_make_wipe_tower().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ plan_tower()

void Slic3r::WipeTower2::plan_tower ( )

private

{
  // Calculate m_wipe_tower_depth (maximum depth for all the layers) and propagate depths downwards
  m_wipe_tower_depth = 0.f;
  for (auto& layer : m_plan)
    layer.depth = 0.f;
    m_wipe_tower_height = m_plan.empty() ? 0.f : m_plan.back().z;
    m_current_height = 0.f;
  
    for (int layer_index = int(m_plan.size()) - 1; layer_index >= 0; --layer_index)
  {
    float this_layer_depth = std::max(m_plan[layer_index].depth, m_plan[layer_index].toolchanges_depth());
    m_plan[layer_index].depth = this_layer_depth;
    
    if (this_layer_depth > m_wipe_tower_depth - m_perimeter_width)
      m_wipe_tower_depth = this_layer_depth + m_perimeter_width;
 
    for (int i = layer_index - 1; i >= 0 ; i--)
    {
      if (m_plan[i].depth - this_layer_depth < 2*m_perimeter_width )
        m_plan[i].depth = this_layer_depth;
    }
  }
}

References m_current_height, m_perimeter_width, m_plan, m_wipe_tower_depth, and m_wipe_tower_height.

Referenced by generate().

Here is the caller graph for this function:

◆ position()

const Vec2f & Slic3r::WipeTower2::position ( ) const

inline

142{ return m_wipe_tower_pos; }

References m_wipe_tower_pos.

Referenced by Slic3r::Print::_make_wipe_tower().

Here is the caller graph for this function:

◆ prime()

std::vector< WipeTower::ToolChangeResult > Slic3r::WipeTower2::prime	(	float	first_layer_height,
		const std::vector< unsigned int > &	tools,
		bool	last_wipe_inside_wipe_tower )

{
  this->set_layer(initial_layer_print_height, initial_layer_print_height, tools.size(), true, false);
  m_current_tool    = tools.front();
    
    // The Prusa i3 MK2 has a working space of [0, -2.2] to [250, 210].
    // Due to the XYZ calibration, this working space may shrink slightly from all directions,
    // therefore the homing position is shifted inside the bed by 0.2 in the firmware to [0.2, -2.0].
//  WipeTower::box_coordinates cleaning_box(xy(0.5f, - 1.5f), m_wipe_tower_width, wipe_area);
 
    float prime_section_width = std::min(0.9f * m_bed_width / tools.size(), 60.f);
    WipeTower::box_coordinates cleaning_box(Vec2f(0.02f * m_bed_width, 0.01f + m_perimeter_width/2.f), prime_section_width, 100.f);
    if (m_bed_shape == CircularBed) {
        cleaning_box = WipeTower::box_coordinates(Vec2f(0.f, 0.f), prime_section_width, 100.f);
        float total_width_half = tools.size() * prime_section_width / 2.f;
        cleaning_box.translate(-total_width_half, -std::sqrt(std::max(0.f, std::pow(m_bed_width/2, 2.f) - std::pow(1.05f * total_width_half, 2.f))));
    }
    else
        cleaning_box.translate(m_bed_bottom_left);
 
    std::vector<WipeTower::ToolChangeResult> results;
 
    // Iterate over all priming toolchanges and push respective ToolChangeResults into results vector.
    for (size_t idx_tool = 0; idx_tool < tools.size(); ++ idx_tool) {
        size_t old_tool = m_current_tool;
 
        WipeTowerWriter2 writer(m_layer_height, m_perimeter_width, m_gcode_flavor, m_filpar, m_enable_arc_fitting);
        writer.set_extrusion_flow(m_extrusion_flow)
              .set_z(m_z_pos)
              .set_initial_tool(m_current_tool);
 
        // This is the first toolchange - initiate priming
        if (idx_tool == 0) {
            writer.append(";--------------------\n"
                          "; CP PRIMING START\n")
                  .append(";--------------------\n")
                  .speed_override_backup()
                  .speed_override(100)
                  .set_initial_position(Vec2f::Zero())  // Always move to the starting position
                  .travel(cleaning_box.ld, 7200);
            if (m_set_extruder_trimpot)
                writer.set_extruder_trimpot(750);       // Increase the extruder driver current to allow fast ramming.
        }
        else
            writer.set_initial_position(results.back().end_pos);
 
 
        unsigned int tool = tools[idx_tool];
        m_left_to_right = true;
        toolchange_Change(writer, tool, m_filpar[tool].material, m_filpar[tool].first_layer_temperature, false); // Select the tool, set a speed override for soluble and flex materials.
        toolchange_Load(writer, cleaning_box); // Prime the tool.
        if (idx_tool + 1 == tools.size()) {
            // Last tool should not be unloaded, but it should be wiped enough to become of a pure color.
            toolchange_Wipe(writer, cleaning_box, wipe_volumes[tools[idx_tool-1]][tool], false, true);
        } else {
            // Ram the hot material out of the melt zone, retract the filament into the cooling tubes and let it cool.
            //writer.travel(writer.x(), writer.y() + m_perimeter_width, 7200);
            toolchange_Wipe(writer, cleaning_box , 20.f, false, true);
            WipeTower::box_coordinates box = cleaning_box;
            box.translate(0.f, writer.y() - cleaning_box.ld.y() + m_perimeter_width);
            toolchange_Unload(writer, box , m_filpar[m_current_tool].material, m_filpar[m_current_tool].first_layer_temperature, m_filpar[tools[idx_tool + 1]].first_layer_temperature);
            cleaning_box.translate(prime_section_width, 0.f);
            writer.travel(cleaning_box.ld, 7200);
        }
        ++ m_num_tool_changes;
 
 
        // Ask our writer about how much material was consumed:
        if (m_current_tool < m_used_filament_length.size())
            m_used_filament_length[m_current_tool] += writer.get_and_reset_used_filament_length();
 
        // This is the last priming toolchange - finish priming
        if (idx_tool+1 == tools.size()) {
            // Reset the extruder current to a normal value.
            if (m_set_extruder_trimpot)
                writer.set_extruder_trimpot(550);
            writer.speed_override_restore()
                  .feedrate(m_travel_speed * 60.f)
                  .flush_planner_queue()
                  .reset_extruder()
                  .append("; CP PRIMING END\n"
                          ";------------------\n"
                          "\n\n");
        }
 
        results.emplace_back(construct_tcr(writer, true, old_tool, true, false));
    }
 
    m_old_temperature = -1; // If the priming is turned off in config, the temperature changing commands will not actually appear
                            // in the output gcode - we should not remember emitting them (we will output them twice in the worst case)
 
  return results;
}

Referenced by Slic3r::Print::_make_wipe_tower().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ save_on_last_wipe()

void Slic3r::WipeTower2::save_on_last_wipe ( )

private

{
    for (m_layer_info=m_plan.begin();m_layer_info<m_plan.end();++m_layer_info) {
        set_layer(m_layer_info->z, m_layer_info->height, 0, m_layer_info->z == m_plan.front().z, m_layer_info->z == m_plan.back().z);
        if (m_layer_info->tool_changes.size()==0)   // we have no way to save anything on an empty layer
            continue;
 
        // Which toolchange will finish_layer extrusions be subtracted from?
        int idx = first_toolchange_to_nonsoluble_nonsupport(m_layer_info->tool_changes);
 
        if (idx == -1) {
            // In this case, finish_layer will be called at the very beginning.
            finish_layer().total_extrusion_length_in_plane();
        }
 
        const float width = m_wipe_tower_width - 3*m_perimeter_width; // width we draw into
        auto recompute_toolchange = [this, width](WipeTowerInfo::ToolChange& toolchange, float volume_to_save) {
            float volume_left_to_wipe = std::max(m_filpar[toolchange.new_tool].filament_minimal_purge_on_wipe_tower, toolchange.wipe_volume_total - volume_to_save);
            float volume_we_need_depth_for = std::max(0.f, volume_left_to_wipe - length_to_volume(toolchange.first_wipe_line, m_perimeter_width*m_extra_flow, m_layer_info->height));
 
            // ORCA: Keep wipe-depth planning consistent with toolchange_Wipe().
            // ORCA: On the first layer, toolchange_Wipe() advances purge rows using
            // ORCA: m_extra_flow * m_perimeter_width, while later layers use
            // ORCA: m_extra_spacing_wipe * m_perimeter_width.
            // ORCA: float dy = (is_first_layer() ? m_extra_flow : m_extra_spacing_wipe) * m_perimeter_width;
            // ORCA: Use the same spacing here so reserved depth matches consumed depth
            // ORCA: and first-layer purge segments do not leave visible gaps.
            const bool first_layer_plan = size_t(m_layer_info - m_plan.begin()) == m_first_layer_idx;
            const float planning_spacing = first_layer_plan ? m_extra_flow : m_extra_spacing_wipe;
 
            float depth_to_wipe = get_wipe_depth(volume_we_need_depth_for, m_layer_info->height, m_perimeter_width, m_extra_flow, planning_spacing, width);
 
            toolchange.required_depth = toolchange.ramming_depth + depth_to_wipe;
            toolchange.wipe_volume = volume_left_to_wipe;
        };
 
        for (int i=0; i<int(m_layer_info->tool_changes.size()); ++i) {
            auto& toolchange = m_layer_info->tool_changes[i];
            tool_change(toolchange.new_tool);
 
            if (i == idx) {
                recompute_toolchange(toolchange, length_to_volume(finish_layer().total_extrusion_length_in_plane(), m_perimeter_width, m_layer_info->height));
            } else if (toolchange.wipe_volume < m_filpar[toolchange.new_tool].filament_minimal_purge_on_wipe_tower) {
                // Keep filament_minimal_purge_on_wipe_tower enforced for toolchanges that get
                // no finish-layer saving, e.g. a support/soluble filament skipped as the
                // finish filament above. Recomputing only when the clamp binds leaves all
                // other toolchanges with their planned values bit-for-bit.
                recompute_toolchange(toolchange, 0.f);
            }
        }
    }
}

References finish_layer(), first_toolchange_to_nonsoluble_nonsupport(), Slic3r::WipeTower2::WipeTowerInfo::ToolChange::first_wipe_line, Slic3r::get_wipe_depth(), Slic3r::length_to_volume(), m_extra_flow, m_extra_spacing_wipe, m_filpar, m_first_layer_idx, m_layer_info, m_perimeter_width, m_plan, m_wipe_tower_width, Slic3r::WipeTower2::WipeTowerInfo::ToolChange::new_tool, Slic3r::WipeTower2::WipeTowerInfo::ToolChange::ramming_depth, Slic3r::WipeTower2::WipeTowerInfo::ToolChange::required_depth, set_layer(), tool_change(), Slic3r::WipeTower::ToolChangeResult::total_extrusion_length_in_plane(), width(), Slic3r::WipeTower2::WipeTowerInfo::ToolChange::wipe_volume, and Slic3r::WipeTower2::WipeTowerInfo::ToolChange::wipe_volume_total.

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_extruder()

void Slic3r::WipeTower2::set_extruder	(	size_t	idx,
		const PrintConfig &	config )

{
    //while (m_filpar.size() < idx+1)   // makes sure the required element is in the vector
    m_filpar.push_back(FilamentParameters());
 
    // Orca: one row per filament, indexed by the raw filament id. Under a per-layer nozzle
    // grouping the per-variant arrays may hold several columns per filament; the tower has no
    // layer dimension here, so it keeps the filament's first column (tower x per-layer
    // grouping is a documented follow-up).
    m_filpar[idx].material = config.filament_type.get_at(idx);
    if (m_wipe_tower_filament > 0)
        m_filpar[idx].is_soluble = (idx != size_t(m_wipe_tower_filament - 1));
    else
        m_filpar[idx].is_soluble = config.filament_soluble.get_at(idx);
    m_filpar[idx].is_support = config.filament_is_support.get_at(idx);
    m_filpar[idx].temperature = config.nozzle_temperature.get_at(idx);
    m_filpar[idx].first_layer_temperature = config.nozzle_temperature_initial_layer.get_at(idx);
    m_filpar[idx].filament_minimal_purge_on_wipe_tower = config.filament_minimal_purge_on_wipe_tower.get_at(idx);
    {
        int interface_temp = config.filament_tower_interface_print_temp.get_at(idx);
        if (interface_temp == -1)
            interface_temp = config.nozzle_temperature_range_high.get_at(idx);
        m_filpar[idx].interface_print_temperature = interface_temp;
    }
    m_filpar[idx].tower_interface_pre_extrusion_dist = config.filament_tower_interface_pre_extrusion_dist.get_at(idx);
    m_filpar[idx].tower_interface_pre_extrusion_length = config.filament_tower_interface_pre_extrusion_length.get_at(idx);
    m_filpar[idx].tower_ironing_area = config.filament_tower_ironing_area.get_at(idx);
    m_filpar[idx].tower_interface_purge_length = config.filament_tower_interface_purge_volume.get_at(idx);
 
    // If this is a single extruder MM printer, we will use all the SE-specific config values.
    // Otherwise, the defaults will be used to turn off the SE stuff.
    if (m_semm) {
        m_filpar[idx].loading_speed           = float(config.filament_loading_speed.get_at(idx));
        m_filpar[idx].loading_speed_start     = float(config.filament_loading_speed_start.get_at(idx));
        m_filpar[idx].unloading_speed         = float(config.filament_unloading_speed.get_at(idx));
        m_filpar[idx].unloading_speed_start   = float(config.filament_unloading_speed_start.get_at(idx));
        m_filpar[idx].delay                   = float(config.filament_toolchange_delay.get_at(idx));
        m_filpar[idx].cooling_moves           = config.filament_cooling_moves.get_at(idx);
        m_filpar[idx].cooling_initial_speed   = float(config.filament_cooling_initial_speed.get_at(idx));
        m_filpar[idx].cooling_final_speed     = float(config.filament_cooling_final_speed.get_at(idx));
        m_filpar[idx].filament_stamping_loading_speed     = float(config.filament_stamping_loading_speed.get_at(idx));
        m_filpar[idx].filament_stamping_distance          = float(config.filament_stamping_distance.get_at(idx));
    }
 
    m_filpar[idx].filament_area = float((M_PI/4.f) * pow(config.filament_diameter.get_at(idx), 2)); // all extruders are assumed to have the same filament diameter at this point
    float nozzle_diameter = float(config.nozzle_diameter.get_at(idx));
    m_filpar[idx].nozzle_diameter = nozzle_diameter; // to be used in future with (non-single) multiextruder MM
 
    // Orca: max_layer_height is per nozzle, so read it through the filament->nozzle map rather than
    // by filament id. Zero means three quarters of the nozzle diameter, as in Slicing.cpp.
    {
        const std::vector<int> &filament_map = config.filament_map.values; // 1 based nozzle indices
        const size_t nozzle_idx = idx < filament_map.size() && filament_map[idx] > 0 ? size_t(filament_map[idx] - 1) : 0;
        const float  max_layer_height = float(config.max_layer_height.get_at(nozzle_idx));
        m_filpar[idx].max_layer_height = max_layer_height > 0.f ? max_layer_height
                                                                : 0.75f * float(config.nozzle_diameter.get_at(nozzle_idx));
    }
 
    float max_vol_speed = float(config.filament_max_volumetric_speed.get_at(idx));
    if (max_vol_speed!= 0.f)
        m_filpar[idx].max_e_speed = (max_vol_speed / filament_area());
 
    m_perimeter_width = nozzle_diameter * Width_To_Nozzle_Ratio; // all extruders are now assumed to have the same diameter
 
    if (m_semm) {
        std::istringstream stream{config.filament_ramming_parameters.get_at(idx)};
        float speed = 0.f;
        stream >> m_filpar[idx].ramming_line_width_multiplicator >> m_filpar[idx].ramming_step_multiplicator;
        m_filpar[idx].ramming_line_width_multiplicator /= 100;
        m_filpar[idx].ramming_step_multiplicator /= 100;
        while (stream >> speed)
            m_filpar[idx].ramming_speed.push_back(speed);
        // ramming_speed now contains speeds to be used for every 0.25s piece of the ramming line.
        // This allows to have the ramming flow variable. The 0.25s value is how it is saved in config
        // and the same time step has to be used when the ramming is performed.
    } else {
        // We will use the same variables internally, but the correspondence to the configuration options will be different.
        float vol  = config.filament_multitool_ramming_volume.get_at(idx);
        float flow = config.filament_multitool_ramming_flow.get_at(idx);
        m_filpar[idx].multitool_ramming = config.filament_multitool_ramming.get_at(idx) && vol > 0.f && flow > 0.f;
        m_filpar[idx].ramming_line_width_multiplicator = 2.;
        m_filpar[idx].ramming_step_multiplicator = 1.;
 
        // Now the ramming speed vector. In this case it contains just one value (flow).
        // The time is calculated and saved separately. This is here so that the MM ramming
        // is not limited by the 0.25s granularity - it is not possible to create a SEMM-style
        // ramming_speed vector that would respect both the volume and flow (because of 
        // rounding issues with small volumes and high flow).
        m_filpar[idx].ramming_speed.push_back(flow);
        m_filpar[idx].multitool_ramming_time = flow > 0.f ? vol/flow : 0.f;
    }
 
    m_used_filament_length.resize(std::max(m_used_filament_length.size(), idx + 1)); // makes sure that the vector is big enough so we don't have to check later
 
    m_filpar[idx].retract_length = config.retraction_length.get_at(idx);
    m_filpar[idx].retract_speed  = config.retraction_speed.get_at(idx);
}

References filament_area(), Slic3r::filament_map(), m_filpar, m_perimeter_width, M_PI, m_semm, m_used_filament_length, m_wipe_tower_filament, Slic3r::nozzle_diameter(), and Width_To_Nozzle_Ratio.

Referenced by Slic3r::Print::_make_wipe_tower().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_layer()

void Slic3r::WipeTower2::set_layer	(	float	print_z,
		float	layer_height,
		size_t	max_tool_changes,
		bool	,
		bool	is_last_layer )

inline

  {
    m_z_pos         = print_z;
    m_layer_height      = layer_height;
    m_depth_traversed  = 0.f;
        m_current_layer_finished = false;
        m_prev_layer_had_interface = m_current_layer_has_interface;
 
    
        // Advance m_layer_info iterator, making sure we got it right
    while (!m_plan.empty() && m_layer_info->z < print_z - WT_EPSILON && m_layer_info+1 != m_plan.end())
      ++m_layer_info;
        m_current_layer_has_interface = (m_layer_info != m_plan.end()) && (m_layer_info->toolchanges_depth() > WT_EPSILON);
 
    //m_current_shape = (! this->is_first_layer() && m_current_shape == SHAPE_NORMAL) ? SHAPE_REVERSED : SHAPE_NORMAL;
        m_current_shape = SHAPE_NORMAL;
    if (this->is_first_layer()) {
            m_num_layer_changes = 0;
            m_num_tool_changes  = 0;
        } else
            ++ m_num_layer_changes;
    
    // Calculate extrusion flow from desired line width, nozzle diameter, filament diameter and layer_height:
    m_extrusion_flow = extrusion_flow(layer_height);
  }

References extrusion_flow(), is_first_layer(), Slic3r::layer_height(), m_current_layer_finished, m_current_layer_has_interface, m_current_shape, m_depth_traversed, m_extrusion_flow, m_layer_height, m_layer_info, m_num_layer_changes, m_num_tool_changes, m_plan, m_prev_layer_had_interface, m_z_pos, SHAPE_NORMAL, and WT_EPSILON.

Referenced by Slic3r::Print::_make_wipe_tower(), generate(), prime(), and save_on_last_wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_toolchange()

WipeTower2::WipeTowerInfo::ToolChange Slic3r::WipeTower2::set_toolchange	(	size_t	old_tool,
		size_t	new_tool,
		float	layer_height,
		float	wipe_volume,
		bool	first_layer_plan )

private

{
    float width = m_wipe_tower_width - 3*m_perimeter_width;
  float length_to_extrude = volume_to_length((m_semm ? 0.25f : m_filpar[old_tool].multitool_ramming_time) * std::accumulate(m_filpar[old_tool].ramming_speed.begin(), m_filpar[old_tool].ramming_speed.end(), 0.f),
                    m_perimeter_width * m_filpar[old_tool].ramming_line_width_multiplicator,
                    layer_height);
    // Orca: Reserve ramming depth only when toolchange_Unload() will actually ram,
    // otherwise the unprinted reservation leaves blank bands between the purge boxes.
    const bool do_ramming = tool_ramming_enabled(old_tool);
    // Orca: with the gap wall on a multi-tool printer the ram band is quantized up to
    // the whole reserved rows and the wipe restarts at the left-edge boundary on a
    // fresh row below it (BBL parity: the old-tool purge is whole rows and the wipe
    // always starts at the box corner, where the entry scrub runs).
    const bool boundary_wipe_start = boundary_wipe_start_enabled(old_tool);
    float ramming_depth = do_ramming ? ((int(length_to_extrude / width) + 1) * (m_perimeter_width * m_filpar[old_tool].ramming_line_width_multiplicator * m_filpar[old_tool].ramming_step_multiplicator) * m_extra_spacing_ramming) : 0;
    // first_wipe_line rides for free on the last (partially used) ramming row, which
    // is already covered by ramming_depth. Without ramming that row does not exist
    // (and with a boundary wipe start the ram band is quantized to whole rows), so
    // the whole wipe volume needs reserved wiping depth.
    float first_wipe_line = (do_ramming && !boundary_wipe_start) ? - (width*((length_to_extrude / width)-int(length_to_extrude / width)) - width) : 0.f;
 
    float first_wipe_volume = length_to_volume(first_wipe_line, m_perimeter_width * m_extra_flow, layer_height);
 
    // ORCA: Keep wipe-depth planning consistent with toolchange_Wipe().
    // ORCA: On the first layer, toolchange_Wipe() advances purge rows using
    // ORCA: m_extra_flow * m_perimeter_width, while later layers use
    // ORCA: m_extra_spacing_wipe * m_perimeter_width.
    // ORCA: float dy = (is_first_layer() ? m_extra_flow : m_extra_spacing_wipe) * m_perimeter_width;
    // ORCA: Use the same spacing here so reserved depth matches consumed depth
    // ORCA: and first-layer purge segments do not leave visible gaps.
    const float planning_spacing = first_layer_plan ? m_extra_flow : m_extra_spacing_wipe;
 
    float wiping_depth = get_wipe_depth(wipe_volume - first_wipe_volume, layer_height, m_perimeter_width, m_extra_flow, planning_spacing, width);
 
  return WipeTowerInfo::ToolChange(old_tool, new_tool, ramming_depth + wiping_depth, ramming_depth, first_wipe_line, wipe_volume);
}

References boundary_wipe_start_enabled(), Slic3r::get_wipe_depth(), Slic3r::layer_height(), Slic3r::length_to_volume(), m_extra_flow, m_extra_spacing_ramming, m_extra_spacing_wipe, m_filpar, m_perimeter_width, m_semm, m_wipe_tower_width, tool_ramming_enabled(), Slic3r::volume_to_length(), and width().

Referenced by generate(), and plan_toolchange().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tool_change()

WipeTower::ToolChangeResult Slic3r::WipeTower2::tool_change ( size_t new_tool )

{
    size_t old_tool = m_current_tool;
 
    float wipe_area = 0.f;
  float wipe_volume = 0.f;
    float ramming_depth = 0.f;
    bool interface_layer = m_enable_tower_interface_features && m_current_layer_has_interface;
 
  // Finds this toolchange info
  if (tool != (unsigned int)(-1))
  {
    for (const auto &b : m_layer_info->tool_changes)
      if ( b.new_tool == tool ) {
                wipe_volume = b.wipe_volume;
        wipe_area = b.required_depth;
                ramming_depth = b.ramming_depth;
        break;
      }
  }
  else {
    // Otherwise we are going to Unload only. And m_layer_info would be invalid.
  }
    if (interface_layer && tool != (unsigned int)(-1) && tool < m_filpar.size()) {
        float extra_purge_length = m_filpar[tool].tower_interface_purge_length;
        if (extra_purge_length > 0.f) {
            wipe_volume += extra_purge_length * m_filpar[tool].filament_area;
        }
    }
 
    WipeTower::box_coordinates cleaning_box(
    Vec2f(m_perimeter_width / 2.f, m_perimeter_width / 2.f),
    m_wipe_tower_width - m_perimeter_width,
        (tool != (unsigned int)(-1) ? wipe_area+m_depth_traversed-0.5f*m_perimeter_width
                                    : m_wipe_tower_depth-m_perimeter_width));
 
  WipeTowerWriter2 writer(m_layer_height, m_perimeter_width, m_gcode_flavor, m_filpar, m_enable_arc_fitting);
  writer.set_extrusion_flow(m_extrusion_flow)
    .set_z(m_z_pos)
    .set_initial_tool(m_current_tool)
        .set_y_shift(m_y_shift + (tool!=(unsigned int)(-1) && (m_current_shape == SHAPE_REVERSED) ? m_layer_info->depth - m_layer_info->toolchanges_depth(): 0.f))
    .append(";--------------------\n"
        "; CP TOOLCHANGE START\n");
 
    if (tool != (unsigned)(-1)){
        writer.comment_with_value(" toolchange #", m_num_tool_changes + 1); // the number is zero-based
        writer.append(std::string("; material : " + (m_current_tool < m_filpar.size() ? m_filpar[m_current_tool].material : "(NONE)") + " -> " + m_filpar[tool].material + "\n").c_str())
            .append(";--------------------\n");
        writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Wipe_Tower_Start) + "\n");
    }
 
    writer.speed_override_backup();
  writer.speed_override(100);
 
    // On a boundary wipe start this enters at the wall gap on the first wipe row;
    // toolchange_Unload() then climbs back up to the ram band along the box interior.
    Vec2f initial_position = toolchange_entry_pos(m_depth_traversed, ramming_depth, is_first_layer());
    writer.set_initial_position(initial_position, m_wipe_tower_width, m_wipe_tower_depth, m_internal_rotation);
 
    // Increase the extruder driver current to allow fast ramming.
  if (m_set_extruder_trimpot)
    writer.set_extruder_trimpot(750);
 
    // Ram the hot material out of the melt zone, retract the filament into the cooling tubes and let it cool.
    if (tool != (unsigned int)-1){      // This is not the last change.
        // Without a ram — or with the boundary wipe start, where the ram band is
        // quantized to whole rows — the box is planned as whole wipe rows; the wipe
        // then fills it completely so adjacent purge blocks stay contiguous. Uses the
        // old tool (m_current_tool before toolchange_Change).
        const bool fill_box = !tool_ramming_enabled(m_current_tool) || boundary_wipe_start_enabled(m_current_tool);
        auto new_tool_temp = is_first_layer() ? m_filpar[tool].first_layer_temperature : m_filpar[tool].temperature;
        toolchange_Unload(writer, cleaning_box, m_filpar[m_current_tool].material,
                          (is_first_layer() ? m_filpar[m_current_tool].first_layer_temperature : m_filpar[m_current_tool].temperature),
                          new_tool_temp);
        // Wait-at-tower target: the interface temp when an interface boost applies on this layer,
        // otherwise the print temp (nozzle_temperature == 0 means "use the first layer temp").
        int wait_for_temp = interface_layer && m_filpar[tool].interface_print_temperature > 0 ?
                                m_filpar[tool].interface_print_temperature :
                                (is_first_layer() || m_filpar[tool].temperature == 0 ? m_filpar[tool].first_layer_temperature : m_filpar[tool].temperature);
        toolchange_Change(writer, tool, m_filpar[tool].material, wait_for_temp, true); // Change the tool, set a speed override for soluble and flex materials.
        toolchange_Load(writer, cleaning_box);
        writer.travel(writer.x(), writer.y()-m_perimeter_width); // cooling and loading were done a bit down the road
        int base_temp = is_first_layer() ? m_filpar[tool].first_layer_temperature : m_filpar[tool].temperature;
        if (interface_layer) {
            int interface_temp = m_filpar[tool].interface_print_temperature;
            // With wait-for-temp-on-wipe-tower the toolchange already blocked for the interface temp.
            if (interface_temp > 0 && interface_temp != base_temp && !m_wait_for_temp_on_wipe_tower)
                writer.set_extruder_temp(interface_temp, true);
            if (m_enable_tower_interface_cooldown_during_tower && interface_temp > 0 && interface_temp != base_temp)
                writer.set_extruder_temp(base_temp, false);
            float pre_dist = m_filpar[tool].tower_interface_pre_extrusion_dist;
            float pre_len = m_filpar[tool].tower_interface_pre_extrusion_length;
            if (pre_dist > 0.f && pre_len > 0.f) {
                float target_x = writer.x() + pre_dist;
                target_x = std::max(cleaning_box.ld.x(), std::min(cleaning_box.rd.x(), target_x));
                writer.extrude_explicit(target_x, writer.y(), pre_len, 600.f);
            }
        }
        toolchange_Wipe(writer, cleaning_box, wipe_volume, interface_layer, false, fill_box);     // Wipe the newly loaded filament until the end of the assigned wipe area.
        if (interface_layer) {
            int interface_temp = m_filpar[tool].interface_print_temperature;
            if (!m_enable_tower_interface_cooldown_during_tower && interface_temp > 0 && interface_temp != base_temp)
                writer.set_extruder_temp(base_temp, false);
        }
        writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Wipe_Tower_End) + "\n");
        ++ m_num_tool_changes;
    } else
        toolchange_Unload(writer, cleaning_box, m_filpar[m_current_tool].material, m_filpar[m_current_tool].temperature, m_filpar[m_current_tool].temperature);
 
    m_depth_traversed += wipe_area;
 
  if (m_set_extruder_trimpot)
    writer.set_extruder_trimpot(550);    // Reset the extruder current to a normal value.
  writer.speed_override_restore();
    writer.feedrate(m_travel_speed * 60.f)
          .flush_planner_queue()
          .reset_extruder()
          .append("; CP TOOLCHANGE END\n"
                  ";------------------\n"
                  "\n\n");
 
    // Ask our writer about how much material was consumed:
    if (m_current_tool < m_used_filament_length.size())
        m_used_filament_length[m_current_tool] += writer.get_and_reset_used_filament_length();
 
    return construct_tcr(writer, false, old_tool, false, interface_layer);
}

Referenced by Slic3r::Print::_make_wipe_tower(), generate(), and save_on_last_wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tool_ramming_enabled()

bool Slic3r::WipeTower2::tool_ramming_enabled ( size_t tool ) const

inlineprivate

323{ return (m_semm && m_enable_filament_ramming) || m_filpar[tool].multitool_ramming; }

References m_enable_filament_ramming, m_filpar, and m_semm.

Referenced by boundary_wipe_start_enabled(), set_toolchange(), tool_change(), and toolchange_Unload().

Here is the caller graph for this function:

◆ toolchange_Change()

void Slic3r::WipeTower2::toolchange_Change	(	WipeTowerWriter2 &	writer,
		const size_t	new_tool,
		const std::string &	new_material,
		const int	wait_for_temp,
		const bool	wait_beside_tower )

private

{
    // Ask the writer about how much of the old filament we consumed:
    if (m_current_tool < m_used_filament_length.size())
      m_used_filament_length[m_current_tool] += writer.get_and_reset_used_filament_length();
 
    // This is where we want to place the custom gcodes. We will use placeholders for this.
    // These will be substituted by the actual gcodes when the gcode is generated.
    //writer.append("[end_filament_gcode]\n");
    writer.append("[change_filament_gcode]\n");
 
    if (m_is_mk4mmu3)
        writer.switch_filament_monitoring(true);
 
    const bool wait_for_temp_here = m_wait_for_temp_on_wipe_tower && wait_for_temp > 0;
 
    // The Tn above was issued without a blocking temperature wait (GCode::set_extruder only raises
    // the target, ahead of the Tn); block here, before the deretraction below, which must not
    // extrude on a cold nozzle. Like the Bambu H2C, park beside the tower for the heat-up so drool lands
    // next to it instead of on its top surface — nearest x side first, then that side clamped
    // toward the bed edge, then the far side, in place if all would leave the bed. Raw
    // pre-rotated moves (see the repositioning move below) keep the writer's tracked position
    // at the tower entry. The tag keeps the
    // interface-temp deduplication pass in append_tcr2 from stripping the M109.
    if (wait_for_temp_here && wait_beside_tower) {
        // The rib wall and the stabilization cone bulge past the nominal width rectangle
        // (widest near the bottom), and the first-layer brim is printed around the wall later
        // in the layer — clear the widest of them, not just the rectangle, so the park point
        // and its drool stay off the tower.
        float min_x = 0.f, max_x = m_wipe_tower_width;
        if (m_wall_type == (int)wtwRib) {
            WipeTower::box_coordinates wt_box(Vec2f(0.f, 0.f), m_wipe_tower_width, m_layer_info->depth + m_perimeter_width);
            const BoundingBox rib_bbox = get_extents(generate_rib_polygon(wt_box)); // the fillet stays within this bbox
            min_x = std::min(min_x, unscaled<float>(rib_bbox.min.x()));
            max_x = std::max(max_x, unscaled<float>(rib_bbox.max.x()));
        } else if (m_wall_type == (int)wtwCone) {
            const double support_scale = get_wipe_tower_cone_base(m_wipe_tower_width, m_wipe_tower_height, m_wipe_tower_depth,
                                                                  m_wipe_tower_cone_angle).second;
            const double z = m_sparse_layers_skipped ? (m_current_height + m_layer_info->height) : m_layer_info->z;
            const double r = std::tan(Geometry::deg2rad(m_wipe_tower_cone_angle / 2.f)) * (m_wipe_tower_height - z);
            const double w = m_layer_info->depth + m_perimeter_width;
            if (r > 0.5 * w + 0.01) { // same guard as generate_support_cone_wall
                const float bulge = float(std::sqrt(r * r - 0.25 * w * w) / support_scale);
                min_x = std::min(min_x, m_wipe_tower_width / 2.f - bulge);
                max_x = std::max(max_x, m_wipe_tower_width / 2.f + bulge);
            }
        }
        if (is_first_layer()) {
            const float brim = m_wipe_tower_brim_width < 0.f ? WipeTower::get_auto_brim_by_height(m_wipe_tower_height) :
                                                               m_wipe_tower_brim_width;
            min_x -= brim;
            max_x += brim;
        }
        constexpr float gap     = 2.f;
        constexpr float min_gap = 0.5f;
        const bool      on_left = writer.x() < m_wipe_tower_width / 2.f;
        const float     near_x  = on_left ? min_x - gap : max_x + gap;
        const float     far_x   = on_left ? max_x + gap : min_x - gap;
        const Eigen::Rotation2Df to_bed(float(Geometry::deg2rad(m_wipe_tower_rotation_angle)));
        auto park_pt_on_bed = [this, &writer, to_bed](float side_x) {
            const Vec2f bed_pt = to_bed * (writer.rotated(Vec2f(side_x, writer.y())) + m_rib_offset) + m_wipe_tower_pos;
            return m_bed_polygon.contains(Point::new_scale(bed_pt.x(), bed_pt.y()));
        };
        float park_x    = near_x;
        bool  have_park = park_pt_on_bed(near_x);
        if (!have_park) {
            // The ideal near point hangs off the bed: pull it back to the bed edge as long
            // as that still clears the tower envelope by min_gap (the BBL tower clamps its
            // stop_pos against the bed the same way in append_tcr). Bisection, because with
            // tower rotation and non-rectangular beds the bed edge is not axis-aligned.
            const float limit_x = on_left ? min_x - min_gap : max_x + min_gap;
            if (park_pt_on_bed(limit_x)) {
                float on = limit_x, off = near_x;
                for (int i = 0; i < 8; ++i) {
                    const float mid = 0.5f * (on + off);
                    if (park_pt_on_bed(mid))
                        on = mid;
                    else
                        off = mid;
                }
                park_x    = on;
                have_park = true;
            }
        }
        if (!have_park && park_pt_on_bed(far_x)) {
            park_x    = far_x;
            have_park = true;
        }
        if (have_park) {
            const Vec2f stop = writer.rotated(Vec2f(park_x, writer.y()));
            writer.feedrate(m_travel_speed * 60.f)
                  .append(std::string("G1 X") + Slic3r::float_to_string_decimal_point(stop.x())
                                     +  " Y"  + Slic3r::float_to_string_decimal_point(stop.y())
                                     + never_skip_tag() + "\n");
        }
        writer.set_extruder_temp(wait_for_temp, true, wait_for_temp_tag());
    }
 
    // Travel to where we assume we are. Custom toolchange or some special T code handling (parking extruder etc)
    // gcode could have left the extruder somewhere, we cannot just start extruding. We should also inform the
    // postprocessor that we absolutely want to have this in the gcode, even if it thought it is the same as before.
    Vec2f current_pos = writer.pos_rotated();
    writer.feedrate(m_travel_speed * 60.f) // see https://github.com/prusa3d/PrusaSlicer/issues/5483
          .append(std::string("G1 X") + Slic3r::float_to_string_decimal_point(current_pos.x())
                             +  " Y"  + Slic3r::float_to_string_decimal_point(current_pos.y())
                             + never_skip_tag() + "\n"
    );
 
    // Priming has no tower to park beside — wait right at the priming line instead.
    if (wait_for_temp_here && !wait_beside_tower)
        writer.set_extruder_temp(wait_for_temp, true, wait_for_temp_tag());
 
    writer.append("[deretraction_from_wipe_tower_generator]");
 
    // The toolchange Tn command will be inserted later, only in case that the user does
    // not provide a custom toolchange gcode.
  writer.set_tool(new_tool); // This outputs nothing, the writer just needs to know the tool has changed.
    // writer.append("[filament_start_gcode]\n");
 
 
  writer.flush_planner_queue();
  m_current_tool = new_tool;
}

Referenced by prime(), and tool_change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toolchange_entry_pos()

Vec2f Slic3r::WipeTower2::toolchange_entry_pos	(	float	depth_traversed,
		float	ramming_depth,
		bool	first_layer ) const

inlineprivate

    {
        Vec2f pos(m_perimeter_width / 2.f, m_perimeter_width / 2.f + depth_traversed);
        if (!m_semm && m_use_gap_wall && ramming_depth > 0.f)
            pos.y() += wipe_start_offset_after_ram(ramming_depth, first_layer);
        return pos;
    }

References m_perimeter_width, m_semm, m_use_gap_wall, and wipe_start_offset_after_ram().

Referenced by compute_wall_skip_points(), and tool_change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toolchange_Load()

void Slic3r::WipeTower2::toolchange_Load	(	WipeTowerWriter2 &	writer,
		const WipeTower::box_coordinates &	cleaning_box )

private

{
    if (m_semm && m_enable_filament_ramming && (m_parking_pos_retraction != 0 || m_extra_loading_move != 0)) {
        float xl = cleaning_box.ld.x() + m_perimeter_width * 0.75f;
        float xr = cleaning_box.rd.x() - m_perimeter_width * 0.75f;
        float oldx = writer.x();  // the nozzle is in place to do the first wiping moves, we will remember the position
 
        // Load the filament while moving left / right, so the excess material will not create a blob at a single position.
        float turning_point = ( oldx-xl < xr-oldx ? xr : xl );
        float edist = m_parking_pos_retraction+m_extra_loading_move;
 
        writer.append("; CP TOOLCHANGE LOAD\n")
              .suppress_preview()
              .load(0.2f * edist, 60.f * m_filpar[m_current_tool].loading_speed_start)
              .load_move_x_advanced(turning_point, 0.7f * edist,        m_filpar[m_current_tool].loading_speed)  // Fast phase
              .load_move_x_advanced(oldx,          0.1f * edist, 0.1f * m_filpar[m_current_tool].loading_speed)  // Super slow*/
 
              .travel(oldx, writer.y()) // in case last move was shortened to limit x feedrate
              .resume_preview();
 
        // Reset the extruder current to the normal value.
        if (m_set_extruder_trimpot)
            writer.set_extruder_trimpot(550);
    }
}

References Slic3r::WipeTowerWriter2::append(), Slic3r::WipeTower::box_coordinates::ld, Slic3r::WipeTowerWriter2::load(), Slic3r::WipeTowerWriter2::load_move_x_advanced(), m_current_tool, m_enable_filament_ramming, m_extra_loading_move, m_filpar, m_parking_pos_retraction, m_perimeter_width, m_semm, m_set_extruder_trimpot, Slic3r::WipeTower::box_coordinates::rd, Slic3r::WipeTowerWriter2::resume_preview(), Slic3r::WipeTowerWriter2::set_extruder_trimpot(), Slic3r::WipeTowerWriter2::suppress_preview(), Slic3r::WipeTowerWriter2::travel(), Slic3r::WipeTowerWriter2::x(), and Slic3r::WipeTowerWriter2::y().

Referenced by prime(), and tool_change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toolchange_Unload()

void Slic3r::WipeTower2::toolchange_Unload	(	WipeTowerWriter2 &	writer,
		const WipeTower::box_coordinates &	cleaning_box,
		const std::string &	current_material,
		const int	old_temperature,
		const int	new_temperature )

private

{
  float xl = cleaning_box.ld.x() + 1.f * m_perimeter_width;
  float xr = cleaning_box.rd.x() - 1.f * m_perimeter_width;
 
    const float line_width = m_perimeter_width * m_filpar[m_current_tool].ramming_line_width_multiplicator;       // desired ramming line thickness
  const float y_step = line_width * m_filpar[m_current_tool].ramming_step_multiplicator * m_extra_spacing_ramming; // spacing between lines in mm
 
    const Vec2f ramming_start_pos = Vec2f(xl, cleaning_box.ld.y() + m_depth_traversed + y_step/2.f);
 
    writer.append("; CP TOOLCHANGE UNLOAD\n")
        .change_analyzer_line_width(line_width);
 
  unsigned i = 0;                   // iterates through ramming_speed
  m_left_to_right = true;               // current direction of ramming
  float remaining = xr - xl ;             // keeps track of distance to the next turnaround
  float e_done = 0;                 // measures E move done from each segment   
 
    const bool do_ramming = tool_ramming_enabled(m_current_tool);
    const bool cold_ramming = m_is_mk4mmu3;
    // Orca: see set_toolchange() — quantized ram band + wipe restart at the boundary.
    const bool boundary_wipe_start = boundary_wipe_start_enabled(m_current_tool);
    float planned_ramming_depth = 0.f;
    if (boundary_wipe_start && m_layer_info != m_plan.end())
        for (const auto& tch : m_layer_info->tool_changes)
            if (tch.old_tool == m_current_tool) { planned_ramming_depth = tch.ramming_depth; break; }
 
    if (do_ramming) {
        if (boundary_wipe_start)
            // The entry sits at the wall gap on the first wipe row past the reserved
            // ram band; step inward first, then move to the band clear of the wall.
            writer.travel(Vec2f(ramming_start_pos.x(), writer.y()));
        writer.travel(ramming_start_pos); // move to starting position
        if (! m_is_mk4mmu3)
            writer.disable_linear_advance();
        if (cold_ramming)
            writer.set_extruder_temp(old_temperature - 20);
    }
    else
        writer.set_position(ramming_start_pos);
 
    // if the ending point of the ram would end up in mid air, align it with the end of the wipe tower:
    // (with a boundary wipe start the band is quantized to whole rows below, so no phase alignment is needed)
    if (do_ramming && !boundary_wipe_start && (m_layer_info > m_plan.begin() && m_layer_info < m_plan.end() && (m_layer_info-1!=m_plan.begin() || !m_adhesion ))) {
 
        // this is y of the center of previous sparse infill border
        float sparse_beginning_y = 0.f;
        if (m_current_shape == SHAPE_REVERSED)
            sparse_beginning_y += ((m_layer_info-1)->depth - (m_layer_info-1)->toolchanges_depth())
                                      - ((m_layer_info)->depth-(m_layer_info)->toolchanges_depth()) ;
        else
            sparse_beginning_y += (m_layer_info-1)->toolchanges_depth() + m_perimeter_width;
 
        float sum_of_depths = 0.f;
        for (const auto& tch : m_layer_info->tool_changes) {  // let's find this toolchange
            if (tch.old_tool == m_current_tool) {
                sum_of_depths += tch.ramming_depth;
                float ramming_end_y = sum_of_depths;
                ramming_end_y -= (y_step/m_extra_spacing_ramming-m_perimeter_width) / 2.f;   // center of final ramming line
 
                if ( (m_current_shape == SHAPE_REVERSED   && ramming_end_y < sparse_beginning_y - 0.5f*m_perimeter_width  ) ||
                     (m_current_shape == SHAPE_NORMAL && ramming_end_y > sparse_beginning_y + 0.5f*m_perimeter_width  )  )
                {
                    writer.extrude(xl + tch.first_wipe_line-1.f*m_perimeter_width,writer.y());
                    remaining -= tch.first_wipe_line-1.f*m_perimeter_width;
                }
                break;
            }
            sum_of_depths += tch.required_depth;
        }
    }
 
    if (m_is_mk4mmu3) {
        writer.switch_filament_monitoring(false);
        writer.wait(1.5f);
    }
    
 
    // now the ramming itself:
    while (do_ramming && i < m_filpar[m_current_tool].ramming_speed.size())
    {
        // The time step is different for SEMM ramming and the MM ramming. See comments in set_extruder() for details.
        const float time_step = m_semm ? 0.25f : m_filpar[m_current_tool].multitool_ramming_time;
 
        const float x = volume_to_length(m_filpar[m_current_tool].ramming_speed[i] * time_step, line_width, m_layer_height);
        const float e = m_filpar[m_current_tool].ramming_speed[i] * time_step / filament_area(); // transform volume per sec to E move;
        const float dist = std::min(x - e_done, remaining);     // distance to travel for either the next time_step, or to the next turnaround
        const float actual_time = dist/x * time_step;
        writer.ram(writer.x(), writer.x() + (m_left_to_right ? 1.f : -1.f) * dist, 0.f, 0.f, e * (dist / x), dist / (actual_time / 60.f));
        remaining -= dist;
 
    if (remaining < WT_EPSILON) { // we reached a turning point
      writer.travel(writer.x(), writer.y() + y_step, 7200);
      m_left_to_right = !m_left_to_right;
      remaining = xr - xl;
    }
    e_done += dist; // subtract what was actually done
    if (e_done > x - WT_EPSILON) { // current segment finished
      ++i;
      e_done = 0;
    }
  }
 
    // Orca: quantize the ram band up to the whole reserved rows (BBL quantizes the
    // old-tool purge the same way) so no unprinted void is left between the band and
    // the wipe restarting at the boundary below it.
    if (planned_ramming_depth > 0.f) {
        const int   reserved_rows = std::max(1, int(std::round(planned_ramming_depth / y_step)));
        const float last_row_y    = ramming_start_pos.y() + (reserved_rows - 1) * y_step;
        // Same bead model as the ramming segments above: E per mm of ram line.
        const float e_per_mm      = 1.f / (volume_to_length(1.f, line_width, m_layer_height) * filament_area());
        const float fill_feed     = m_filpar[m_current_tool].ramming_speed.empty() ? 3000.f :
            60.f * volume_to_length(m_filpar[m_current_tool].ramming_speed.back(), line_width, m_layer_height);
        while (true) {
            const float target_x = m_left_to_right ? xr : xl;
            if (std::abs(target_x - writer.x()) > WT_EPSILON)
                writer.ram(writer.x(), target_x, 0.f, 0.f, e_per_mm * std::abs(target_x - writer.x()), fill_feed);
            if (writer.y() + 0.5f * y_step > last_row_y)
                break;
            writer.travel(writer.x(), writer.y() + y_step, 7200);
            m_left_to_right = !m_left_to_right;
        }
    }
 
  Vec2f end_of_ramming(writer.x(),writer.y());
    writer.change_analyzer_line_width(m_perimeter_width);   // so the next lines are not affected by ramming_line_width_multiplier
 
    // Retraction:
    if(m_enable_filament_ramming)
        writer.append("; Ramming start\n");
 
    float old_x = writer.x();
    float turning_point = (!m_left_to_right ? xl : xr );
    if (m_enable_filament_ramming && m_semm && (m_cooling_tube_retraction != 0 || m_cooling_tube_length != 0)) {
        writer.append("; Retract(unload)\n");
        float total_retraction_distance = m_cooling_tube_retraction + m_cooling_tube_length/2.f - 15.f; // the 15mm is reserved for the first part after ramming
        writer.suppress_preview()
              .retract(15.f, m_filpar[m_current_tool].unloading_speed_start * 60.f) // feedrate 5000mm/min = 83mm/s
              .retract(0.70f * total_retraction_distance, 1.0f * m_filpar[m_current_tool].unloading_speed * 60.f)
              .retract(0.20f * total_retraction_distance, 0.5f * m_filpar[m_current_tool].unloading_speed * 60.f)
              .retract(0.10f * total_retraction_distance, 0.3f * m_filpar[m_current_tool].unloading_speed * 60.f)
              .resume_preview();
    }
 
    const int& number_of_cooling_moves = m_filpar[m_current_tool].cooling_moves;
    const bool cooling_will_happen = m_enable_filament_ramming && m_semm && number_of_cooling_moves > 0 && m_cooling_tube_length != 0;
    bool change_temp_later = false;
 
    // Wipe tower should only change temperature with single extruder MM. Otherwise, all temperatures should
    // be already set and there is no need to change anything. Also, the temperature could be changed
    // for wrong extruder.
    if (m_semm) {
        if (new_temperature != 0 && (new_temperature != m_old_temperature || is_first_layer() || cold_ramming) ) {  // Set the extruder temperature, but don't wait.
            // If the required temperature is the same as last time, don't emit the M104 again (if user adjusted the value, it would be reset)
            // However, always change temperatures on the first layer (this is to avoid issues with priming lines turned off).
            if (cold_ramming && cooling_will_happen)
                change_temp_later = true;
            else
                writer.set_extruder_temp(new_temperature, false);
            m_old_temperature = new_temperature;
        }
    }
 
    // Cooling:
    if (cooling_will_happen) {
        writer.append("; Cooling\n");
        const float& initial_speed = m_filpar[m_current_tool].cooling_initial_speed;
        const float& final_speed   = m_filpar[m_current_tool].cooling_final_speed;
 
        float speed_inc = (final_speed - initial_speed) / (2.f * number_of_cooling_moves - 1.f);
 
        if (m_is_mk4mmu3)
            writer.disable_linear_advance();
 
        writer.suppress_preview()
              .travel(writer.x(), writer.y() + y_step);
        old_x = writer.x();
        turning_point = xr-old_x > old_x-xl ? xr : xl;
        float stamping_dist_e = m_filpar[m_current_tool].filament_stamping_distance + m_cooling_tube_length / 2.f;
 
        for (int i=0; i<number_of_cooling_moves; ++i) {
 
            // Stamping - happens after every cooling move except for the last one.
            if (i>0 && m_filpar[m_current_tool].filament_stamping_distance != 0) {
 
                // Stamping turning point shall be no farther than 20mm from the current nozzle position:
                float stamping_turning_point = std::clamp(old_x + 20.f * (turning_point - old_x > 0.f ? 1.f : -1.f), xl, xr);
 
                // Only last 5mm will be done with the fast x travel. The point is to spread possible blobs
                // along the whole wipe tower.
                if (stamping_dist_e > 5) {
                    float cent = writer.x();
                    writer.load_move_x_advanced(stamping_turning_point, (stamping_dist_e - 5), m_filpar[m_current_tool].filament_stamping_loading_speed, 200);
                    writer.load_move_x_advanced(cent, 5, m_filpar[m_current_tool].filament_stamping_loading_speed, m_travel_speed);
                    writer.travel(cent, writer.y());
                } else
                    writer.load_move_x_advanced_there_and_back(stamping_turning_point, stamping_dist_e, m_filpar[m_current_tool].filament_stamping_loading_speed, m_travel_speed);
 
                // Retract while the print head is stationary, so if there is a blob, it is not dragged along.
                writer.retract(stamping_dist_e, m_filpar[m_current_tool].unloading_speed * 60.f);
            }
 
            if (i == number_of_cooling_moves - 1 && change_temp_later) {
                // If cold_ramming, the temperature change should be done before the last cooling move.
                    writer.set_extruder_temp(new_temperature, false);
            }
 
            float speed = initial_speed + speed_inc * 2*i;
            writer.load_move_x_advanced(turning_point, m_cooling_tube_length, speed);
            speed += speed_inc;
            writer.load_move_x_advanced(old_x, -m_cooling_tube_length, speed);
        }
    }
 
    if (m_enable_filament_ramming && m_semm) {
        writer.append("; Cooling park\n");
        // let's wait is necessary:
        writer.wait(m_filpar[m_current_tool].delay);
        // we should be at the beginning of the cooling tube again - let's move to parking position:
        const auto _e = -m_cooling_tube_length / 2.f + m_parking_pos_retraction - m_cooling_tube_retraction;
        if (_e != 0.f)
            writer.retract(_e, 2000);
    }
 
    if(m_enable_filament_ramming)
        writer.append("; Ramming end\n");
 
 
    // this is to align ramming and future wiping extrusions, so the future y-steps can be uniform from the start:
    // the perimeter_width will later be subtracted, it is there to not load while moving over just extruded material
    Vec2f pos = Vec2f(end_of_ramming.x(), end_of_ramming.y() + (y_step/m_extra_spacing_ramming-m_perimeter_width) / 2.f + m_perimeter_width);
    if (planned_ramming_depth > 0.f) {
        // Orca: restart the wipe at the left-edge boundary on a fresh row below the
        // quantized ram band so the entry scrub always runs at the wall gap (BBL keeps
        // CP_TOOLCHANGE_WIPE starting at a box corner the same way). Same lattice
        // formula as the no-ram branch below, offset by the ram band.
        writer.travel(Vec2f(ramming_start_pos.x(),
            cleaning_box.ld.y() + m_depth_traversed +
                wipe_start_offset_after_ram(planned_ramming_depth, is_first_layer()) + m_perimeter_width), 2400.f);
        m_left_to_right = true;
    }
    else if (do_ramming)
        writer.travel(pos, 2400.f);
    else {
        // Orca: with no ram printed there is no ramming geometry to align with. Start the
        // first wipe row so the purge row lattice continues across the block boundary
        // (previous box's last row top edge sits at its box top): with the planned depth
        // of rows * dy, the last row's top edge then lands exactly on this box's top and
        // no blank band is left between adjacent purge blocks.
        writer.set_position(Vec2f(end_of_ramming.x(),
            cleaning_box.ld.y() + m_depth_traversed + wipe_start_offset_after_ram(0.f, is_first_layer()) + m_perimeter_width));
    }
 
    writer.resume_preview()
          .flush_planner_queue();
}

Referenced by prime(), and tool_change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toolchange_Wipe()

void Slic3r::WipeTower2::toolchange_Wipe	(	WipeTowerWriter2 &	writer,
		const WipeTower::box_coordinates &	cleaning_box,
		float	wipe_volume,
		bool	interface_layer,
		bool	priming = false,
		bool	fill_box = false )

private

{
  // Increase flow on first layer, slow down print.
    writer.set_extrusion_flow(m_extrusion_flow * (is_first_layer() ? 1.18f : 1.f))
      .append("; CP TOOLCHANGE WIPE\n");
  const float& xl = cleaning_box.ld.x();
  const float& xr = cleaning_box.rd.x();
 
    writer.set_extrusion_flow(m_extrusion_flow * m_extra_flow);
    const float line_width = wipe_line_width();
    writer.change_analyzer_line_width(line_width);
 
  // Variables x_to_wipe and traversed_x are here to be able to make sure it always wipes at least
    //   the ordered volume, even if it means violating the box. This can later be removed and simply
    // wipe until the end of the assigned area.
 
  float x_to_wipe = volume_to_length(wipe_volume, m_perimeter_width, m_layer_height) / m_extra_flow;
  float dy = wipe_row_spacing(is_first_layer()); // Don't use the extra spacing for the first layer, but do use the spacing resulting from increased flow.
    // All the calculations in all other places take the spacing into account for all the layers.
 
  // If spare layers are excluded->if 1 or less toolchange has been done, it must be sill the first layer, too.So slow down.
    const float target_speed = is_first_layer() || (m_num_tool_changes <= 1 && m_sparse_layers_skipped) ? m_first_layer_speed * 60.f : std::min(m_wipe_tower_max_purge_speed * 60.f, m_infill_speed * 60.f);
    float wipe_speed = 0.33f * target_speed;
 
    // if there is less than 2.5*line_width to the edge, advance straightaway (there is likely a blob anyway)
    if ((m_left_to_right ? xr-writer.x() : writer.x()-xl) < 2.5f*line_width) {
        writer.travel((m_left_to_right ? xr-line_width : xl+line_width),writer.y()+dy);
        m_left_to_right = !m_left_to_right;
    }
    
    // now the wiping itself:
  for (int i = 0; true; ++i)  {
    if (i!=0) {
            if      (wipe_speed < 0.34f * target_speed) wipe_speed = 0.375f * target_speed;
            else if (wipe_speed < 0.377 * target_speed) wipe_speed = 0.458f * target_speed;
            else if (wipe_speed < 0.46f * target_speed) wipe_speed = 0.875f * target_speed;
            else wipe_speed = std::min(target_speed, wipe_speed + 50.f);
    }
 
    float traversed_x = writer.x();
 
        // BBS gap wall: iron the first few mm of the purge, then drag the retracted nozzle
        // back out through the wall gap and scrub it with a dry spiral centred on the entry
        // point so the toolchange start blob is not left on the wall (same sequence as the
        // BBL tower's toolchange_wipe_new; the spiral self-disables when the filament's
        // tower ironing area is 0). WT2's entry gap always sits at the left-edge entry
        // point, so only iron when the purge actually starts there heading right (in-place
        // toolchangers do; SEMM ram/cooling moves leave the nozzle mid-box, far from any gap).
        if (i == 0 && m_use_gap_wall && !interface_layer && !priming && m_left_to_right &&
            writer.x() - xl < 2.5f * line_width) {
            float ironing_length = 3.f;
            if (xr - writer.x() < ironing_length)
                ironing_length = std::max(xr - writer.x(), 0.f);
            const float retract_length = m_filpar[m_current_tool].retract_length;
            const float retract_speed  = m_filpar[m_current_tool].retract_speed * 60.f;
            writer.extrude(writer.x() + ironing_length, writer.y(), wipe_speed);
            writer.retract(retract_length, retract_speed);
            writer.travel(writer.x() - 1.5f * ironing_length, writer.y(), 600.f);
            writer.travel(writer.x() + 0.5f * ironing_length, writer.y(), 240.f);
            const Vec2f iron_end(writer.x() + ironing_length, writer.y());
            writer.spiral_flat_ironing(writer.pos(), m_filpar[m_current_tool].tower_ironing_area, m_perimeter_width, flat_iron_speed);
            writer.travel(iron_end, wipe_speed);
            writer.retract(-retract_length, retract_speed);
        }
 
    if (m_left_to_right)
            writer.extrude(xr - (i % 4 == 0 ? 0 : 1.5f*line_width), writer.y(), wipe_speed);
    else
            writer.extrude(xl + (i % 4 == 1 ? 0 : 1.5f*line_width), writer.y(), wipe_speed);
 
        if (writer.y()+float(EPSILON) > cleaning_box.lu.y()-0.5f*line_width)
            break;    // in case next line would not fit
 
    traversed_x -= writer.x();
        x_to_wipe -= std::abs(traversed_x);
        // Orca: with no ram printed the box was planned as whole wipe rows; fill it
        // completely (quantizing the purge up to the planned rows) so the next block
        // can start right above it without a blank band in between.
        if (!fill_box && x_to_wipe < WT_EPSILON) {
            writer.travel(m_left_to_right ? xl + 1.5f*line_width : xr - 1.5f*line_width, writer.y(), 7200);
      break;
    }
    // stepping to the next line:
        writer.extrude(writer.x() + (i % 4 == 0 ? -1.f : (i % 4 == 1 ? 1.f : 0.f)) * 1.5f*line_width, writer.y() + dy);
    m_left_to_right = !m_left_to_right;
  }
 
    // We may be going back to the model - wipe the nozzle. If this is followed
    // by finish_layer, this wipe path will be overwritten.
    writer.add_wipe_point(writer.x(), writer.y())
          .add_wipe_point(writer.x(), writer.y() - dy)
          .add_wipe_point(! m_left_to_right ? m_wipe_tower_width : 0.f, writer.y() - dy);
 
    if (m_layer_info != m_plan.end() && m_current_tool != m_layer_info->tool_changes.back().new_tool)
        m_left_to_right = !m_left_to_right;
 
    writer.set_extrusion_flow(m_extrusion_flow); // Reset the extrusion flow.
    writer.change_analyzer_line_width(m_perimeter_width);
}

Referenced by prime(), and tool_change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ use_gap_wall()

bool Slic3r::WipeTower2::use_gap_wall ( const PrintConfig & config )

static

{
    // The cone wall has its own fully separate generator with no gap machinery.
    return config.prime_tower_skip_points.value && config.wipe_tower_wall_type.value != wtwCone;
}

References Slic3r::wtwCone.

Referenced by WipeTower2(), Slic3r::WipeTowerIntegration::append_tcr2(), and Slic3r::WipeTowerIntegration::travel_to_tower_gap().

Here is the caller graph for this function:

◆ wait_for_temp_enabled()

bool Slic3r::WipeTower2::wait_for_temp_enabled ( const PrintConfig & config )

static

{
    // SEMM runs its own unload/load temperature sequence; the GUI hides the option
    // there but a profile may still carry it set.
    return config.wait_for_temp_on_wipe_tower.value && !config.single_extruder_multi_material.value;
}

Referenced by WipeTower2(), Slic3r::WipeTowerIntegration::append_tcr2(), and Slic3r::Print::invalidate_state_by_config_options().

Here is the caller graph for this function:

◆ wait_for_temp_tag()

const std::string Slic3r::WipeTower2::wait_for_temp_tag ( )

inlinestatic

34{ return ";_WAIT_FOR_TEMP_ON_WIPE_TOWER"; }

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

Here is the caller graph for this function:

◆ width()

float Slic3r::WipeTower2::width ( ) const

inline

144{ return m_wipe_tower_width; }

References m_wipe_tower_width.

Referenced by Slic3r::Print::_make_wipe_tower(), cone_base_polygon(), get_wipe_tower_cone_base(), save_on_last_wipe(), and set_toolchange().

Here is the caller graph for this function:

◆ wipe_line_width()

float Slic3r::WipeTower2::wipe_line_width ( ) const

inlineprivate

320{ return m_perimeter_width * m_extra_flow; }

References m_extra_flow, and m_perimeter_width.

Referenced by toolchange_Wipe(), and wipe_start_offset_after_ram().

Here is the caller graph for this function:

◆ wipe_row_spacing()

float Slic3r::WipeTower2::wipe_row_spacing ( bool first_layer ) const

inlineprivate

319{ return (first_layer ? m_extra_flow : m_extra_spacing_wipe) * m_perimeter_width; }

References m_extra_flow, m_extra_spacing_wipe, and m_perimeter_width.

Referenced by toolchange_Wipe(), and wipe_start_offset_after_ram().

Here is the caller graph for this function:

◆ wipe_start_offset_after_ram()

float Slic3r::WipeTower2::wipe_start_offset_after_ram	(	float	ramming_depth,
		bool	first_layer ) const

inlineprivate

    {
        return ramming_depth + wipe_row_spacing(first_layer) - (m_perimeter_width + wipe_line_width()) / 2.f;
    }

References m_perimeter_width, wipe_line_width(), and wipe_row_spacing().

Referenced by toolchange_entry_pos(), and toolchange_Unload().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ m_adhesion

bool Slic3r::WipeTower2::m_adhesion = true

private

Referenced by finish_layer(), and toolchange_Unload().

◆ m_bed_bottom_left

Vec2f Slic3r::WipeTower2::m_bed_bottom_left

private

Referenced by WipeTower2(), and prime().

◆ m_bed_polygon

Polygon Slic3r::WipeTower2::m_bed_polygon

private

Referenced by WipeTower2(), and toolchange_Change().

◆ []

enum { ... } Slic3r::WipeTower2::m_bed_shape

Referenced by WipeTower2(), and prime().

◆ m_bed_width

float Slic3r::WipeTower2::m_bed_width

private

Referenced by WipeTower2(), and prime().

◆ m_bridging

float Slic3r::WipeTower2::m_bridging = 0.f

private

Referenced by WipeTower2(), and finish_layer().

◆ m_cooling_tube_length

float Slic3r::WipeTower2::m_cooling_tube_length = 0.f

private

Referenced by WipeTower2(), and toolchange_Unload().

◆ m_cooling_tube_retraction

float Slic3r::WipeTower2::m_cooling_tube_retraction = 0.f

private

Referenced by WipeTower2(), and toolchange_Unload().

◆ m_current_height

float Slic3r::WipeTower2::m_current_height = 0.f

private

Referenced by finish_layer(), generate(), generate_support_cone_wall(), plan_tower(), and toolchange_Change().

◆ m_current_layer_finished

bool Slic3r::WipeTower2::m_current_layer_finished = false

private

Referenced by finish_layer(), layer_finished(), and set_layer().

◆ m_current_layer_has_interface

bool Slic3r::WipeTower2::m_current_layer_has_interface = false

private

Referenced by set_layer(), and tool_change().

◆ m_current_shape

wipe_shape Slic3r::WipeTower2::m_current_shape = SHAPE_NORMAL

private

Referenced by finish_layer(), set_layer(), tool_change(), and toolchange_Unload().

◆ m_current_tool

size_t Slic3r::WipeTower2::m_current_tool = 0

private

Referenced by WipeTower2(), construct_tcr(), finish_layer(), generate(), generate_support_rib_wall(), prime(), tool_change(), toolchange_Change(), toolchange_Load(), toolchange_Unload(), and toolchange_Wipe().

◆ m_depth_traversed

float Slic3r::WipeTower2::m_depth_traversed = 0.f

private

Referenced by set_layer(), tool_change(), and toolchange_Unload().

◆ m_enable_arc_fitting

bool Slic3r::WipeTower2::m_enable_arc_fitting = false

private

Referenced by WipeTower2(), finish_layer(), prime(), and tool_change().

◆ m_enable_filament_ramming

bool Slic3r::WipeTower2::m_enable_filament_ramming = true

private

Referenced by WipeTower2(), tool_ramming_enabled(), toolchange_Load(), and toolchange_Unload().

◆ m_enable_tower_interface_cooldown_during_tower

bool Slic3r::WipeTower2::m_enable_tower_interface_cooldown_during_tower = false

private

Referenced by WipeTower2(), and tool_change().

◆ m_enable_tower_interface_features

bool Slic3r::WipeTower2::m_enable_tower_interface_features = false

private

Referenced by WipeTower2(), finish_layer(), and tool_change().

◆ m_extra_flow

float Slic3r::WipeTower2::m_extra_flow = 1.f

private

Referenced by WipeTower2(), save_on_last_wipe(), set_toolchange(), toolchange_Wipe(), wipe_line_width(), and wipe_row_spacing().

◆ m_extra_loading_move

float Slic3r::WipeTower2::m_extra_loading_move = 0.f

private

Referenced by WipeTower2(), and toolchange_Load().

◆ m_extra_rib_length

float Slic3r::WipeTower2::m_extra_rib_length = 0

private

Referenced by WipeTower2(), and generate().

◆ m_extra_spacing_ramming

float Slic3r::WipeTower2::m_extra_spacing_ramming = 1.f

private

Referenced by WipeTower2(), set_toolchange(), and toolchange_Unload().

◆ m_extra_spacing_wipe

float Slic3r::WipeTower2::m_extra_spacing_wipe = 1.f

private

Referenced by WipeTower2(), save_on_last_wipe(), set_toolchange(), and wipe_row_spacing().

◆ m_extrusion_flow

float Slic3r::WipeTower2::m_extrusion_flow = 0.038f

private

Referenced by extrusion_flow(), finish_layer(), prime(), set_layer(), tool_change(), and toolchange_Wipe().

◆ m_filpar

std::vector<FilamentParameters> Slic3r::WipeTower2::m_filpar

private

Referenced by filament_area(), finish_layer(), first_toolchange_to_nonsoluble_nonsupport(), generate(), generate_support_rib_wall(), prime(), save_on_last_wipe(), set_extruder(), set_toolchange(), tool_change(), tool_ramming_enabled(), toolchange_Load(), toolchange_Unload(), and toolchange_Wipe().

◆ m_first_layer_bbx

BoundingBoxf Slic3r::WipeTower2::m_first_layer_bbx

private

Referenced by finish_layer(), and get_bbx().

◆ m_first_layer_idx

size_t Slic3r::WipeTower2::m_first_layer_idx = size_t(-1)

private

Referenced by compute_wall_skip_points(), generate(), is_first_layer(), plan_toolchange(), and save_on_last_wipe().

◆ m_first_layer_speed

float Slic3r::WipeTower2::m_first_layer_speed = 0.f

private

Referenced by WipeTower2(), finish_layer(), and toolchange_Wipe().

◆ m_gcode_flavor

GCodeFlavor Slic3r::WipeTower2::m_gcode_flavor

private

Referenced by WipeTower2(), finish_layer(), prime(), and tool_change().

◆ m_infill_speed

float Slic3r::WipeTower2::m_infill_speed = 0.f

private

Referenced by WipeTower2(), finish_layer(), and toolchange_Wipe().

◆ m_internal_rotation

float Slic3r::WipeTower2::m_internal_rotation = 0.f

private

Referenced by finish_layer(), generate(), and tool_change().

◆ m_is_mk4mmu3

bool Slic3r::WipeTower2::m_is_mk4mmu3 = false

private

Referenced by WipeTower2(), toolchange_Change(), and toolchange_Unload().

◆ m_layer_height

float Slic3r::WipeTower2::m_layer_height = 0.f

private

Referenced by construct_tcr(), finish_layer(), prime(), set_layer(), tool_change(), toolchange_Unload(), and toolchange_Wipe().

◆ m_layer_info

std::vector<WipeTowerInfo>::iterator Slic3r::WipeTower2::m_layer_info = m_plan.end()

private

Referenced by finish_layer(), generate(), generate_support_cone_wall(), generate_support_rib_wall(), is_first_layer(), save_on_last_wipe(), set_layer(), tool_change(), toolchange_Change(), toolchange_Unload(), and toolchange_Wipe().

◆ m_left_to_right

bool Slic3r::WipeTower2::m_left_to_right = true

private

Referenced by finish_layer(), prime(), toolchange_Unload(), and toolchange_Wipe().

◆ m_max_color_changes

size_t Slic3r::WipeTower2::m_max_color_changes = 0

private

Referenced by finished().

◆ m_num_layer_changes

unsigned int Slic3r::WipeTower2::m_num_layer_changes = 0

private

Referenced by finish_layer(), and set_layer().

◆ m_num_tool_changes

unsigned int Slic3r::WipeTower2::m_num_tool_changes = 0

private

Referenced by finish_layer(), get_number_of_toolchanges(), prime(), set_layer(), tool_change(), and toolchange_Wipe().

◆ m_old_temperature

int Slic3r::WipeTower2::m_old_temperature = -1

private

Referenced by generate(), prime(), and toolchange_Unload().

◆ m_parking_pos_retraction

float Slic3r::WipeTower2::m_parking_pos_retraction = 0.f

private

Referenced by WipeTower2(), toolchange_Load(), and toolchange_Unload().

◆ m_perimeter_speed

float Slic3r::WipeTower2::m_perimeter_speed = 0.f

private

Referenced by WipeTower2(), and finish_layer().

◆ m_perimeter_width

float Slic3r::WipeTower2::m_perimeter_width = 0.4f * Width_To_Nozzle_Ratio

private

Referenced by extrusion_flow(), finish_layer(), generate(), generate_support_rib_wall(), plan_tower(), prime(), save_on_last_wipe(), set_extruder(), set_toolchange(), tool_change(), toolchange_Change(), toolchange_entry_pos(), toolchange_Load(), toolchange_Unload(), toolchange_Wipe(), wipe_line_width(), wipe_row_spacing(), and wipe_start_offset_after_ram().

◆ m_plan

std::vector<WipeTowerInfo> Slic3r::WipeTower2::m_plan

private

Referenced by compute_wall_skip_points(), finish_layer(), generate(), generate_support_rib_wall(), get_z_and_depth_pairs(), is_first_layer(), plan_toolchange(), plan_tower(), save_on_last_wipe(), set_layer(), toolchange_Unload(), and toolchange_Wipe().

◆ m_prev_layer_had_interface

bool Slic3r::WipeTower2::m_prev_layer_had_interface = false

private

Referenced by finish_layer(), and set_layer().

◆ m_rib_length

float Slic3r::WipeTower2::m_rib_length = 0

private

Referenced by generate(), generate_rib_polygon(), and get_rib_length().

◆ m_rib_offset

Vec2f Slic3r::WipeTower2::m_rib_offset = Vec2f::Zero()

private

Referenced by generate_support_rib_wall(), get_rib_offset(), and toolchange_Change().

◆ m_rib_width

float Slic3r::WipeTower2::m_rib_width = 10

private

Referenced by WipeTower2(), generate(), generate_rib_polygon(), and get_rib_width().

◆ m_semm

bool Slic3r::WipeTower2::m_semm = true

private

Referenced by WipeTower2(), boundary_wipe_start_enabled(), set_extruder(), set_toolchange(), tool_ramming_enabled(), toolchange_entry_pos(), toolchange_Load(), and toolchange_Unload().

◆ m_set_extruder_trimpot

bool Slic3r::WipeTower2::m_set_extruder_trimpot = false

private

Referenced by WipeTower2(), prime(), tool_change(), and toolchange_Load().

◆ m_sparse_layers_combined

bool Slic3r::WipeTower2::m_sparse_layers_combined = false

private

Referenced by WipeTower2(), and generate().

◆ m_sparse_layers_skipped

bool Slic3r::WipeTower2::m_sparse_layers_skipped = false

private

Referenced by WipeTower2(), finish_layer(), generate_support_cone_wall(), plan_toolchange(), toolchange_Change(), and toolchange_Wipe().

◆ m_travel_speed

float Slic3r::WipeTower2::m_travel_speed = 0.f

private

Referenced by WipeTower2(), prime(), tool_change(), toolchange_Change(), and toolchange_Unload().

◆ m_use_gap_wall

bool Slic3r::WipeTower2::m_use_gap_wall = false

private

Referenced by WipeTower2(), boundary_wipe_start_enabled(), generate(), generate_support_rib_wall(), toolchange_entry_pos(), and toolchange_Wipe().

◆ m_used_filament_length

std::vector<float> Slic3r::WipeTower2::m_used_filament_length

private

Referenced by finish_layer(), generate(), get_used_filament(), prime(), set_extruder(), tool_change(), and toolchange_Change().

◆ m_used_filament_length_until_layer

std::vector<std::pair<float, std::vector<float> > > Slic3r::WipeTower2::m_used_filament_length_until_layer

private

Referenced by generate(), and get_used_filament_until_layer().

◆ m_used_fillet

bool Slic3r::WipeTower2::m_used_fillet = true

private

Referenced by WipeTower2(), and generate_support_rib_wall().

◆ m_wait_for_temp_on_wipe_tower

bool Slic3r::WipeTower2::m_wait_for_temp_on_wipe_tower = false

private

Referenced by WipeTower2(), tool_change(), and toolchange_Change().

◆ m_wall_skip_points

std::vector<std::vector<Vec2f> > Slic3r::WipeTower2::m_wall_skip_points

private

Referenced by compute_wall_skip_points(), and generate_support_rib_wall().

◆ m_wall_type

int Slic3r::WipeTower2::m_wall_type

private

Referenced by WipeTower2(), finish_layer(), generate(), and toolchange_Change().

◆ m_wipe_tower_brim_width

float Slic3r::WipeTower2::m_wipe_tower_brim_width = 0.f

private

Referenced by WipeTower2(), finish_layer(), and toolchange_Change().

◆ m_wipe_tower_brim_width_real

float Slic3r::WipeTower2::m_wipe_tower_brim_width_real = 0.f

private

Referenced by finish_layer(), get_bbx(), and get_brim_width().

◆ m_wipe_tower_cone_angle

float Slic3r::WipeTower2::m_wipe_tower_cone_angle = 0.f

private

Referenced by WipeTower2(), generate_support_cone_wall(), and toolchange_Change().

◆ m_wipe_tower_depth

float Slic3r::WipeTower2::m_wipe_tower_depth = 0.f

private

Referenced by finish_layer(), generate(), generate_rib_polygon(), generate_support_cone_wall(), get_bbx(), get_depth(), get_z_and_depth_pairs(), plan_tower(), tool_change(), and toolchange_Change().

◆ m_wipe_tower_filament

int Slic3r::WipeTower2::m_wipe_tower_filament = 0

private

Referenced by WipeTower2(), first_toolchange_to_nonsoluble_nonsupport(), and set_extruder().

◆ m_wipe_tower_height

float Slic3r::WipeTower2::m_wipe_tower_height = 0.f

private

Referenced by finish_layer(), generate(), generate_rib_polygon(), generate_support_cone_wall(), get_wipe_tower_height(), get_z_and_depth_pairs(), plan_tower(), and toolchange_Change().

◆ m_wipe_tower_max_purge_speed

float Slic3r::WipeTower2::m_wipe_tower_max_purge_speed = 90.f

private

Referenced by WipeTower2(), finish_layer(), and toolchange_Wipe().

◆ m_wipe_tower_pos

Vec2f Slic3r::WipeTower2::m_wipe_tower_pos

private

Referenced by WipeTower2(), position(), and toolchange_Change().

◆ m_wipe_tower_rotation_angle

float Slic3r::WipeTower2::m_wipe_tower_rotation_angle = 0.f

private

Referenced by WipeTower2(), and toolchange_Change().

◆ m_wipe_tower_width

float Slic3r::WipeTower2::m_wipe_tower_width

private

Referenced by WipeTower2(), finish_layer(), generate(), generate_rib_polygon(), generate_support_cone_wall(), generate_support_rib_wall(), get_bbx(), save_on_last_wipe(), set_toolchange(), tool_change(), toolchange_Change(), toolchange_Wipe(), and width().

◆ m_y_shift

float Slic3r::WipeTower2::m_y_shift = 0.f

private

Referenced by WipeTower2(), finish_layer(), generate(), generate_rib_polygon(), generate_support_rib_wall(), and tool_change().

◆ m_z_pos

float Slic3r::WipeTower2::m_z_pos = 0.f

private

Referenced by WipeTower2(), construct_tcr(), finish_layer(), generate_rib_polygon(), prime(), set_layer(), and tool_change().

◆ Width_To_Nozzle_Ratio

const float Slic3r::WipeTower2::Width_To_Nozzle_Ratio = 1.25f

private

Referenced by set_extruder().

◆ wipe_volumes

const std::vector<std::vector<float> > Slic3r::WipeTower2::wipe_volumes

private

Referenced by WipeTower2(), estimate_semm_flush_volume(), extract_wipe_volumes(), and prime().

◆ WT_EPSILON

const float Slic3r::WipeTower2::WT_EPSILON = 1e-3f

private

Referenced by finish_layer(), get_z_and_depth_pairs(), plan_toolchange(), set_layer(), toolchange_Unload(), and toolchange_Wipe().

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

/home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/WipeTower2.hpp
/home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/WipeTower2.cpp

	OrcaSlicer latest OrcaSlicer

Classes

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Class Documentation

◆ Slic3r::WipeTower2::FilamentParameters

Member Enumeration Documentation

◆ anonymous enum

◆ wipe_shape

Constructor & Destructor Documentation

◆ WipeTower2()

Member Function Documentation

◆ boundary_wipe_start_enabled()

◆ compute_wall_skip_points()

◆ cone_base_polygon()

◆ construct_tcr()

◆ estimate_semm_flush_volume()

◆ extract_wipe_volumes()

◆ extrusion_flow()

◆ filament_area()

◆ finish_layer()

◆ finished()

◆ first_toolchange_to_nonsoluble_nonsupport()

◆ generate()

◆ generate_rib_polygon()

◆ generate_support_cone_wall()

◆ generate_support_rib_wall()

◆ get_bbx()

◆ get_brim_width()

◆ get_depth()

◆ get_number_of_toolchanges()

◆ get_rib_length()

◆ get_rib_offset()

◆ get_rib_width()

◆ get_used_filament()

◆ get_used_filament_until_layer()

◆ get_wipe_tower_cone_base()

◆ get_wipe_tower_height()

◆ get_z_and_depth_pairs()

◆ is_first_layer()

◆ layer_finished()

◆ never_skip_tag()

◆ plan_toolchange()

◆ plan_tower()

◆ position()

◆ prime()

◆ save_on_last_wipe()

◆ set_extruder()

◆ set_layer()

◆ set_toolchange()

◆ tool_change()

◆ tool_ramming_enabled()

◆ toolchange_Change()

◆ toolchange_entry_pos()

◆ toolchange_Load()

◆ toolchange_Unload()

◆ toolchange_Wipe()

◆ use_gap_wall()

◆ wait_for_temp_enabled()

◆ wait_for_temp_tag()

◆ width()

◆ wipe_line_width()

◆ wipe_row_spacing()

◆ wipe_start_offset_after_ram()

Member Data Documentation

◆ m_adhesion

◆ m_bed_bottom_left

◆ m_bed_polygon

◆ []

◆ m_bed_width

◆ m_bridging

◆ m_cooling_tube_length

◆ m_cooling_tube_retraction

◆ m_current_height

◆ m_current_layer_finished

◆ m_current_layer_has_interface

◆ m_current_shape