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

Collaboration diagram for Slic3r::WipeTower:

Classes
struct	PurgeEstimate
struct	Extrusion
struct	NozzleChangeResult
struct	ToolChangeResult
struct	box_coordinates
struct	FilamentParameters
struct	WipeTowerBlock
struct	BlockDepthInfo
struct	WipeTowerInfo

Public Types
enum class	WipeTowerLayerType : unsigned char { Normal , Contact , Solid , Contact_UP }

Public Member Functions
ToolChangeResult	construct_tcr (WipeTowerWriter &writer, bool priming, size_t old_tool, bool is_finish, bool is_tool_change, float purge_volume, bool is_contact) const
ToolChangeResult	construct_block_tcr (WipeTowerWriter &writer, bool priming, size_t filament_id, bool is_finish, float purge_volume) const
	WipeTower (const PrintConfig &config, int plate_idx, Vec3d plate_origin, size_t initial_tool, const float wipe_tower_height, const std::vector< unsigned int > &slice_used_filaments)
void	set_extruder (size_t idx, const PrintConfig &config)
void	set_shared_print_bed (const Polygons &bed)
void	set_has_filament_switcher (bool v)
void	plan_toolchange (float z_par, float layer_height_par, unsigned int old_tool, unsigned int new_tool, float wipe_volume_ec=0.f, float wipe_volume_nc=0.f, float prime_volume=0.f)
void	generate (std::vector< std::vector< ToolChangeResult > > &result)
WipeTower::ToolChangeResult	only_generate_out_wall (bool is_new_mode=false)
Polygon	generate_support_wall (WipeTowerWriter &writer, const box_coordinates &wt_box, double feedrate, bool first_layer)
Polygon	generate_support_wall_new (WipeTowerWriter &writer, const box_coordinates &wt_box, double feedrate, bool first_layer, bool rib_wall, bool extrude_perimeter, bool skip_points)
Polygon	generate_rib_polygon (const box_coordinates &wt_box)
float	get_depth () const
float	get_brim_width () const
BoundingBoxf	get_bbx () const
std::map< float, Polylines >	get_outer_wall () const
float	get_height () const
float	get_layer_height () const
float	get_rib_length () const
float	get_rib_width () const
void	set_last_layer_extruder_fill (bool extruder_fill)
void	set_layer (float print_z, float layer_height, size_t max_tool_changes, bool is_first_layer, bool is_last_layer)
const Vec2f &	position () const
float	width () const
bool	finished () const
std::vector< ToolChangeResult >	prime (float initial_layer_print_height, const std::vector< unsigned int > &tools, bool last_wipe_inside_wipe_tower)
ToolChangeResult	tool_change (size_t new_tool, bool extrude_perimeter=false, bool first_toolchange_to_nonsoluble=false)
NozzleChangeResult	nozzle_change (int old_filament_id, int new_filament_id)
ToolChangeResult	finish_layer (bool extruder_perimeter=true, bool extruder_fill=true)
float	extrusion_flow (float layer_height=-1.f) const
float	nozzle_change_extrusion_flow (float layer_height=-1.f) const
bool	get_floating_area (float &start_pos_y, float &end_pos_y) const
bool	need_thick_bridge_flow (float pos_y) const
float	get_extrusion_flow () const
bool	layer_finished () const
std::vector< float >	get_used_filament () const
int	get_number_of_toolchanges () const
void	set_has_tpu_filament (bool has_tpu)
bool	has_tpu_filament () const
void	set_used_filament_ids (const std::vector< int > &used_filament_ids)
void	set_filament_categories (const std::vector< int > &filament_categories)
void	set_nozzle_group_result (const MultiNozzleUtils::LayeredNozzleGroupResult &multi_nozzle_group_result)
WipeTowerBlock *	get_block_by_category (int filament_adhesiveness_category, bool create)
void	add_depth_to_block (int filament_id, int filament_adhesiveness_category, float depth, bool is_nozzle_change=false)
int	get_filament_category (int filament_id)
void	reset_block_status ()
int	get_wall_filament_for_all_layer ()
void	generate_new (std::vector< std::vector< WipeTower::ToolChangeResult > > &result)
void	plan_tower_new ()
void	generate_wipe_tower_blocks (bool add_solid_flag)
void	update_all_layer_depth (float wipe_tower_depth)
void	set_nozzle_last_layer_id ()
void	set_first_layer_flow_ratio (const float flow_ratio)
void	set_accelerations (const std::vector< double > &normal, const std::vector< double > &first_layer_normal, const std::vector< double > &travel, const std::vector< double > &first_layer_travel)
void	calc_block_infill_gap ()
ToolChangeResult	tool_change_new (size_t new_tool, bool solid_change=false, bool solid_nozzlechange=false)
NozzleChangeResult	ramming (int old_filament_id, int new_filament_id, bool solid_change=false, bool extruder_change=true)
ToolChangeResult	finish_layer_new (bool extrude_perimeter=true, bool extrude_fill=true, bool extrude_fill_wall=true)
ToolChangeResult	finish_block (const WipeTowerBlock &block, int filament_id, bool extrude_fill=true)
ToolChangeResult	finish_block_solid (const WipeTowerBlock &block, int filament_id, bool extrude_fill=true, WipeTowerLayerType layer_type=WipeTowerLayerType::Normal)
void	toolchange_wipe_new (WipeTowerWriter &writer, const box_coordinates &cleaning_box, float wipe_length, bool solid_toolchange=false)
Vec2f	get_rib_offset () const
bool	is_need_ramming (int filament_id_1, int filament_id_2, int layer_id) const
bool	is_same_extruder (int filament_id_1, int filament_id_2, int layer_id) const
bool	is_same_nozzle (int filament_id_1, int filament_id_2, int layer_id) const
int	get_nozzle_id (int filament_id, int layer_id) const
int	get_extruder_id (int filament_id, int layer_id) const

Static Public Member Functions
static const std::string	never_skip_tag ()
static float	get_limit_depth_by_height (float max_height)
static float	get_auto_brim_by_height (float max_height)
static float	estimate_brim_real_width (float brim_width, float nozzle_diameter, float first_layer_height, bool type2)
static float	get_wrapping_detection_depth ()
static float	nozzle_change_perimeter_width (float nozzle_diameter)
static TriangleMesh	its_make_rib_tower (float width, float depth, float height, float rib_length, float rib_width, bool fillet_wall)
static TriangleMesh	its_make_rib_brim (const Polygon &brim, float layer_height)
static Polygon	rib_section (float width, float depth, float rib_length, float rib_width, bool fillet_wall)
static float	estimate_tower_blocks_depth (const std::vector< PurgeEstimate > &purges, float width, float layer_height, float nozzle_diameter, float extra_spacing)
static float	rib_footprint_side (float width, float depth, float rib_width, float extra_rib_length, float max_height)
static float	estimate_rib_tower_bbox_side (const std::vector< PurgeEstimate > &purges, float width, float layer_height, float nozzle_diameter, float extra_spacing, float rib_width, float extra_rib_length, float max_height)
static Vec2f	move_box_inside_polygon (const BoundingBox &box, const Polygons &polygons, coord_t offset=0)
static Polygon	rounding_polygon (Polygon &polygon, double rounding=2., double angle_tol=30./180. *PI)

Public Attributes
std::vector< int >	m_used_filament_ids
std::vector< int >	m_filament_categories
const MultiNozzleUtils::LayeredNozzleGroupResult *	m_multi_nozzle_group_result {nullptr}
std::vector< std::vector< BlockDepthInfo > >	m_all_layers_depth
std::vector< WipeTowerBlock >	m_wipe_tower_blocks
int	m_last_block_id
WipeTowerBlock *	m_cur_block {nullptr}

Static Public Attributes
static const std::map< float, float >	min_depth_per_height

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
bool	is_valid_last_layer (int tool, int layer_id, double layer_z) const
float	volume_to_length (float volume, float line_width, float layer_height) const
float	length_to_volume (float length, float line_width, float layer_height) const
void	plan_tower ()
bool	layer_is_printed (bool toolchanges_on_layer) const
void	make_wipe_tower_square ()
Vec2f	get_next_pos (const WipeTower::box_coordinates &cleaning_box, float wipe_length, bool solid_toolchange)
void	save_on_last_wipe ()
bool	is_tpu_filament (int filament_id) const
bool	is_petg_filament (int filament_id) const
bool	is_need_reverse_travel (int filament, bool extruder_change) const
box_coordinates	align_perimeter (const box_coordinates &perimeter_box)
void	set_for_wipe_tower_writer (WipeTowerWriter &writer)
int	first_toolchange_to_nonsoluble_nonsupport (const std::vector< WipeTowerInfo::ToolChange > &tool_changes) const
WipeTowerInfo::ToolChange	set_toolchange (int old_tool, int new_tool, float layer_height, float wipe_volume, float purge_volume, int layer_id)
void	toolchange_Unload (WipeTowerWriter &writer, const box_coordinates &cleaning_box, const std::string &current_material, const int new_temperature)
void	toolchange_Change (WipeTowerWriter &writer, const size_t new_tool, const std::string &new_material)
void	toolchange_Load (WipeTowerWriter &writer, const box_coordinates &cleaning_box)
void	toolchange_Wipe (WipeTowerWriter &writer, const box_coordinates &cleaning_box, float wipe_volume)
void	get_wall_skip_points (const WipeTowerInfo &layer, int layer_id)
void	get_all_wall_skip_points ()
ToolChangeResult	merge_tcr (ToolChangeResult &first, ToolChangeResult &second)
float	get_block_gap_width (int tool, bool is_nozzlechangle=false)

Private Attributes
const float	Width_To_Nozzle_Ratio = 1.25f
const float	WT_EPSILON = 1e-3f
int	m_slice_used_filaments = 0
int	m_wrapping_detection_layers = 0
bool	m_enable_wrapping_detection = false
bool	m_enable_timelapse_print = false
bool	m_semm = true
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_brim_width = 0.f
float	m_wipe_tower_brim_width_real = 0.f
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_first_layer_speed = 0.f
size_t	m_first_layer_idx = size_t(-1)
Vec2f	m_origin
std::vector< int >	m_last_layer_id
std::pair< std::vector< double >, std::vector< double > >	m_filaments_change_length
size_t	m_cur_layer_id
NozzleChangeResult	m_nozzle_change_result
bool	m_has_tpu_filament {false}
bool	m_is_multi_extruder {false}
bool	m_use_gap_wall {false}
bool	m_use_rib_wall {false}
float	m_rib_length =0.f
float	m_rib_width =0.f
float	m_extra_rib_length =0.f
bool	m_used_fillet {false}
Vec2f	m_rib_offset {Vec2f(0.f, 0.f)}
bool	m_tower_framework {false}
bool	m_need_reverse_travel {false}
bool	m_enable_tower_interface_features {false}
float	m_bridging = 0.f
bool	m_sparse_layers_skipped = false
bool	m_sparse_layers_combined = false
bool	m_adhesion = true
GCodeFlavor	m_gcode_flavor
bool	m_is_multiple_nozzle = false
std::vector< unsigned int >	m_normal_accels
std::vector< unsigned int >	m_first_layer_normal_accels
std::vector< unsigned int >	m_travel_accels
std::vector< unsigned int >	m_first_layer_travel_accels
unsigned int	m_max_accels
bool	m_accel_to_decel_enable
float	m_accel_to_decel_factor
bool	m_enable_arc_fitting = true
std::vector< double >	m_hotend_heating_rate
std::vector< double >	m_hotend_cooling_rate
Polygons	m_shared_print_bed
enum Slic3r::WipeTower:: { ... }	m_bed_shape
float	m_bed_width
Vec2f	m_bed_bottom_left
float	m_first_layer_flow_ratio
float	m_perimeter_width = 0.4f * Width_To_Nozzle_Ratio
float	m_nozzle_change_perimeter_width = 0.4f * Width_To_Nozzle_Ratio
float	m_extrusion_flow = 0.038f
std::unordered_map< int, std::pair< float, float > >	m_block_infill_gap_width
std::vector< FilamentParameters >	m_filpar
unsigned int	m_num_layer_changes = 0
unsigned int	m_num_tool_changes = 0
bool	m_print_brim = true
	unsigned int m_idx_tool_change_in_layer = 0; // Layer change counter in this layer. Counting up to m_max_color_changes.
wipe_shape	m_current_shape = SHAPE_NORMAL
size_t	m_current_tool = 0
float	m_depth_traversed = 0.f
bool	m_current_layer_finished = false
bool	m_left_to_right = true
float	m_extra_spacing = 1.f
float	m_tpu_fixed_spacing = 2
float	m_max_speed = 5400.f
std::vector< std::vector< Vec2f > >	m_wall_skip_points
std::map< float, Polylines >	m_outer_wall
std::vector< double >	m_printable_height
bool	m_flat_ironing =false
bool	m_contact_ironing = false
bool	m_has_filament_switcher = false
float	m_contact_speed = 20 * 60.f
std::vector< int >	m_physical_extruder_map
std::vector< WipeTowerInfo >	m_plan
std::vector< WipeTowerInfo >::iterator	m_layer_info = m_plan.end()
std::vector< float >	m_used_filament_length

Friends
class	WipeTowerWriter

Detailed Description

Class Documentation

◆ Slic3r::WipeTower::PurgeEstimate

struct Slic3r::WipeTower::PurgeEstimate

Class Members
int	category = 0
float	filament_change_length = 0.f
float	filament_diameter = 1.75f
float	prime_volume = 0.f

◆ Slic3r::WipeTower::NozzleChangeResult

struct Slic3r::WipeTower::NozzleChangeResult

Collaboration diagram for Slic3r::WipeTower::NozzleChangeResult:

Class Members
Vec2f	end_pos
string	gcode
bool	is_extruder_change {true}
Vec2f	origin_start_pos
Vec2f	start_pos
vector< Vec2f >	wipe_path

◆ Slic3r::WipeTower::FilamentParameters

struct Slic3r::WipeTower::FilamentParameters

Collaboration diagram for Slic3r::WipeTower::FilamentParameters:

Class Members
int	category
float	filament_area
float	filament_cooling_before_tower = 0.f
float	filament_petg_pre_extrusion_offset_dist = 0
float	filament_tower_interface_pre_extrusion_dist = 0
float	filament_tower_interface_pre_extrusion_length = 0
float	filament_tower_interface_print_temp
float	flat_iron_area
bool	is_soluble = false
bool	is_support = false
string	material = "PLA"
pair< float, float >	max_e_ramming_speed
float	max_e_speed = std::numeric_limits<float>::max()
float	max_layer_height = 0.f
float	nozzle_diameter
int	nozzle_temperature = 0
int	nozzle_temperature_initial_layer = 0
pair< vector< float >, vector< float > >	precool_t
pair< vector< float >, vector< float > >	precool_t_first_layer
pair< int, int >	precool_target_temp
float	ramming_line_width_multiplicator = 1.f
vector< float >	ramming_speed
float	ramming_step_multiplicator = 1.f
pair< float, float >	ramming_travel_time
float	retract_length
float	retract_speed
float	wipe_dist

◆ Slic3r::WipeTower::WipeTowerBlock

struct Slic3r::WipeTower::WipeTowerBlock

Collaboration diagram for Slic3r::WipeTower::WipeTowerBlock:

Class Members
int	block_id {0}
float	cur_depth {0}
float	depth {0}
int	filament_adhesiveness_category {0}
vector< float >	finish_depth {0}
int	last_filament_change_id {-1}
int	last_nozzle_change_id {-1}
vector< float >	layer_depths
vector< WipeTowerLayerType >	layers_type
float	start_depth {0}

◆ Slic3r::WipeTower::BlockDepthInfo

struct Slic3r::WipeTower::BlockDepthInfo

Class Members
int	category {-1}
float	depth {0}
float	nozzle_change_depth {0}

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

private

Enumerator
RectangularBed
CircularBed
CustomBed

         {
        RectangularBed,
        CircularBed,
        CustomBed
    } m_bed_shape;

◆ wipe_shape

enum Slic3r::WipeTower::wipe_shape

private

Enumerator
SHAPE_NORMAL
SHAPE_REVERSED

  {
    SHAPE_NORMAL = 1,
    SHAPE_REVERSED = -1
  };

◆ WipeTowerLayerType

enum class Slic3r::WipeTower::WipeTowerLayerType : unsigned char

strong

Enumerator
Normal
Contact
Solid
Contact_UP

417: unsigned char { Normal, Contact, Solid, Contact_UP};// Contact layer should be solid and reduce feed

Slic3r::GUI::Normal

@ Normal

Definition PrePrintChecker.hpp:15

Constructor & Destructor Documentation

◆ WipeTower()

Slic3r::WipeTower::WipeTower	(	const PrintConfig &	config,
		int	plate_idx,
		Vec3d	plate_origin,
		size_t	initial_tool,
		const float	wipe_tower_height,
		const std::vector< unsigned int > &	slice_used_filaments )

                                                                                                                                                                                          :
    m_semm(config.single_extruder_multi_material.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)),
    // BBS
    m_wipe_tower_height(wipe_tower_height),
    m_wipe_tower_rotation_angle(float(config.wipe_tower_rotation_angle)),
    m_wipe_tower_brim_width(float(config.prime_tower_brim_width)),
    m_y_shift(0.f),
    m_z_pos(0.f),
    //m_bridging(float(config.wipe_tower_bridging)),
    m_bridging(10.f),
    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_current_tool(initial_tool),
    //wipe_volumes(flush_matrix)
    m_enable_timelapse_print(config.timelapse_type.value == TimelapseType::tlSmooth),
    m_enable_wrapping_detection(config.enable_wrapping_detection),
    m_wrapping_detection_layers(config.wrapping_detection_layers.value && (config.wrapping_exclude_area.values.size() > 2)),
    m_slice_used_filaments(slice_used_filaments.size()),
    m_is_multi_extruder(config.nozzle_diameter.size() > 1),
    m_use_gap_wall(config.prime_tower_skip_points.value),
    // Orca: rib-wall options live under wipe_tower_* names and the wall type is an enum
    m_use_rib_wall(config.wipe_tower_wall_type.value == WipeTowerWallType::wtwRib),
    m_extra_rib_length((float)config.wipe_tower_extra_rib_length.value),
    m_rib_width((float)config.wipe_tower_rib_width.value),
    m_used_fillet(config.wipe_tower_fillet_wall.value),
    m_extra_spacing((float)config.prime_tower_infill_gap.value/100.f),
    m_tower_framework(config.prime_tower_enable_framework.value),
    // Orca: prime_tower_max_speed is named wipe_tower_max_purge_speed (same default/min)
    m_max_speed((float)config.wipe_tower_max_purge_speed.value*60.f),
    m_accel_to_decel_enable(config.accel_to_decel_enable.value),
    m_accel_to_decel_factor(config.accel_to_decel_factor.value),
    m_printable_height(config.extruder_printable_height.values),
    m_flat_ironing(config.prime_tower_flat_ironing.value),
    m_enable_tower_interface_features(config.enable_tower_interface_features.value),
    m_physical_extruder_map(config.physical_extruder_map.values),
    m_enable_arc_fitting(config.enable_arc_fitting.value == ArcFittingMode::Enabled)
    // Orca: has_filament_switcher is a device-set dynamic key, not a PrintConfig member;
    // it is pushed in from Print via set_has_filament_switcher() instead of read here.
{
    m_contact_speed                  = 20 * 60.f;
    m_filaments_change_length.first = config.filament_change_length.values;
    m_filaments_change_length.second = config.filament_change_length_nc.values;
    m_hotend_heating_rate            = config.hotend_heating_rate.values;
    m_hotend_cooling_rate            = config.hotend_cooling_rate.values;
    m_flat_ironing = (m_flat_ironing && m_use_gap_wall);
    // Orca: default/initial-layer/travel acceleration are object-scope options here (PrintConfig
    // members in BBS), so Print pushes the resolved columns in via set_accelerations() instead of
    // the ctor reading them from config.
    m_max_accels = config.machine_max_acceleration_extruding.values.front();
 
    // 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;
 
    // 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.
    // BBS: remove useless config
#if 0
    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;
    }
#endif
    // 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_last_layer_id.resize(config.nozzle_diameter.size(), -1);
    m_origin  = {plate_origin[0], plate_origin[1]};
    m_is_multiple_nozzle = std::any_of(config.extruder_max_nozzle_count.values.begin(), config.extruder_max_nozzle_count.values.end(), [](auto &elem) { return elem > 1; });
}

References Slic3r::accel_to_decel_enable(), Slic3r::BoundingBoxBase< PointType, APointsType >::center(), Slic3r::center(), CircularBed, CustomBed, Slic3r::enable_tower_interface_features(), Slic3r::gcode_flavor(), Slic3r::get_extruder_index(), m_accel_to_decel_enable, m_accel_to_decel_factor, m_bed_bottom_left, m_bed_shape, m_bed_width, m_bridging, m_contact_speed, m_current_tool, m_enable_arc_fitting, m_enable_timelapse_print, m_enable_tower_interface_features, m_enable_wrapping_detection, m_extra_rib_length, m_extra_spacing, m_filaments_change_length, m_first_layer_speed, m_flat_ironing, m_gcode_flavor, m_hotend_cooling_rate, m_hotend_heating_rate, m_is_multi_extruder, m_is_multiple_nozzle, m_last_layer_id, m_max_accels, m_max_speed, m_origin, m_physical_extruder_map, m_printable_height, m_rib_width, m_semm, m_slice_used_filaments, m_sparse_layers_combined, m_sparse_layers_skipped, m_tower_framework, m_travel_speed, m_use_gap_wall, m_use_rib_wall, m_used_fillet, m_wipe_tower_brim_width, m_wipe_tower_height, m_wipe_tower_pos, m_wipe_tower_rotation_angle, m_wipe_tower_width, m_wrapping_detection_layers, m_y_shift, m_z_pos, Slic3r::nozzle_diameter(), Slic3r::physical_extruder_map(), Slic3r::prime_tower_brim_width(), Slic3r::prime_tower_enable_framework(), Slic3r::prime_tower_skip_points(), RectangularBed, Slic3r::single_extruder_multi_material(), Slic3r::BoundingBoxBase< PointType, APointsType >::size(), Slic3r::tlSmooth, Slic3r::travel_speed(), 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(), Slic3r::wrapping_detection_layers(), and Slic3r::wtwRib.

Here is the call graph for this function:

Member Function Documentation

◆ add_depth_to_block()

void Slic3r::WipeTower::add_depth_to_block	(	int	filament_id,
		int	filament_adhesiveness_category,
		float	depth,
		bool	is_nozzle_change = false )

{
    std::vector<WipeTower::BlockDepthInfo> &layer_depth = m_all_layers_depth[m_cur_layer_id];
    auto iter = std::find_if(layer_depth.begin(), layer_depth.end(), [&filament_adhesiveness_category](const WipeTower::BlockDepthInfo &item) {
        return item.category == filament_adhesiveness_category;
    });
 
    if (iter != layer_depth.end()) {
        iter->depth += depth;
        if (is_nozzle_change)
            iter->nozzle_change_depth += depth;
    }
    else {
        WipeTower::BlockDepthInfo new_block;
        new_block.category = filament_adhesiveness_category;
        new_block.depth = depth;
        if (is_nozzle_change)
            new_block.nozzle_change_depth += depth;
        layer_depth.emplace_back(std::move(new_block));
    }
}

References Slic3r::WipeTower::BlockDepthInfo::category, Slic3r::WipeTower::BlockDepthInfo::depth, Slic3r::filament_adhesiveness_category(), m_all_layers_depth, m_cur_layer_id, and Slic3r::WipeTower::BlockDepthInfo::nozzle_change_depth.

Referenced by generate_wipe_tower_blocks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ align_perimeter()

WipeTower::box_coordinates Slic3r::WipeTower::align_perimeter ( const box_coordinates & perimeter_box )

private

{
    box_coordinates aligned_box = perimeter_box;
 
    float spacing = m_extra_spacing * m_perimeter_width;
    float up = perimeter_box.lu(1) - m_perimeter_width - EPSILON;
    up = align_ceil(up, spacing);
    up += m_perimeter_width;
    up = std::min(up, m_wipe_tower_depth);
 
    float down = perimeter_box.ld(1) - m_perimeter_width + EPSILON;
    down = align_floor(down, spacing);
    down += m_perimeter_width;
    down = std::max(down, -m_y_shift);
 
    aligned_box.lu(1) = aligned_box.ru(1) = up;
    aligned_box.ld(1) = aligned_box.rd(1) = down;
 
    return aligned_box;
}

References Slic3r::align_ceil(), Slic3r::align_floor(), EPSILON, Slic3r::WipeTower::box_coordinates::ld, Slic3r::WipeTower::box_coordinates::lu, m_extra_spacing, m_perimeter_width, m_wipe_tower_depth, m_y_shift, Slic3r::WipeTower::box_coordinates::rd, and Slic3r::WipeTower::box_coordinates::ru.

Referenced by finish_block(), finish_layer_new(), only_generate_out_wall(), and tool_change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calc_block_infill_gap()

void Slic3r::WipeTower::calc_block_infill_gap ( )

{
    //1.calc block infill gap width
    struct BlockInfo
    {
        bool has_ramming = false;
        bool has_reverse_travel = false;
        float depth              = 0.f;
    };
    std::unordered_map<int, BlockInfo> block_info;
    std::unordered_map<int, BlockInfo> high_block_info;
    for (int i= (int)m_plan.size()-1;i>=0;i--)
    {
        for (auto &toolchange : m_plan[i].tool_changes) {
            int new_tool =toolchange.new_tool;
            int old_tool =toolchange.old_tool;
            if (is_need_ramming(old_tool,new_tool, i)) {
                bool extruder_change = !is_same_extruder(new_tool, old_tool, i);
                block_info[m_filpar[old_tool].category].has_ramming=true;
                if (is_need_reverse_travel(old_tool, extruder_change)) block_info[m_filpar[old_tool].category].has_reverse_travel = true;
                block_info[m_filpar[old_tool].category].depth += toolchange.nozzle_change_depth;
            }
            if (!block_info.count(m_filpar[new_tool].category)) block_info.insert({m_filpar[new_tool].category,BlockInfo{}});
            block_info[m_filpar[new_tool].category].depth += toolchange.required_depth - toolchange.nozzle_change_depth;
        }
        for (auto &block : block_info) {
            if (high_block_info.count(block.first) && high_block_info[block.first].depth > block.second.depth)
                block.second.depth = high_block_info[block.first].depth;
        }
        high_block_info = block_info;
 
        for (auto &block : block_info) { block.second.depth = 0.f;}
        if (i == 0) block_info = high_block_info;
    }
    float max_depth = std::accumulate(block_info.begin(), block_info.end(), 0.f, [](float value, const std::pair<int,BlockInfo> &block) { return value + block.second.depth; });
    float height_to_depth = get_limit_depth_by_height(m_wipe_tower_height);
    float height_to_spacing = max_depth > height_to_depth ? 1.f : height_to_depth / max_depth;
 
    float spacing_ratio = m_extra_spacing - 1.f;
    float extra_width = spacing_ratio * m_perimeter_width;
    float line_gap_tol  = 2.f * m_nozzle_change_perimeter_width; //If the block's line_gap is greater than it, the block should be aligned.
    for (auto &info : block_info) {
        //case1: no ramming, it can always align
        if (!info.second.has_ramming) {
            m_block_infill_gap_width[info.first].first = m_block_infill_gap_width[info.first].second = extra_width + m_perimeter_width;
        }
        // case2: has ramming, but no reverse travel
        //
        else if (!info.second.has_reverse_travel) {
            float line_gap                              = m_nozzle_change_perimeter_width + extra_width;
            if (!m_use_rib_wall) line_gap *= height_to_spacing;
            if (line_gap < line_gap_tol) {
                m_block_infill_gap_width[info.first].first  = m_perimeter_width + extra_width;
                m_block_infill_gap_width[info.first].second = m_nozzle_change_perimeter_width + extra_width;
            } else {
                m_block_infill_gap_width[info.first].first = m_block_infill_gap_width[info.first].second = m_nozzle_change_perimeter_width + extra_width;
            }
        }
        // case 3: has ramming and reverse travel
        else {
            float extra_tpu_fix_spacing = m_tpu_fixed_spacing - 1.f;
            float line_gap = m_nozzle_change_perimeter_width + std::max(extra_tpu_fix_spacing * m_perimeter_width, extra_width);
            if (!m_use_rib_wall) line_gap = height_to_spacing * line_gap;
            if (line_gap < line_gap_tol) {
                m_block_infill_gap_width[info.first].first  = m_perimeter_width + extra_width;
                m_block_infill_gap_width[info.first].second = m_nozzle_change_perimeter_width + std::max(extra_tpu_fix_spacing * m_perimeter_width, extra_width);
            } else {
                m_block_infill_gap_width[info.first].first = m_block_infill_gap_width[info.first].second = m_nozzle_change_perimeter_width +
                                                                                                           std::max(extra_tpu_fix_spacing * m_perimeter_width, extra_width);
            }
        }
    }
 
    //2. recalculate toolchange depth
     for (int 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, toolchange.purge_volume,idx);
        }
     }
     m_extra_spacing = 1.f;
}

References get_limit_depth_by_height(), is_need_ramming(), is_need_reverse_travel(), is_same_extruder(), m_block_infill_gap_width, m_extra_spacing, m_filpar, m_nozzle_change_perimeter_width, m_perimeter_width, m_plan, m_tpu_fixed_spacing, m_use_rib_wall, m_wipe_tower_height, and set_toolchange().

Referenced by plan_tower_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ construct_block_tcr()

WipeTower::ToolChangeResult Slic3r::WipeTower::construct_block_tcr	(	WipeTowerWriter &	writer,
		bool	priming,
		size_t	filament_id,
		bool	is_finish,
		float	purge_volume ) const

{
    ToolChangeResult result;
    result.priming              = priming;
    result.initial_tool         = int(filament_id);
    result.new_tool             = int(filament_id);
    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_tool_change       = false;
    result.tool_change_start_pos = Vec2f(0, 0);
    // BBS
    result.purge_volume = purge_volume;
    return result;
}

Referenced by finish_block(), and finish_block_solid().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ construct_tcr()

WipeTower::ToolChangeResult Slic3r::WipeTower::construct_tcr	(	WipeTowerWriter &	writer,
		bool	priming,
		size_t	old_tool,
		bool	is_finish,
		bool	is_tool_change,
		float	purge_volume,
		bool	is_contact ) const

{
    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.nozzle_change_result = m_nozzle_change_result;
    result.is_tool_change       = is_tool_change;
    result.tool_change_start_pos = is_tool_change ? result.start_pos : Vec2f(0, 0);
    result.is_contact            = is_contact;
    // BBS
    result.purge_volume = purge_volume;
    return result;
}

Referenced by finish_layer_new(), only_generate_out_wall(), tool_change(), and tool_change_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ estimate_brim_real_width()

float Slic3r::WipeTower::estimate_brim_real_width	(	float	brim_width,
		float	nozzle_diameter,
		float	first_layer_height,
		bool	type2 )

static

{
    if (brim_width <= 0.f)
        return brim_width;
    const float spacing = nozzle_diameter * 1.25f - first_layer_height * float(1. - M_PI_4); // Width_To_Nozzle_Ratio
    if (spacing <= EPSILON)
        return brim_width;
    const int loops_num = int((brim_width + spacing / 2.f) / spacing);
    return loops_num * spacing + (type2 ? 0.f : spacing / 2.f);
}

References EPSILON, and Slic3r::nozzle_diameter().

Referenced by Slic3r::estimate_wipe_tower_footprint().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ estimate_rib_tower_bbox_side()

float Slic3r::WipeTower::estimate_rib_tower_bbox_side	(	const std::vector< PurgeEstimate > &	purges,
		float	width,
		float	layer_height,
		float	nozzle_diameter,
		float	extra_spacing,
		float	rib_width,
		float	extra_rib_length,
		float	max_height )

static

{
    if (purges.empty() || width < EPSILON || layer_height < EPSILON || nozzle_diameter < EPSILON)
        return 0.f;
    const float pw     = nozzle_diameter * 1.25f; // Width_To_Nozzle_Ratio
    const float square = align_ceil(std::sqrt(estimate_tower_blocks_depth(purges, width, layer_height, nozzle_diameter, extra_spacing) * width), pw);
    const float depth  = estimate_tower_blocks_depth(purges, square, layer_height, nozzle_diameter, extra_spacing);
    return rib_footprint_side(square, depth, rib_width, extra_rib_length, max_height);
}

References Slic3r::align_ceil(), EPSILON, estimate_tower_blocks_depth(), Slic3r::layer_height(), Slic3r::nozzle_diameter(), rib_footprint_side(), and width().

Referenced by Slic3r::estimate_wipe_tower_footprint().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ estimate_tower_blocks_depth()

float Slic3r::WipeTower::estimate_tower_blocks_depth	(	const std::vector< PurgeEstimate > &	purges,
		float	width,
		float	layer_height,
		float	nozzle_diameter,
		float	extra_spacing )

static

{
    if (purges.empty() || layer_height < EPSILON || nozzle_diameter < EPSILON)
        return 0.f;
    const float pw         = nozzle_diameter * 1.25f; // Width_To_Nozzle_Ratio
    const float ncpw       = nozzle_change_perimeter_width(nozzle_diameter);
    const float line_width = width - 2.f * pw;
    if (line_width <= EPSILON)
        return 0.f;
    // Line cross-section as volume_to_length() sees it; the infill gap stretches the perimeter
    // width by the configured ratio and nozzle-change lines keep their own width
    // (calc_block_infill_gap).
    auto        line_area   = [layer_height](float w) { return layer_height * (w - layer_height * float(1. - M_PI_4)); };
    const float extra_width = (extra_spacing - 1.f) * pw;
    const float gap         = pw + extra_width;
    const float nc_gap      = ncpw + extra_width;
    // A layer purges into at most (filaments - 1) targets, so a category holding every filament
    // never sees its smallest purge (the layer's first filament) in its worst layer.
    struct Block { float depth = 0.f; float min_purge = 0.f; size_t filaments = 0; };
    std::map<int, Block> blocks;
    for (const PurgeEstimate &purge : purges) {
        Block      &block       = blocks[purge.category];
        const float purge_depth = std::ceil(purge.prime_volume / line_area(pw) / line_width) * gap;
        block.min_purge         = block.filaments == 0 ? purge_depth : std::min(block.min_purge, purge_depth);
        block.depth += purge_depth;
        ++block.filaments;
        if (purge.filament_change_length > EPSILON) {
            // The leaving filament is rammed over the nozzle-change flow, again in whole lines.
            const float filament_area = float(M_PI) * purge.filament_diameter * purge.filament_diameter / 4.f;
            const float nc_length     = purge.filament_change_length * filament_area / line_area(ncpw);
            block.depth += std::ceil(nc_length / (width - ncpw - pw)) * nc_gap;
        }
    }
    float depth = pw; // plan_tower_new starts the first block one perimeter width in
    for (const auto &[category, block] : blocks)
        depth += block.filaments == purges.size() ? block.depth - block.min_purge : block.depth;
    return depth;
}

References EPSILON, filament_area(), Slic3r::layer_height(), M_PI, nozzle_change_perimeter_width(), Slic3r::nozzle_diameter(), and width().

Referenced by estimate_rib_tower_bbox_side(), and Slic3r::estimate_wipe_tower_footprint().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extrusion_flow()

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

inline

    {
        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 finish_block_solid(), Slic3r::WipeTowerWriter::line(), Slic3r::WipeTowerWriter::rectangle_fill_box(), set_layer(), tool_change(), toolchange_Wipe(), and toolchange_wipe_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ filament_area()

float Slic3r::WipeTower::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 estimate_tower_blocks_depth(), extrusion_flow(), nozzle_change_extrusion_flow(), set_extruder(), and toolchange_Unload().

Here is the caller graph for this function:

◆ finish_block()

WipeTower::ToolChangeResult Slic3r::WipeTower::finish_block	(	const WipeTowerBlock &	block,
		int	filament_id,
		bool	extrude_fill = true )

{
    WipeTowerWriter 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(filament_id)
        .set_y_shift(m_y_shift - (m_current_shape == SHAPE_REVERSED ? m_layer_info->toolchanges_depth() : 0.f));
 
    set_for_wipe_tower_writer(writer);
 
    writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Wipe_Tower_Start) + "\n");
 
    // Slow down on the 1st layer.
    bool first_layer = is_first_layer();
    // BBS: speed up perimeter speed to 90mm/s for non-first layer
    float feedrate = first_layer ? std::min(m_first_layer_speed * 60.f, m_max_speed) : std::min(60.0f * m_filpar[filament_id].max_e_speed / m_extrusion_flow, m_max_speed);
 
    box_coordinates fill_box(Vec2f(0, 0), 0, 0);
    fill_box = box_coordinates(Vec2f(m_perimeter_width, block.cur_depth), m_wipe_tower_width - 2 * m_perimeter_width, block.start_depth + block.layer_depths[m_cur_layer_id] - block.cur_depth - m_perimeter_width);
 
    writer.set_initial_position((m_left_to_right ? fill_box.ru : fill_box.lu), m_wipe_tower_width, m_wipe_tower_depth, m_internal_rotation);
 
    bool toolchanges_on_layer = m_layer_info->toolchanges_depth() > WT_EPSILON;
 
    std::vector<Vec2f> finish_rect_wipe_path;
    // inner perimeter of the sparse section, if there is space for it:
    if (fill_box.ru.y() - fill_box.rd.y() > WT_EPSILON) {
        writer.rectangle_fill_box(this, fill_box, finish_rect_wipe_path, feedrate);
    }
 
    // 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 (extrude_fill && 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());
            }
            finish_rect_wipe_path.clear();
            // BBS: add wipe_path for this case: only with finish rectangle
            finish_rect_wipe_path.emplace_back(writer.pos());
            finish_rect_wipe_path.emplace_back(Vec2f(left + dx * n, n % 2 ? fill_box.ru.y() : fill_box.rd.y()));
        }
 
        writer.append("; CP EMPTY GRID END\n"
                      ";------------------\n\n\n\n\n\n\n");
    }
 
    // outer perimeter (always):
    // BBS
    box_coordinates wt_box(Vec2f(0.f, 0.f), m_wipe_tower_width, m_layer_info->depth + m_perimeter_width);
    wt_box = align_perimeter(wt_box);
 
    // Now prepare future wipe. box contains rectangle that was extruded last (ccw).
    Vec2f target = (writer.pos() == wt_box.ld ? wt_box.rd : (writer.pos() == wt_box.rd ? wt_box.ru : (writer.pos() == wt_box.ru ? wt_box.lu : wt_box.ld)));
 
    // BBS: add wipe_path for this case: only with finish rectangle
    if (finish_rect_wipe_path.size() == 2 && finish_rect_wipe_path[0] == writer.pos()) target = finish_rect_wipe_path[1];
 
    writer.add_wipe_point(writer.pos()).add_wipe_point(target);
 
    writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Wipe_Tower_End) + "\n");
 
    // 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.
    if (layer_is_printed(toolchanges_on_layer))
        if (filament_id < m_used_filament_length.size())
            m_used_filament_length[filament_id] += writer.get_and_reset_used_filament_length();
 
    return construct_block_tcr(writer, false, filament_id, true, 0.f);
}

Referenced by generate_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finish_block_solid()

WipeTower::ToolChangeResult Slic3r::WipeTower::finish_block_solid	(	const WipeTowerBlock &	block,
		int	filament_id,
		bool	extrude_fill = true,
		WipeTowerLayerType	layer_type = WipeTowerLayerType::Normal )

{
    float layer_height = m_layer_height;
    float e_flow = m_extrusion_flow;
    if (m_cur_layer_id > 1 && block.layers_type[m_cur_layer_id - 1]==WipeTowerLayerType::Normal && m_extrusion_flow < extrusion_flow(0.2)) {
        layer_height = 0.2;
        e_flow = extrusion_flow(0.2);
    }
 
    WipeTowerWriter writer(layer_height, m_perimeter_width, m_gcode_flavor, m_filpar, m_enable_arc_fitting);
    writer.set_extrusion_flow(e_flow)
        .set_z(m_z_pos)
        .set_initial_tool(filament_id)
        .set_y_shift(m_y_shift - (m_current_shape == SHAPE_REVERSED ? m_layer_info->toolchanges_depth() : 0.f));
 
    set_for_wipe_tower_writer(writer);
 
    writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Wipe_Tower_Start) + "\n");
 
    // Slow down on the 1st layer.
    bool first_layer = is_first_layer();
    // BBS: speed up perimeter speed to 90mm/s for non-first layer
    float feedrate = first_layer ? std::min(m_first_layer_speed * 60.f, m_max_speed) : std::min(60.0f * m_filpar[filament_id].max_e_speed / m_extrusion_flow, m_max_speed);
    feedrate       = (layer_type == WipeTowerLayerType::Contact || layer_type == WipeTowerLayerType::Contact_UP) ? 20.f * 60.f : feedrate;
    box_coordinates fill_box(Vec2f(0, 0), 0, 0);
    fill_box = box_coordinates(Vec2f(m_perimeter_width, block.cur_depth), m_wipe_tower_width - 2 * m_perimeter_width,
                               block.start_depth + block.layer_depths[m_cur_layer_id] - block.cur_depth - m_perimeter_width);
    bool toolchanges_on_layer = m_layer_info->toolchanges_depth() > WT_EPSILON;
    const float dy                   = (fill_box.lu.y() - fill_box.ld.y());
    int   n                    = (dy + 0.25 * m_perimeter_width) / m_perimeter_width+1;
    float spacing              = m_perimeter_width;
    Vec2f initial_pos(0, 0);
    bool        up_to_down = false;
    //set initial pos 
    {
        int   index      = m_cur_layer_id % 4;
        float gird_depth = spacing * (n-1);
        switch (index % 4) {
        case 0:
            initial_pos = fill_box.ld;
            m_left_to_right = true;
            up_to_down      = false;
            break;
        case 1:
            initial_pos     = Vec2f(fill_box.rd.x(), fill_box.rd.y() + gird_depth);
            m_left_to_right = false;
            up_to_down      = true;
            break;
        case 2:
            initial_pos     = fill_box.rd;
            m_left_to_right = false;
            up_to_down      = false;
            break;
        case 3:
            initial_pos     = Vec2f(fill_box.ld.x(), gird_depth + fill_box.ld.y());
            m_left_to_right = true;
            up_to_down      = true;
            break;
        default: break;
        }
    }
    // Extrude infill to support the material to be printed above.
    float              left  = fill_box.lu.x();
    float              right = fill_box.ru.x();
    std::vector<Vec2f> finish_rect_wipe_path;
    {
        writer
            .append(";--------------------\n"
                    "; CP EMPTY GRID START\n")
            .comment_with_value(" layer #", m_num_layer_changes + 1);
        bool is_full_block = std::abs(block.cur_depth - block.start_depth) < EPSILON;
        if (is_full_block && layer_type == WipeTowerLayerType::Contact && m_enable_tower_interface_features ) {
            Vec2f        stop_pos                                    = initial_pos;
            float        filament_tower_interface_pre_extrusion_dist = m_filpar[m_current_tool].filament_tower_interface_pre_extrusion_dist;
            // Orca: unscaled(BoundingBox) here is a template returning BoundingBoxBase<Vec2d>, not BoundingBoxf
            auto         printer_bbx                                 = unscaled(get_extents(m_shared_print_bed));
            printer_bbx.translate((- m_wipe_tower_pos - m_rib_offset).cast<double>()); // first layer never be contact
            if (stop_pos.x() < m_wipe_tower_width/2.f)
                stop_pos = Vec2f(stop_pos.x() - filament_tower_interface_pre_extrusion_dist, stop_pos.y());
            else
                stop_pos = Vec2f(stop_pos.x() + filament_tower_interface_pre_extrusion_dist, stop_pos.y());
            if (stop_pos.x() < printer_bbx.min[0]) stop_pos.x() = printer_bbx.min[0];
            if (stop_pos.x() > printer_bbx.max[0]) stop_pos.x() = printer_bbx.max[0];
            initial_pos = stop_pos;
            if (m_filpar[m_current_tool].filament_tower_interface_print_temp != m_filpar[m_current_tool].nozzle_temperature)
                writer.format_line_M109(m_filpar[m_current_tool].filament_tower_interface_print_temp, get_extruder_id(m_current_tool, m_cur_layer_id));
                writer.retract(-m_filpar[m_current_tool].filament_tower_interface_pre_extrusion_length - 2.f, 100.f);
        }
        writer.set_initial_position(initial_pos, m_wipe_tower_width, m_wipe_tower_depth, m_internal_rotation);
 
        int   i             = 0;
        for (i = 0; i < n; ++i) {
            writer.extrude(m_left_to_right ? right : left, writer.y(), feedrate);
            if (i == n - 1) {
                writer.add_wipe_point(writer.pos()).add_wipe_point(Vec2f(m_left_to_right ? left : right, writer.y()));
                break;
            }
            m_left_to_right = !m_left_to_right;
            writer.extrude(writer.x(), writer.y()+spacing*(up_to_down?-1:1), feedrate);
        }
        if (layer_type == WipeTowerLayerType::Contact && m_enable_tower_interface_features && m_filpar[m_current_tool].filament_tower_interface_print_temp != m_filpar[m_current_tool].nozzle_temperature)
            writer.format_line_M104(m_filpar[m_current_tool].nozzle_temperature, get_extruder_id(m_current_tool, m_cur_layer_id));
        writer.append("; CP EMPTY GRID END\n"
                      ";------------------\n\n\n\n\n\n\n");
    }
 
    writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Wipe_Tower_End) + "\n");
 
    // 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.
    if (layer_is_printed(toolchanges_on_layer))
        if (filament_id < m_used_filament_length.size())
            m_used_filament_length[filament_id] += writer.get_and_reset_used_filament_length();
 
    return construct_block_tcr(writer, false, filament_id, true, 0.f);
}

Referenced by generate_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finish_layer()

ToolChangeResult Slic3r::WipeTower::finish_layer	(	bool	extruder_perimeter = true,
		bool	extruder_fill = true )

◆ finish_layer_new()

WipeTower::ToolChangeResult Slic3r::WipeTower::finish_layer_new	(	bool	extrude_perimeter = true,
		bool	extrude_fill = true,
		bool	extrude_fill_wall = true )

{
    assert(!this->layer_finished());
    m_current_layer_finished = true;
 
    WipeTowerWriter 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));
 
    set_for_wipe_tower_writer(writer);
 
    writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Wipe_Tower_Start) + "\n");
 
    // Slow down on the 1st layer.
    bool first_layer = is_first_layer();
    // BBS: speed up perimeter speed to 90mm/s for non-first layer
    float feedrate = first_layer ? std::min(m_first_layer_speed * 60.f, m_max_speed) : std::min(60.0f * m_filpar[m_current_tool].max_e_speed / m_extrusion_flow, m_max_speed);
 
    bool toolchanges_on_layer = m_layer_info->toolchanges_depth() > WT_EPSILON;
 
    std::vector<Vec2f> finish_rect_wipe_path;
    const bool         multi_block_fill = (m_wipe_tower_blocks.size() > 1) && (extrude_fill_wall || extrude_fill);
 
    // Build list of fill boxes: one per block when multi_block_fill, else one for whole tower.
    std::vector<box_coordinates> fill_boxes;
    if (multi_block_fill) {
        for (const WipeTowerBlock &block : m_wipe_tower_blocks) {
            float block_fill_height = block.depth - 2 * m_perimeter_width;
            if (m_cur_layer_id >= 0 && size_t(m_cur_layer_id) < block.layer_depths.size())
                block_fill_height = block.layer_depths[m_cur_layer_id] - 2 * m_perimeter_width;
            if (block_fill_height <= WT_EPSILON)
                continue;
            fill_boxes.emplace_back(
                Vec2f(m_perimeter_width, block.start_depth + m_perimeter_width),
                m_wipe_tower_width - 2 * m_perimeter_width,
                block_fill_height);
        }
    }
    if (fill_boxes.empty()) {
        float fill_box_depth = m_wipe_tower_depth - 2 * m_perimeter_width;
        if (m_wipe_tower_blocks.size() == 1)
            fill_box_depth = m_layer_info->depth - 2 * m_perimeter_width;
        fill_boxes.emplace_back(Vec2f(m_perimeter_width, m_perimeter_width), m_wipe_tower_width - 2 * m_perimeter_width, fill_box_depth);
    }
 
    writer.set_initial_position((m_left_to_right ? fill_boxes.front().ru : fill_boxes.front().lu), m_wipe_tower_width, m_wipe_tower_depth, m_internal_rotation);
 
    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;
 
    for (size_t i = 0; i < fill_boxes.size(); ++i) {
        const box_coordinates &fill_box = fill_boxes[i];
        if (i > 0)
            writer.travel(m_left_to_right ? fill_box.ru : fill_box.lu);
 
        if (extrude_fill_wall && (fill_box.ru.y() - fill_box.rd.y() > WT_EPSILON))
            writer.rectangle_fill_box(this, fill_box, finish_rect_wipe_path, feedrate);
        // 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 (extrude_fill && 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);
 
            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());
                }
 
                finish_rect_wipe_path.clear();
                // BBS: add wipe_path for this case: only with finish rectangle
                finish_rect_wipe_path.emplace_back(writer.pos());
                finish_rect_wipe_path.emplace_back(Vec2f(left + dx * n, n % 2 ? fill_box.ru.y() : fill_box.rd.y()));
            }
 
            writer.append("; CP EMPTY GRID END\n"
                          ";------------------\n\n\n\n\n\n\n");
        }
    }
 
    // outer perimeter (always):
    // BBS
    float wipe_tower_depth = m_wipe_tower_depth;
    if (m_wipe_tower_blocks.size() == 1) {
        wipe_tower_depth = m_layer_info->depth + m_perimeter_width;
    }
    box_coordinates wt_box(Vec2f(0.f, 0.f), m_wipe_tower_width, wipe_tower_depth);
    wt_box = align_perimeter(wt_box);
 
    //if (extrude_perimeter && !m_use_rib_wall) {
    //    if (!m_use_gap_wall)
    //        writer.rectangle(wt_box, feedrate);
    //    else
    //        generate_support_wall(writer, wt_box, feedrate, first_layer);
    //}
    Polygon outer_wall;
    outer_wall = generate_support_wall_new(writer, wt_box, feedrate, first_layer, m_use_rib_wall, extrude_perimeter, m_use_gap_wall);
    if (extrude_perimeter) {
        Polyline shift_polyline = to_polyline(outer_wall);
        shift_polyline.translate(0, scaled(m_y_shift));
        m_outer_wall[m_z_pos].push_back(shift_polyline);
    }
    // brim chamfer
    float spacing = m_perimeter_width - m_layer_height * float(1. - M_PI_4);
    // How many perimeters shall the brim have?
    int loops_num = (m_wipe_tower_brim_width + spacing / 2.f) / spacing;
    const float max_chamfer_width = 3.f;
    if (!first_layer) {
        // stop print chamfer if depth changes
        if (m_layer_info->depth != m_plan.front().depth) {
            loops_num = 0;
        } else {
            // limit max chamfer width to 3 mm
            int chamfer_loops_num = (int) (max_chamfer_width / spacing);
            int dist_to_1st       = m_layer_info - m_plan.begin() - m_first_layer_idx;
            loops_num             = std::min(loops_num, chamfer_loops_num) - dist_to_1st;
        }
    }
 
    if (loops_num > 0) {
        //box_coordinates box = wt_box;
        for (size_t i = 0; i < loops_num; ++i) {
            outer_wall = offset(outer_wall, scaled(spacing)).front();
            writer.polygon(outer_wall, feedrate);
            m_outer_wall[m_z_pos].push_back(to_polyline(outer_wall));
        }
 
            /*for (size_t i = 0; i < loops_num; ++i) {
                box.expand(spacing);
                writer.rectangle(box, feedrate);
            }*/
 
        if (first_layer) {
            // 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 + spacing / 2.f;
            //m_wipe_tower_brim_width_real = wt_box.ld.x() - box.ld.x() + spacing / 2.f;
        }
        //wt_box = box;
    }
 
    if (extrude_perimeter || loops_num > 0) {
        writer.add_wipe_path(outer_wall, m_filpar[m_current_tool].wipe_dist);
    }
    else {
        // Now prepare future wipe. box contains rectangle that was extruded last (ccw).
        Vec2f target = (writer.pos() == wt_box.ld ? wt_box.rd : (writer.pos() == wt_box.rd ? wt_box.ru : (writer.pos() == wt_box.ru ? wt_box.lu : wt_box.ld)));
 
        // BBS: add wipe_path for this case: only with finish rectangle
        if (finish_rect_wipe_path.size() == 2 && finish_rect_wipe_path[0] == writer.pos()) target = finish_rect_wipe_path[1];
 
        writer.add_wipe_point(writer.pos()).add_wipe_point(target);
    }
    writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Wipe_Tower_End) + "\n");
 
    // 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.
    if (layer_is_printed(toolchanges_on_layer))
        if (m_current_tool < m_used_filament_length.size())
            m_used_filament_length[m_current_tool] += writer.get_and_reset_used_filament_length();
 
    m_nozzle_change_result.gcode.clear();
    return construct_tcr(writer, false, m_current_tool, true, false, 0.f,false);
}

Referenced by generate_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finished()

bool Slic3r::WipeTower::finished ( ) const

inline

317{ return m_max_color_changes == 0; }

Slic3r::WipeTower::m_max_color_changes

size_t m_max_color_changes

Definition WipeTower.hpp:508

References m_max_color_changes.

◆ first_toolchange_to_nonsoluble_nonsupport()

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

private

{
    for (size_t idx=0; idx<tool_changes.size(); ++idx)
        if (! m_filpar[tool_changes[idx].new_tool].is_soluble && ! m_filpar[tool_changes[idx].new_tool].is_support)
            return idx;
    return -1;
}

References Slic3r::is_support(), and m_filpar.

Here is the call graph for this function:

◆ generate()

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

References WipeTowerWriter.

Here is the call graph for this function:

◆ generate_new()

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

{
    if (m_plan.empty())
        return;
    //m_extra_spacing = 1.f;
    // 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);
    m_wipe_tower_height = m_plan.back().z;//real wipe_tower_height
    plan_tower_new();
    m_layer_info = m_plan.begin();
 
    for (const auto &layer : m_plan) {
        if (!layer.tool_changes.empty()) {
            m_current_tool = layer.tool_changes.front().old_tool;
            break;
        }
    }
 
    for (auto &used : m_used_filament_length) // reset used filament stats
        used = 0.f;
 
    int wall_filament = get_wall_filament_for_all_layer();
 
    std::vector<WipeTower::ToolChangeResult> layer_result;
    int index = 0;
    for (auto layer : m_plan) {
        reset_block_status();
        m_cur_layer_id = index++;
        set_layer(layer.z, layer.height, 0, false, layer.z == m_plan.back().z);
        if (m_layer_info->depth < m_perimeter_width) continue;
        if (m_wipe_tower_blocks.size() == 1) {
            if (m_layer_info->depth < m_wipe_tower_depth - m_perimeter_width) {
                // align y shift to perimeter width
                float dy  = m_extra_spacing * m_perimeter_width;
                m_y_shift = (m_wipe_tower_depth - m_layer_info->depth) / 2.f;
                m_y_shift = align_round(m_y_shift, dy);
            }
        }
 
        //get_wall_skip_points(layer);
 
        ToolChangeResult finish_layer_tcr;
        ToolChangeResult timelapse_wall;
 
        auto get_wall_filament_for_this_layer = [this, &layer, &wall_filament]() -> int {
            if (layer.tool_changes.size() == 0)
                return -1;
 
            if (wall_filament < 0)
                return layer.tool_changes[0].new_tool;
 
            int candidate_id = -1;
            for (size_t idx = 0; idx < layer.tool_changes.size(); ++idx) {
                if (idx == 0) {
                    if (layer.tool_changes[idx].old_tool == wall_filament && is_valid_last_layer(layer.tool_changes[idx].old_tool, this->m_cur_layer_id, layer.z))
                        return wall_filament;
                    else if (m_filpar[layer.tool_changes[idx].old_tool].category == m_filpar[wall_filament].category &&
                             is_valid_last_layer(layer.tool_changes[idx].old_tool, this->m_cur_layer_id, layer.z)) {
                        candidate_id = layer.tool_changes[idx].old_tool;
                    }
                }
                if (layer.tool_changes[idx].new_tool == wall_filament) {
                    return wall_filament;
                }
 
                if ((candidate_id == -1) && (m_filpar[layer.tool_changes[idx].new_tool].category == m_filpar[wall_filament].category))
                    candidate_id = layer.tool_changes[idx].new_tool;
            }
            return candidate_id == -1 ? layer.tool_changes[0].new_tool : candidate_id;
        };
        int wall_idx = get_wall_filament_for_this_layer();
 
        bool only_generate_wall = m_enable_timelapse_print || (m_enable_wrapping_detection && m_slice_used_filaments <= 1);
        // this layer has no tool_change
        if (wall_idx == -1) {
            bool need_insert_solid_infill = false;
            for (const WipeTowerBlock &block : m_wipe_tower_blocks) {
                if (block.layers_type[m_cur_layer_id] != WipeTowerLayerType::Normal) {
                    need_insert_solid_infill = true;
                    break;
                }
            }
 
            if (need_insert_solid_infill) {
                wall_idx = m_current_tool;
            } else {
                if (only_generate_wall) {
                    timelapse_wall = only_generate_out_wall(true);
                }
                finish_layer_tcr = finish_layer_new(only_generate_wall ? false : true, layer.extruder_fill);
                std::for_each(m_wipe_tower_blocks.begin(), m_wipe_tower_blocks.end(), [this](WipeTowerBlock &block) {
                    block.finish_depth[this->m_cur_layer_id] = block.start_depth;
                });
            }
        }
 
        // generate tool change
        bool insert_wall = false;
        int  insert_finish_layer_idx = -1;
        if (wall_idx != -1 && only_generate_wall) {
            timelapse_wall = only_generate_out_wall(true);
        }
        for (int i = 0; i < int(layer.tool_changes.size()); ++i) {
            ToolChangeResult wall_gcode;
            if (i == 0 && (layer.tool_changes[i].old_tool == wall_idx)) {
                finish_layer_tcr = finish_layer_new(only_generate_wall ? false : true, false, false);
            }
            bool        solid_nozzlechange = false, solid_toolchange = false;
            const auto * block = get_block_by_category(m_filpar[layer.tool_changes[i].new_tool].category, false);
            if (block) solid_toolchange = block->layers_type[m_cur_layer_id] == WipeTowerLayerType::Contact;
 
            const auto * block2 = get_block_by_category(m_filpar[layer.tool_changes[i].old_tool].category, false);
            if(block2) solid_nozzlechange = block2->layers_type[m_cur_layer_id] == WipeTowerLayerType::Contact;
            layer_result.emplace_back(tool_change_new(layer.tool_changes[i].new_tool, solid_toolchange,solid_nozzlechange));
 
            if (i == 0 && (layer.tool_changes[i].old_tool == wall_idx)) {
 
            }
            else if (layer.tool_changes[i].new_tool == wall_idx) {
                finish_layer_tcr = finish_layer_new(only_generate_wall ? false : true, false, false);
                insert_finish_layer_idx = i;
            }
        }
 
        // insert finish block
        if (wall_idx != -1) {
            if (layer.tool_changes.empty()) {
                finish_layer_tcr = finish_layer_new(only_generate_wall ? false : true, false, false);
            }
 
            for (WipeTowerBlock& block : m_wipe_tower_blocks) {
                block.finish_depth[m_cur_layer_id] = block.start_depth + block.depth;
                if (block.cur_depth + EPSILON >= block.start_depth + block.layer_depths[m_cur_layer_id]-m_perimeter_width) {
                    continue;
                }
                int id = std::find_if(m_wipe_tower_blocks.begin(), m_wipe_tower_blocks.end(), [&](const WipeTowerBlock &b) { return &b == &block; }) - m_wipe_tower_blocks.begin();
                bool block_solid = block.layers_type[m_cur_layer_id] == WipeTowerLayerType::Contact || block.layers_type[m_cur_layer_id] == WipeTowerLayerType::Contact_UP ||
                                   block.layers_type[m_cur_layer_id] == WipeTowerLayerType::Solid;
                int finish_layer_filament = -1;
                if (block.last_filament_change_id != -1) {
                    finish_layer_filament = block.last_filament_change_id;
                } else if (block.last_nozzle_change_id != -1) {
                    finish_layer_filament = block.last_nozzle_change_id;
                }
 
                if (!layer.tool_changes.empty()) {
                    WipeTowerBlock * last_layer_finish_block = get_block_by_category(get_filament_category(layer.tool_changes.front().old_tool), false);
                    if (last_layer_finish_block && last_layer_finish_block->block_id == block.block_id && finish_layer_filament == -1)
                        finish_layer_filament = layer.tool_changes.front().old_tool;
                }
 
                if (finish_layer_filament == -1) {
                    finish_layer_filament = wall_idx;
                }
                // Cancel the block of the last layer
                if (!is_valid_last_layer(finish_layer_filament, m_cur_layer_id, layer.z)) continue;
                ToolChangeResult finish_block_tcr;
                if (block_solid) {
                    finish_block_tcr = finish_block_solid(block, finish_layer_filament, layer.extruder_fill, block.layers_type[m_cur_layer_id]);
                    block.finish_depth[m_cur_layer_id] = block.start_depth + block.depth;
                }
                else {
                    finish_block_tcr = finish_block(block, finish_layer_filament, layer.extruder_fill);
                    block.finish_depth[m_cur_layer_id] = block.cur_depth;
                }
 
                bool has_inserted = false;
                {
                    auto fc_iter = std::find_if(layer_result.begin(), layer_result.end(),
                                                [&finish_layer_filament](const WipeTower::ToolChangeResult &item) { return item.new_tool == finish_layer_filament; });
                    if (fc_iter != layer_result.end()) {
                        *fc_iter = merge_tcr(*fc_iter, finish_block_tcr);
                        has_inserted = true;
                    }
                }
 
                if (block.last_filament_change_id == -1 && !has_inserted) {
                    auto nc_iter = std::find_if(layer_result.begin(), layer_result.end(),
                                                [&finish_layer_filament](const WipeTower::ToolChangeResult &item) { return item.initial_tool == finish_layer_filament; });
                    if (nc_iter != layer_result.end()) {
                        *nc_iter = merge_tcr(finish_block_tcr, *nc_iter);
                        has_inserted = true;
                    }
                }
 
                if (!has_inserted && !finish_block_tcr.gcode.empty())
                    finish_layer_tcr = merge_tcr(finish_layer_tcr, finish_block_tcr);
            }
        }
        // record the contact layers of different categories
        if (layer_result.empty()) {
            // there is nothing to merge finish_layer with
            layer_result.emplace_back(std::move(finish_layer_tcr));
        }
        else if (is_valid_gcode(finish_layer_tcr.gcode)) {
            if (insert_finish_layer_idx == -1)
                layer_result[0] = merge_tcr(finish_layer_tcr, layer_result[0]);
            else
                layer_result[insert_finish_layer_idx] = merge_tcr(layer_result[insert_finish_layer_idx], finish_layer_tcr);
        }
 
        if (only_generate_wall && !timelapse_wall.gcode.empty()) {
            layer_result.insert(layer_result.begin(), std::move(timelapse_wall));
        }
        if (layer.combined_away)
            for (WipeTower::ToolChangeResult &tcr : layer_result)
                tcr.combined_away = true;
        result.emplace_back(std::move(layer_result));
    }
    assert(m_outer_wall.size() == m_plan.size());
}

References Slic3r::align_round(), Slic3r::WipeTower::WipeTowerBlock::block_id, Slic3r::combine_sparse_wipe_tower_plan(), Contact, Contact_UP, EPSILON, finish_block(), finish_block_solid(), finish_layer_new(), Slic3r::WipeTower::ToolChangeResult::gcode, get_block_by_category(), get_filament_category(), get_wall_filament_for_all_layer(), Slic3r::is_valid_gcode(), is_valid_last_layer(), m_cur_layer_id, m_current_tool, m_enable_timelapse_print, m_enable_wrapping_detection, m_extra_spacing, m_filpar, m_first_layer_idx, m_layer_info, m_outer_wall, m_perimeter_width, m_plan, m_slice_used_filaments, m_sparse_layers_combined, m_used_filament_length, m_wipe_tower_blocks, m_wipe_tower_depth, m_wipe_tower_height, m_y_shift, merge_tcr(), Normal, only_generate_out_wall(), plan_tower_new(), reset_block_status(), set_layer(), Solid, and tool_change_new().

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::WipeTower::generate_rib_polygon ( const box_coordinates & wt_box )

{
    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_wall_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_support_wall()

Polygon Slic3r::WipeTower::generate_support_wall	(	WipeTowerWriter &	writer,
		const box_coordinates &	wt_box,
		double	feedrate,
		bool	first_layer )

{
    float retract_length = m_filpar[m_current_tool].retract_length;
    float retract_speed  = m_filpar[m_current_tool].retract_speed *60 ;
    bool is_left  = false;
    bool is_right = false;
    for (auto pt : m_wall_skip_points[m_cur_layer_id]) {
        if (abs(pt.x()) < EPSILON) {
            is_left = true;
        } else if (abs(pt.x() - m_wipe_tower_width) < EPSILON) {
            is_right = true;
        }
    }
 
    if (is_left && is_right) {
        Vec2f *p = nullptr;
        p->x();
    }
 
    if (!is_left && !is_right) {
        Vec2f *p = nullptr;
        p->x();
    }
 
    //  3 -------------  2
    //    |           |
    //    |           |
    //  0 -------------  1
 
    int   index   = 0;
    Vec2f cur_pos = writer.pos();
    if (abs(cur_pos.x() - wt_box.ld.x()) > abs(cur_pos.x() - wt_box.rd.x())) {
        if (abs(cur_pos.y() - wt_box.ld.y()) > abs(cur_pos.y() - wt_box.lu.y())) {
            index = 2;
        } else {
            index = 1;
        }
    } else {
        if (abs(cur_pos.y() - wt_box.ld.y()) > abs(cur_pos.y() - wt_box.lu.y())) {
            index = 3;
        } else {
            index = 0;
        }
    }
 
    std::vector<Vec2f> points;
    points.emplace_back(wt_box.ld);
    points.emplace_back(wt_box.rd);
    points.emplace_back(wt_box.ru);
    points.emplace_back(wt_box.lu);
 
    writer.travel(points[index]);
    int extruded_nums = 0;
    while (extruded_nums < 4) {
        index = (index + 1) % 4;
        if (index == 2) {
            if (is_right) {
                std::vector<Segment> break_segments = remove_points_from_segment(Segment(wt_box.rd, wt_box.ru), m_wall_skip_points[m_cur_layer_id], 2.5 * m_perimeter_width);
                for (auto iter = break_segments.begin(); iter != break_segments.end(); ++iter) {
                    float dx  = iter->start.x() - writer.pos().x();
                    float dy  = iter->start.y() - writer.pos().y();
                    float len = std::sqrt(dx * dx + dy * dy);
                    if (len > 0) {
                        writer.retract(retract_length, retract_speed);
                        writer.travel(iter->start, 600.);
                        writer.retract(-retract_length, retract_speed);
                    } else
                        writer.travel(iter->start, 600.);
 
                    writer.extrude(iter->end, feedrate);
                }
                writer.travel(wt_box.ru, feedrate);
            } else {
                writer.extrude(wt_box.ru, feedrate);
            }
        } else if (index == 0) {
            if (is_left) {
                std::vector<Segment> break_segments = remove_points_from_segment(Segment(wt_box.ld, wt_box.lu), m_wall_skip_points[m_cur_layer_id], 2.5 * m_perimeter_width);
                for (auto iter = break_segments.rbegin(); iter != break_segments.rend(); ++iter) {
                    float dx  = iter->end.x() - writer.pos().x();
                    float dy  = iter->end.y() - writer.pos().y();
                    float len = std::sqrt(dx * dx + dy * dy);
                    if (len > 0) {
                        writer.retract(retract_length, retract_speed);
                        writer.travel(iter->end, 600.);
                        writer.retract(-retract_length, retract_speed);
                    } else
                        writer.travel(iter->end, 600.);
 
                    writer.extrude(iter->start, feedrate);
                }
                writer.travel(wt_box.ld, feedrate);
            } else {
                writer.extrude(wt_box.ld, feedrate);
            }
        } else {
            writer.extrude(points[index], feedrate);
        }
        extruded_nums++;
    }
 
    return Polygon();
}

References EPSILON, Slic3r::WipeTowerWriter::extrude(), Slic3r::WipeTower::box_coordinates::ld, Slic3r::WipeTower::box_coordinates::lu, m_cur_layer_id, m_current_tool, m_filpar, m_perimeter_width, m_wall_skip_points, m_wipe_tower_width, Slic3r::WipeTowerWriter::pos(), Slic3r::WipeTower::box_coordinates::rd, Slic3r::remove_points_from_segment(), Slic3r::WipeTowerWriter::retract(), Slic3r::WipeTower::box_coordinates::ru, Slic3r::WipeTowerWriter::travel(), and WipeTowerWriter.

Here is the call graph for this function:

◆ generate_support_wall_new()

Polygon Slic3r::WipeTower::generate_support_wall_new	(	WipeTowerWriter &	writer,
		const box_coordinates &	wt_box,
		double	feedrate,
		bool	first_layer,
		bool	rib_wall,
		bool	extrude_perimeter,
		bool	skip_points )

{
    auto get_closet_idx = [&writer](Polylines &pls) -> std::pair<int,int> {
        Vec2f anchor{writer.x(), writer.y()};
        int   closestIndex = -1;
        int   closestPl = -1;
        float minDistance  = std::numeric_limits<float>::max();
        for (int i = 0; i < pls.size(); ++i) {
            for (int j = 0; j < pls[i].size(); ++j) {
                float distance = (unscaled<float>(pls[i][j]) - anchor).squaredNorm();
                if (distance < minDistance) {
                    minDistance  = distance;
                    closestPl    = i;
                    closestIndex = j;
                }
            }
        }
        return {closestPl, closestIndex};
    };
 
    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 (skip_points) {
        result_wall = construct_gap_for_skip_points(wall_polygon, m_wall_skip_points[m_cur_layer_id], 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);
    if (m_cur_layer_id == 0) {
        BoundingBox bbox = get_extents(result_wall);
        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::WipeTowerWriter::generate_path(), Slic3r::generate_rectange_polygon(), generate_rib_polygon(), Slic3r::get_extents(), Slic3r::WipeTower::box_coordinates::ld, m_cur_layer_id, m_current_tool, m_filpar, m_perimeter_width, m_rib_offset, m_used_fillet, m_wall_skip_points, m_wipe_tower_width, m_y_shift, Slic3r::BoundingBoxBase< PointType, APointsType >::min, rounding_polygon(), Slic3r::WipeTower::box_coordinates::ru, Slic3r::to_polyline(), Slic3r::union_(), Slic3r::unscaled(), WipeTowerWriter, Slic3r::WipeTowerWriter::x(), and Slic3r::WipeTowerWriter::y().

Referenced by finish_layer_new(), and only_generate_out_wall().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_wipe_tower_blocks()

void Slic3r::WipeTower::generate_wipe_tower_blocks ( bool add_solid_flag )

{
    // 1. generate all layer depth
    m_all_layers_depth.clear();
    m_all_layers_depth.resize(m_plan.size());
    m_cur_layer_id = 0;
    for (auto& info : m_plan) {
        for (const WipeTowerInfo::ToolChange &tool_change : info.tool_changes) {
            if (!is_need_ramming(tool_change.old_tool, tool_change.new_tool, m_cur_layer_id)) {
                int filament_adhesiveness_category = get_filament_category(tool_change.new_tool);
                add_depth_to_block(tool_change.new_tool, filament_adhesiveness_category, tool_change.required_depth);
            }
            else {
                int old_filament_category = get_filament_category(tool_change.old_tool);
                add_depth_to_block(tool_change.old_tool, old_filament_category, tool_change.nozzle_change_depth, true);
                int new_filament_category = get_filament_category(tool_change.new_tool);
                add_depth_to_block(tool_change.new_tool, new_filament_category, tool_change.required_depth - tool_change.nozzle_change_depth);
 
            }
        }
        ++m_cur_layer_id;
    }
 
    // 2. generate all layer depth
    std::vector<std::unordered_map<int, float>> all_layer_category_to_depth(m_plan.size());
    for (size_t layer_id = 0; layer_id < m_all_layers_depth.size(); ++layer_id) {
        const auto& layer_blocks = m_all_layers_depth[layer_id];
        std::unordered_map<int, float> &category_to_depth = all_layer_category_to_depth[layer_id];
        for (auto block : layer_blocks) {
            category_to_depth[block.category] = block.depth;
        }
    }
 
    // 3. generate wipe tower block
    m_wipe_tower_blocks.clear();
    for (int layer_id = 0; layer_id < all_layer_category_to_depth.size(); ++layer_id) {
        const auto &layer_category_depths = all_layer_category_to_depth[layer_id];
        for (auto iter = layer_category_depths.begin(); iter != layer_category_depths.end(); ++iter) {
            auto* block = get_block_by_category(iter->first, true);
            if (block->layer_depths.empty()) {
                block->layer_depths.resize(all_layer_category_to_depth.size(), 0);
                block->finish_depth.resize(all_layer_category_to_depth.size(), 0);
                block->layers_type.resize(all_layer_category_to_depth.size(), WipeTowerLayerType::Normal);
            }
            block->depth = std::max(block->depth, iter->second);
            block->layer_depths[layer_id] = iter->second;
        }
    }
    // 4. get real depth for every layer
    for (int layer_id = m_plan.size() - 1; layer_id >= 0; --layer_id) {
        m_plan[layer_id].depth = 0;
        for (auto& block : m_wipe_tower_blocks) {
            if (layer_id < m_plan.size() - 1)
                block.layer_depths[layer_id] = std::max(block.layer_depths[layer_id], block.layer_depths[layer_id + 1]);
            m_plan[layer_id].depth += block.layer_depths[layer_id];
        }
    }
 
    if (m_tower_framework) {
        for (int layer_id = 1; layer_id < m_plan.size(); ++layer_id) {
            m_plan[layer_id].depth = 0;
            for (auto &block : m_wipe_tower_blocks) {
                block.layer_depths[layer_id] = block.layer_depths[0];
                m_plan[layer_id].depth += block.layer_depths[layer_id];
            }
        }
    }
 
        // add solid infill flag
    if (add_solid_flag) {
        int solid_infill_layer_low = 4;
        std::vector<std::unordered_set<int>> layers_used_tools;
 
        int first_tool = -1;
        for (const auto &layer : m_plan) {
            if (!layer.tool_changes.empty()) {
                first_tool = layer.tool_changes.front().old_tool;
                break;
            }
        }
        for (auto &info : m_plan) {
            std::unordered_set<int> used_tools;
            if (info.tool_changes.empty()) {
                used_tools.insert(get_filament_category(first_tool));
            } else {
                for (const WipeTowerInfo::ToolChange &tool_change : info.tool_changes) {
                    used_tools.insert(get_filament_category(tool_change.old_tool));
                    used_tools.insert(get_filament_category(tool_change.new_tool));
                }
                first_tool = info.tool_changes.back().new_tool;
            }
            layers_used_tools.push_back(used_tools);
        }
 
        for (WipeTowerBlock &block : m_wipe_tower_blocks) {
            for (int layer_id = 0; layer_id < all_layer_category_to_depth.size(); ++layer_id) {
                std::unordered_map<int, float> &category_to_depth = all_layer_category_to_depth[layer_id];
                if (category_to_depth[block.filament_adhesiveness_category] < block.layer_depths[layer_id] - m_perimeter_width) {
                    bool cur_has_block_category = layers_used_tools[layer_id].count(block.filament_adhesiveness_category);
                    int  layer_count            = solid_infill_layer_low;
                    while (layer_count > 0) {
                        if (layer_id + layer_count < all_layer_category_to_depth.size()) {
                            std::unordered_map<int, float> &up_layer_depth = all_layer_category_to_depth[layer_id + layer_count];
                            {
                                bool up_has_block_category = layers_used_tools[layer_id + layer_count].count(block.filament_adhesiveness_category);
                                if (cur_has_block_category != up_has_block_category) {
                                    block.layers_type[layer_id] = WipeTowerLayerType::Solid;
                                    break;
                                }
                            }
                        }
                        --layer_count;
                    }
                }
                if (layer_id > 0) {
                    bool cur_has_block_category = layers_used_tools[layer_id].count(block.filament_adhesiveness_category);
                    bool pre_has_block_category = layers_used_tools[layer_id - 1].count(block.filament_adhesiveness_category);
                    if (cur_has_block_category != pre_has_block_category) { block.layers_type[layer_id] = WipeTowerLayerType::Contact; }
                    if (block.layers_type[layer_id - 1] == WipeTowerLayerType::Contact && block.layers_type[layer_id] != WipeTowerLayerType::Contact) {
                        block.layers_type[layer_id] = WipeTowerLayerType::Contact_UP;
                    }
                }
            }
        }
    }
 
}

References add_depth_to_block(), Contact, Contact_UP, Slic3r::filament_adhesiveness_category(), get_block_by_category(), get_filament_category(), is_need_ramming(), m_all_layers_depth, m_cur_layer_id, m_perimeter_width, m_plan, m_tower_framework, m_wipe_tower_blocks, Normal, Solid, and tool_change().

Referenced by plan_tower_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_all_wall_skip_points()

void Slic3r::WipeTower::get_all_wall_skip_points ( )

private

                                         {
    m_wall_skip_points.clear();
    m_wall_skip_points.resize(m_plan.size());
    for (int i = 0; i < m_plan.size(); i++) {
        const WipeTowerInfo &layer = m_plan[i];
        get_wall_skip_points(m_plan[i],i);
    }
}

References get_wall_skip_points(), m_plan, and m_wall_skip_points.

Referenced by plan_tower_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_auto_brim_by_height()

float Slic3r::WipeTower::get_auto_brim_by_height ( float max_height )

static

                                                         {
    if (max_height < 100) return max_height/100.f * 8.f;
    return 8.f;
}

Referenced by Slic3r::estimate_wipe_tower_footprint(), Slic3r::WipeTower2::finish_layer(), Slic3r::GUI::GLCanvas3D::get_wipe_tower_info(), plan_tower_new(), and Slic3r::WipeTower2::toolchange_Change().

Here is the caller graph for this function:

◆ get_bbx()

BoundingBoxf Slic3r::WipeTower::get_bbx ( ) const

inline

                                 {
        if (m_outer_wall.empty()) return BoundingBoxf({Vec2d(0,0)});
        BoundingBox  box = get_extents(m_outer_wall.begin()->second);
        BoundingBoxf res = BoundingBoxf(unscale(box.min), unscale(box.max));
        return res;
    }

References Slic3r::get_extents(), m_outer_wall, and Slic3r::unscale().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_block_by_category()

WipeTower::WipeTowerBlock * Slic3r::WipeTower::get_block_by_category	(	int	filament_adhesiveness_category,
		bool	create )

{
    auto iter = std::find_if(m_wipe_tower_blocks.begin(), m_wipe_tower_blocks.end(), [&filament_adhesiveness_category](const WipeTower::WipeTowerBlock &item) {
        return item.filament_adhesiveness_category == filament_adhesiveness_category;
    });
 
    if (iter != m_wipe_tower_blocks.end()) {
        return &(*iter);
    }
 
    if (create) {
        WipeTower::WipeTowerBlock new_block;
        new_block.block_id = m_wipe_tower_blocks.size();
        new_block.filament_adhesiveness_category = filament_adhesiveness_category;
        m_wipe_tower_blocks.emplace_back(new_block);
        return &m_wipe_tower_blocks.back();
    }
 
    return nullptr;
}

References Slic3r::WipeTower::WipeTowerBlock::block_id, Slic3r::filament_adhesiveness_category(), Slic3r::WipeTower::WipeTowerBlock::filament_adhesiveness_category, and m_wipe_tower_blocks.

Referenced by generate_new(), generate_wipe_tower_blocks(), get_wall_skip_points(), ramming(), and tool_change_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_block_gap_width()

float Slic3r::WipeTower::get_block_gap_width	(	int	tool,
		bool	is_nozzlechangle = false )

private

{
    //assert(m_block_infill_gap_width.count(m_filpar[tool].category));//The code contains logic that attempts to access non-existent blocks,
                                                                     // such as in case of involving two extruders with only a single head and a single layer,
                                                                     // some code will attempt to access the block's nozzle_change_gap_width, even though the block does not exist.
    if (!m_block_infill_gap_width.count(m_filpar[tool].category)) {
        return is_nozzlechangle ? m_nozzle_change_perimeter_width : m_perimeter_width;
    }
    return is_nozzlechangle ? m_block_infill_gap_width[m_filpar[tool].category].second : m_block_infill_gap_width[m_filpar[tool].category].first;
 
}

References m_block_infill_gap_width, m_filpar, m_nozzle_change_perimeter_width, and m_perimeter_width.

Referenced by get_next_pos(), get_wall_skip_points(), ramming(), set_toolchange(), and toolchange_wipe_new().

Here is the caller graph for this function:

◆ get_brim_width()

float Slic3r::WipeTower::get_brim_width ( ) const

inline

257{ 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::WipeTower::get_depth ( ) const

inline

256{ 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_extruder_id()

int Slic3r::WipeTower::get_extruder_id	(	int	filament_id,
		int	layer_id ) const

                                                                  {
    return m_multi_nozzle_group_result->get_extruder_id(filament_id, layer_id);
}

References m_multi_nozzle_group_result.

Referenced by finish_block_solid(), is_valid_last_layer(), ramming(), set_nozzle_last_layer_id(), and toolchange_wipe_new().

Here is the caller graph for this function:

◆ get_extrusion_flow()

float Slic3r::WipeTower::get_extrusion_flow ( ) const

inline

355{ return m_extrusion_flow; }

References m_extrusion_flow.

Referenced by Slic3r::WipeTowerWriter::line(), and Slic3r::WipeTowerWriter::rectangle_fill_box().

Here is the caller graph for this function:

◆ get_filament_category()

int Slic3r::WipeTower::get_filament_category ( int filament_id )

{
    if (filament_id >= m_filament_categories.size())
        return 0;
    return m_filament_categories[filament_id];
}

References m_filament_categories.

Referenced by generate_new(), generate_wipe_tower_blocks(), get_wall_filament_for_all_layer(), and get_wall_skip_points().

Here is the caller graph for this function:

◆ get_floating_area()

bool Slic3r::WipeTower::get_floating_area	(	float &	start_pos_y,
		float &	end_pos_y ) const

                                                                            {
    if (m_layer_info == m_plan.begin() || (m_layer_info - 1) == m_plan.begin())
        return false;
 
    if (!m_cur_block)
        return false;
 
    end_pos_y = m_cur_block->start_depth + m_cur_block->depth - m_perimeter_width;
    start_pos_y = m_cur_block->finish_depth[m_cur_layer_id - 1];
 
#if 0
    float last_layer_fill_box_y = (m_layer_info - 1)->toolchanges_depth() + m_perimeter_width;
    float last_layer_wipe_depth = (m_layer_info - 1)->depth;
    if (last_layer_wipe_depth - last_layer_fill_box_y <= 2 * m_perimeter_width)
        return false;
 
    start_pos_y = last_layer_fill_box_y + m_perimeter_width;
    end_pos_y   = last_layer_wipe_depth - m_perimeter_width;
#endif
    return true;
}

References m_cur_block, m_cur_layer_id, m_layer_info, m_perimeter_width, and m_plan.

Referenced by need_thick_bridge_flow().

Here is the caller graph for this function:

◆ get_height()

float Slic3r::WipeTower::get_height ( ) const

inline

268{ 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_layer_height()

float Slic3r::WipeTower::get_layer_height ( ) const

inline

269{ return m_layer_height; }

References m_layer_height.

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

Here is the caller graph for this function:

◆ get_limit_depth_by_height()

float Slic3r::WipeTower::get_limit_depth_by_height ( float max_height )

static

{
    float min_wipe_tower_depth = 0.f;
    auto  iter                 = WipeTower::min_depth_per_height.begin();
    while (iter != WipeTower::min_depth_per_height.end()) {
        auto curr_height_to_depth = *iter;
 
        // This is the case that wipe tower height is lower than the first min_depth_to_height member.
        if (curr_height_to_depth.first >= max_height) {
            min_wipe_tower_depth = curr_height_to_depth.second;
            break;
        }
 
        iter++;
 
        // If curr_height_to_depth is the last member, use its min_depth.
        if (iter == WipeTower::min_depth_per_height.end()) {
            min_wipe_tower_depth = curr_height_to_depth.second;
            break;
        }
 
        // If wipe tower height is between the current and next member, set the min_depth as linear interpolation between them
        auto next_height_to_depth = *iter;
        if (next_height_to_depth.first > max_height) {
            float height_base    = curr_height_to_depth.first;
            float height_diff    = next_height_to_depth.first - curr_height_to_depth.first;
            float min_depth_base = curr_height_to_depth.second;
            float depth_diff     = next_height_to_depth.second - curr_height_to_depth.second;
 
            min_wipe_tower_depth = min_depth_base + (max_height - curr_height_to_depth.first) / height_diff * depth_diff;
            break;
        }
    }
    return min_wipe_tower_depth;
}

References min_depth_per_height.

Referenced by calc_block_infill_gap(), Slic3r::estimate_wipe_tower_footprint(), Slic3r::WipeTower2::generate(), plan_tower_new(), and rib_footprint_side().

Here is the caller graph for this function:

◆ get_next_pos()

Vec2f Slic3r::WipeTower::get_next_pos	(	const WipeTower::box_coordinates &	cleaning_box,
		float	wipe_length,
		bool	solid_toolchange )

private

{
    const float &xl = cleaning_box.ld.x();
    const float &xr = cleaning_box.rd.x();
    int line_count = wipe_length / (xr - xl);
 
    float dy = m_layer_info->extra_spacing * get_block_gap_width(m_current_tool,false);
    float y_offset = float(line_count) * dy;
    const Vec2f pos_offset = Vec2f(0.f, m_depth_traversed);
 
    Vec2f res;
    int   index = m_cur_layer_id % 4;
    //Vec2f offset = m_use_gap_wall ? Vec2f(5 * m_perimeter_width, 0) : Vec2f{0, 0};
    Vec2f offset = Vec2f{0, 0};
    switch (index % 4) {
    case 0:
        res = offset +cleaning_box.ld + pos_offset;
        break;
    case 1:
        res = -offset +cleaning_box.rd + pos_offset + Vec2f(0, y_offset);
        break;
    case 2:
        res = -offset+ cleaning_box.rd + pos_offset;
        break;
    case 3:
        res = offset+cleaning_box.ld + pos_offset + Vec2f(0, y_offset);
        break;
    default: break;
    }
    bool is_contact_pre_extrusion = solid_toolchange && m_enable_tower_interface_features;
    bool is_petg_pre_extrusion   = !is_contact_pre_extrusion && is_petg_filament(m_current_tool) && m_has_filament_switcher;
    if (is_contact_pre_extrusion || is_petg_pre_extrusion) {
        Vec2f        stop_pos                                    = res;
        float        filament_tower_interface_pre_extrusion_dist = is_petg_pre_extrusion
                                                                       ? m_filpar[m_current_tool].filament_petg_pre_extrusion_offset_dist
                                                                       : m_filpar[m_current_tool].filament_tower_interface_pre_extrusion_dist;
        // Orca: unscaled(BoundingBox) here is a template returning BoundingBoxBase<Vec2d>, not BoundingBoxf
        auto         printer_bbx                                 = unscaled(get_extents(m_shared_print_bed));
        printer_bbx.translate((-m_wipe_tower_pos - m_rib_offset).cast<double>()); // first layer never be contact
        if (stop_pos.x() < m_wipe_tower_width / 2.f)
            stop_pos = Vec2f(stop_pos.x() - filament_tower_interface_pre_extrusion_dist, stop_pos.y());
        else
            stop_pos = Vec2f(stop_pos.x() + filament_tower_interface_pre_extrusion_dist, stop_pos.y());
        if (stop_pos.x() < printer_bbx.min[0]) stop_pos.x() = printer_bbx.min[0];
        if (stop_pos.x() > printer_bbx.max[0]) stop_pos.x() = printer_bbx.max[0];
        res = stop_pos;
    }
    return res;
}

References Slic3r::cast(), Slic3r::filament_tower_interface_pre_extrusion_dist(), get_block_gap_width(), Slic3r::get_extents(), is_petg_filament(), Slic3r::WipeTower::box_coordinates::ld, m_cur_layer_id, m_current_tool, m_depth_traversed, m_enable_tower_interface_features, m_filpar, m_has_filament_switcher, m_layer_info, m_rib_offset, m_shared_print_bed, m_wipe_tower_pos, m_wipe_tower_width, Slic3r::offset(), Slic3r::WipeTower::box_coordinates::rd, and Slic3r::unscaled().

Referenced by tool_change(), and tool_change_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_nozzle_id()

int Slic3r::WipeTower::get_nozzle_id	(	int	filament_id,
		int	layer_id ) const

5556{ return m_multi_nozzle_group_result->get_nozzle_id(filament_id, layer_id); }

References m_multi_nozzle_group_result.

Referenced by ramming().

Here is the caller graph for this function:

◆ get_number_of_toolchanges()

int Slic3r::WipeTower::get_number_of_toolchanges ( ) const

inline

363{ return m_num_tool_changes; }

Slic3r::WipeTower::m_num_tool_changes

unsigned int m_num_tool_changes

Definition WipeTower.hpp:576

References m_num_tool_changes.

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

Here is the caller graph for this function:

◆ get_outer_wall()

std::map< float, Polylines > Slic3r::WipeTower::get_outer_wall ( ) const

inline

    {
        return m_outer_wall;
    }

References m_outer_wall.

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

Here is the caller graph for this function:

◆ get_rib_length()

float Slic3r::WipeTower::get_rib_length ( ) const

inline

270{ 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::WipeTower::get_rib_offset ( ) const

inline

471{ 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::WipeTower::get_rib_width ( ) const

inline

271{ 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::WipeTower::get_used_filament ( ) const

inline

362{ 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_wall_filament_for_all_layer()

int Slic3r::WipeTower::get_wall_filament_for_all_layer ( )

{
    std::map<int, int> category_counts;
    std::map<int, int> filament_counts;
    int current_tool = m_current_tool;
    for (const auto &layer : m_plan) {
        if (layer.tool_changes.empty()){
            filament_counts[current_tool]++;
            category_counts[get_filament_category(current_tool)]++;
            continue;
        }
        std::unordered_set<int> used_tools;
        std::unordered_set<int> used_category;
        for (size_t i = 0; i < layer.tool_changes.size(); ++i) {
            if (i == 0) {
                filament_counts[layer.tool_changes[i].old_tool]++;
                category_counts[get_filament_category(layer.tool_changes[i].old_tool)]++;
                used_tools.insert(layer.tool_changes[i].old_tool);
                used_category.insert(get_filament_category(layer.tool_changes[i].old_tool));
            }
            if (!used_category.count(get_filament_category(layer.tool_changes[i].new_tool)))
                category_counts[get_filament_category(layer.tool_changes[i].new_tool)]++;
            if (!used_tools.count(layer.tool_changes[i].new_tool))
                filament_counts[layer.tool_changes[i].new_tool]++;
            used_tools.insert(layer.tool_changes[i].new_tool);
            used_category.insert(get_filament_category(layer.tool_changes[i].new_tool));
        }
        current_tool = layer.tool_changes.empty()?current_tool:layer.tool_changes.back().new_tool;
    }
 
    // std::vector<std::pair<int, int>> category_counts_vec;
    int selected_category = -1;
    int selected_count    = 0;
 
    for (auto iter = category_counts.begin(); iter != category_counts.end(); ++iter) {
        if (iter->second > selected_count) {
            selected_category = iter->first;
            selected_count    = iter->second;
        }
    }
 
    // std::sort(category_counts_vec.begin(), category_counts_vec.end(), [](const std::pair<int, int> &left, const std::pair<int, int>& right) {
    //     return left.second > right.second;
    // });
 
    int filament_id    = -1;
    int filament_count = 0;
    for (auto iter = filament_counts.begin(); iter != filament_counts.end(); ++iter) {
        if (get_filament_category(iter->first) == selected_category && iter->second > filament_count) {
            filament_id    = iter->first;
            filament_count = iter->second;
        }
    }
    return filament_id;
}

References get_filament_category(), m_current_tool, and m_plan.

Referenced by generate_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_wall_skip_points()

void Slic3r::WipeTower::get_wall_skip_points	(	const WipeTowerInfo &	layer,
		int	layer_id )

private

{
    const int                      pre_access_layer = 4;
    std::unordered_map<int, float> cur_block_depth;
    for (int i = 0; i < int(layer.tool_changes.size()); ++i) {
        const WipeTowerInfo::ToolChange &tool_change         = layer.tool_changes[i];
        size_t                           old_filament        = tool_change.old_tool;
        size_t                           new_filament        = tool_change.new_tool;
        float                            nozzle_change_depth = tool_change.nozzle_change_depth;
        float                            wipe_depth          = tool_change.required_depth - nozzle_change_depth;
        if (!is_valid_last_layer(old_filament, layer_id, m_plan[layer_id].z)) nozzle_change_depth = 0.f;
        auto *block = get_block_by_category(m_filpar[new_filament].category, false);
        if (!block) continue;
        float process_depth = 0.f;
        if (!cur_block_depth.count(m_filpar[new_filament].category)) cur_block_depth[m_filpar[new_filament].category] = block->start_depth;
        process_depth = cur_block_depth[m_filpar[new_filament].category];
        if (is_need_ramming(new_filament, old_filament, layer_id)) {
            if (get_filament_category(new_filament) == get_filament_category(old_filament))
                process_depth += nozzle_change_depth;
            else {
                if (!cur_block_depth.count(m_filpar[old_filament].category)) {
                    auto *old_block = get_block_by_category(m_filpar[old_filament].category, false);
                    if (!old_block) continue;
                    cur_block_depth[m_filpar[old_filament].category] = old_block->start_depth;
                }
                cur_block_depth[m_filpar[old_filament].category] += nozzle_change_depth;
            }
        }
 
        float infill_gap_width = get_block_gap_width(new_filament, false);
        Vec2f res;
        int   index = layer_id % 4;
        switch (index % 4) {
        case 0: res = Vec2f(0, process_depth); break;
        case 1: res = Vec2f(m_wipe_tower_width, process_depth + wipe_depth - m_plan[layer_id].extra_spacing * infill_gap_width); break;
        case 2: res = Vec2f(m_wipe_tower_width, process_depth); break;
        case 3: res = Vec2f(0, process_depth + wipe_depth - m_plan[layer_id].extra_spacing * infill_gap_width); break;
        default: break;
        }
 
        m_wall_skip_points[layer_id].emplace_back(res);
 
        cur_block_depth[m_filpar[new_filament].category] = process_depth + wipe_depth;
 
        bool solid_toolchange = block->layers_type[layer_id] == WipeTowerLayerType::Contact;
        if (solid_toolchange && m_enable_tower_interface_features) {
            for (int j = 0; j < pre_access_layer; j++) {
                int pre_layer_id = layer_id - j;
                if (pre_layer_id < 0) break;
                m_wall_skip_points[pre_layer_id].push_back(res);
            }
        }
    }
    if (m_enable_tower_interface_features) {
        for (auto &block : m_wipe_tower_blocks) {
            float block_depth = cur_block_depth.count(block.filament_adhesiveness_category) ? cur_block_depth[block.filament_adhesiveness_category] : block.start_depth;
            if (block_depth + EPSILON >= block.start_depth + block.layer_depths[layer_id] - m_perimeter_width) { continue; }
            bool block_solid = block.layers_type[layer_id] == WipeTowerLayerType::Contact;
            bool add_skip_point = block_solid && std::abs(block_depth - block.start_depth) < EPSILON;
            if (add_skip_point) {
                Vec2f res;
                int   index = layer_id % 4;
 
                float dy_skip = block.layer_depths[layer_id] - m_perimeter_width;
                int   n_skip  = (int) ((dy_skip + 0.25f * m_perimeter_width) / m_perimeter_width + 1);
                float gird_depth = m_perimeter_width * (n_skip - 1); // in sync with finish_block_solid
                switch (index % 4) {
                case 0: res = Vec2f(0, block_depth); break;
                case 1: res = Vec2f(m_wipe_tower_width, block_depth + gird_depth); break;
                case 2: res = Vec2f(m_wipe_tower_width, block_depth); break;
                case 3: res = Vec2f(0, block_depth + gird_depth); break;
                default: break;
                }
                m_wall_skip_points[layer_id].emplace_back(res);
                for (int j = 0; j < pre_access_layer; j++) {
                    int pre_layer_id = layer_id - j;
                    if (pre_layer_id < 0) break;
                    m_wall_skip_points[pre_layer_id].push_back(res);
                }
            }
        }
    }
}

References Contact, EPSILON, get_block_by_category(), get_block_gap_width(), get_filament_category(), is_need_ramming(), is_valid_last_layer(), m_enable_tower_interface_features, m_filpar, m_perimeter_width, m_plan, m_wall_skip_points, m_wipe_tower_blocks, m_wipe_tower_width, tool_change(), and Slic3r::WipeTower::WipeTowerInfo::tool_changes.

Referenced by get_all_wall_skip_points().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_wrapping_detection_depth()

float Slic3r::WipeTower::get_wrapping_detection_depth ( )

static

{
    return float(wrapping_wipe_tower_depth);
}

References Slic3r::wrapping_wipe_tower_depth.

Referenced by Slic3r::estimate_wipe_tower_footprint().

Here is the caller graph for this function:

◆ has_tpu_filament()

bool Slic3r::WipeTower::has_tpu_filament ( ) const

inline

367{ return m_has_tpu_filament; }

Slic3r::WipeTower::m_has_tpu_filament

bool m_has_tpu_filament

Definition WipeTower.hpp:518

References m_has_tpu_filament.

◆ is_first_layer()

bool Slic3r::WipeTower::is_first_layer ( ) const

inlineprivate

594{ 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_block(), finish_block_solid(), finish_layer_new(), only_generate_out_wall(), ramming(), set_layer(), tool_change(), tool_change_new(), toolchange_Unload(), toolchange_Wipe(), and toolchange_wipe_new().

Here is the caller graph for this function:

◆ is_need_ramming()

bool Slic3r::WipeTower::is_need_ramming	(	int	filament_id_1,
		int	filament_id_2,
		int	layer_id ) const

{
    return !m_multi_nozzle_group_result->are_filaments_same_nozzle(filament_id_1, filament_id_2, layer_id);
}

References m_multi_nozzle_group_result.

Referenced by calc_block_infill_gap(), generate_wipe_tower_blocks(), get_wall_skip_points(), plan_toolchange(), set_toolchange(), and tool_change_new().

Here is the caller graph for this function:

◆ is_need_reverse_travel()

bool Slic3r::WipeTower::is_need_reverse_travel	(	int	filament,
		bool	extruder_change ) const

private

{
    if (extruder_change)
        return m_filpar[filament_id].ramming_travel_time.first > EPSILON && at_or_front(m_filaments_change_length.first, filament_id) > EPSILON;
    return m_filpar[filament_id].ramming_travel_time.second > EPSILON && at_or_front(m_filaments_change_length.second, filament_id) > EPSILON;
}

References Slic3r::at_or_front(), EPSILON, m_filaments_change_length, and m_filpar.

Referenced by calc_block_infill_gap(), ramming(), and tool_change_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_petg_filament()

bool Slic3r::WipeTower::is_petg_filament ( int filament_id ) const

private

{
    return m_filpar[filament_id].material == "PETG";
}

References m_filpar.

Referenced by get_next_pos().

Here is the caller graph for this function:

◆ is_same_extruder()

bool Slic3r::WipeTower::is_same_extruder	(	int	filament_id_1,
		int	filament_id_2,
		int	layer_id ) const

{
    return m_multi_nozzle_group_result->are_filaments_same_extruder(filament_id_1, filament_id_2, layer_id);
}

References m_multi_nozzle_group_result.

Referenced by calc_block_infill_gap(), plan_toolchange(), set_toolchange(), and tool_change_new().

Here is the caller graph for this function:

◆ is_same_nozzle()

bool Slic3r::WipeTower::is_same_nozzle	(	int	filament_id_1,
		int	filament_id_2,
		int	layer_id ) const

{
    return m_multi_nozzle_group_result->are_filaments_same_nozzle(filament_id_1, filament_id_2, layer_id);
}

References m_multi_nozzle_group_result.

Referenced by plan_toolchange().

Here is the caller graph for this function:

◆ is_tpu_filament()

bool Slic3r::WipeTower::is_tpu_filament ( int filament_id ) const

private

{
    return m_filpar[filament_id].material == "TPU";
}

References m_filpar.

Referenced by tool_change().

Here is the caller graph for this function:

◆ is_valid_last_layer()

bool Slic3r::WipeTower::is_valid_last_layer	(	int	tool,
		int	layer_id,
		double	layer_z ) const

private

{
    int extruder_id = get_extruder_id(tool, layer_id);
    if (extruder_id < 0 || extruder_id >= m_printable_height.size()) return true;
    if (m_last_layer_id[extruder_id] == layer_id && layer_z > m_printable_height[extruder_id]) return false;
    return true;
}

References get_extruder_id(), m_last_layer_id, and m_printable_height.

Referenced by generate_new(), get_wall_skip_points(), and tool_change_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ its_make_rib_brim()

TriangleMesh Slic3r::WipeTower::its_make_rib_brim	(	const Polygon &	brim,
		float	layer_height )

static

                                                                                 {
    TriangleMesh res;
    if (brim.area() < scaled(EPSILON))return res;
    int          offset = brim.size();
    res.its.vertices.reserve(brim.size() * 2);
    auto    faces= Triangulation::triangulate(brim);
    res.its.indices.reserve(brim.size() * 2  + 2 * faces.size());
    for (auto &t : faces) res.its.indices.push_back({t[1], t[0], t[2]});
    for (auto &t : faces) res.its.indices.push_back({t[0] + offset, t[1] + offset, t[2] + offset});
 
    for (int i = 0; i < brim.size(); i++) res.its.vertices.push_back({unscaled<float>(brim[i][0]), unscaled<float>(brim[i][1]), 0});
    for (int i = 0; i < brim.size(); i++) res.its.vertices.push_back({unscaled<float>(brim[i][0]), unscaled<float>(brim[i][1]), layer_height});
 
    for (int i = 0; i < offset; i++) {
        int a = i;
        int b = (i + 1) % offset;
        int c = i + offset;
        int d = b + offset;
        res.its.indices.push_back({a, b, c});
        res.its.indices.push_back({d, c, b});
    }
    return res;
}

References Slic3r::Polygon::area(), EPSILON, Slic3r::TriangleMesh::its, Slic3r::layer_height(), Slic3r::offset(), Slic3r::scaled(), Slic3r::MultiPoint::size(), and Slic3r::Triangulation::triangulate().

Referenced by Slic3r::WipeTowerData::construct_mesh(), and Slic3r::GLVolumeCollection::load_wipe_tower_preview().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ its_make_rib_tower()

TriangleMesh Slic3r::WipeTower::its_make_rib_tower	(	float	width,
		float	depth,
		float	height,
		float	rib_length,
		float	rib_width,
		bool	fillet_wall )

static

{
    TriangleMesh res;
    Polygon      bottom = rib_section(width, depth, rib_length, rib_width, fillet_wall);
    Polygon      top    = rib_section(width, depth, std::sqrt(width * width + depth * depth), rib_width, fillet_wall);
    if (fillet_wall)
        assert(bottom.points.size() == top.points.size());
    int     offset       = bottom.points.size();
    res.its.vertices.reserve(offset * 2);
    if (bottom.area() < scaled(EPSILON) || top.area() < scaled(EPSILON) || bottom.points.size() != top.points.size()) return res;
    auto    faces_bottom = Triangulation::triangulate(bottom);
    auto    faces_top    = Triangulation::triangulate(top);
    res.its.indices.reserve(offset * 2 + faces_bottom.size() + faces_top.size());
    for (auto &t : faces_bottom) res.its.indices.push_back({t[1], t[0], t[2]});
    for (auto &t : faces_top) res.its.indices.push_back({t[0] + offset, t[1] + offset, t[2] + offset});
 
    for (int i = 0; i < bottom.size(); i++) res.its.vertices.push_back({unscaled<float>(bottom[i][0]), unscaled<float>(bottom[i][1]), 0});
    for (int i = 0; i < top.size(); i++) res.its.vertices.push_back({unscaled<float>(top[i][0]), unscaled<float>(top[i][1]), height});
 
    for (int i = 0; i < offset; i++) {
        int a = i;
        int b = (i + 1) % offset;
        int c = i + offset;
        int d = b + offset;
        res.its.indices.push_back({a, b, c});
        res.its.indices.push_back({d, c, b});
    }
    return res;
}

References Slic3r::Polygon::area(), EPSILON, Slic3r::TriangleMesh::its, Slic3r::offset(), Slic3r::MultiPoint::points, rib_section(), Slic3r::scaled(), Slic3r::MultiPoint::size(), Slic3r::Triangulation::triangulate(), and width().

Referenced by Slic3r::WipeTowerData::construct_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ layer_finished()

bool Slic3r::WipeTower::layer_finished ( ) const

inline

                                    {
        return m_current_layer_finished;
  }

References m_current_layer_finished.

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

Here is the caller graph for this function:

◆ layer_is_printed()

bool Slic3r::WipeTower::layer_is_printed ( bool toolchanges_on_layer ) const

private

{
    if (m_layer_info != m_plan.end() && m_layer_info->combined_away)
        return false;
    return ! m_sparse_layers_skipped || toolchanges_on_layer;
}

References m_layer_info, m_plan, and m_sparse_layers_skipped.

Referenced by finish_block(), finish_block_solid(), finish_layer_new(), and only_generate_out_wall().

Here is the caller graph for this function:

◆ length_to_volume()

float Slic3r::WipeTower::length_to_volume	(	float	length,
		float	line_width,
		float	layer_height ) const

inlineprivate

    {
        return std::max(0.f, length * (layer_height * (line_width - layer_height * (1.f - float(M_PI) / 4.f))));
    }

References Slic3r::layer_height(), Slic3r::length(), and M_PI.

Referenced by plan_tower_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_wipe_tower_square()

void Slic3r::WipeTower::make_wipe_tower_square ( )

private

◆ merge_tcr()

WipeTower::ToolChangeResult Slic3r::WipeTower::merge_tcr	(	ToolChangeResult &	first,
		ToolChangeResult &	second )

private

{
    assert(first.new_tool == second.initial_tool);
    WipeTower::ToolChangeResult out = first;
    if ((first.end_pos - second.start_pos).norm() > (float)EPSILON) {
        std::string travel_gcode = "G1 X" + Slic3r::float_to_string_decimal_point(second.start_pos.x(), 3) + " Y" +
                                   Slic3r::float_to_string_decimal_point(second.start_pos.y(), 3) + " F" + Slic3r::float_to_string_decimal_point(m_max_speed, 6) + "\n";
        bool need_insert_travel = true;
        if (second.is_tool_change
            && is_approx(second.start_pos.x(), second.tool_change_start_pos.x())
            && is_approx(second.start_pos.y(), second.tool_change_start_pos.y())) {
            // will insert travel in gcode.cpp
            need_insert_travel = false;
        }
 
        if (need_insert_travel)
            out.gcode += travel_gcode;
    }
    out.gcode += second.gcode;
    out.extrusions.insert(out.extrusions.end(), second.extrusions.begin(), second.extrusions.end());
    out.end_pos = second.end_pos;
    out.wipe_path = second.wipe_path;
    out.initial_tool = first.initial_tool;
    out.new_tool = second.new_tool;
    out.is_contact   = first.is_contact || second.is_contact;
    if (!first.nozzle_change_result.gcode.empty())
        out.nozzle_change_result = first.nozzle_change_result;
    else if (!second.nozzle_change_result.gcode.empty())
        out.nozzle_change_result = second.nozzle_change_result;
 
    if (first.is_tool_change) {
        out.is_tool_change = true;
        out.tool_change_start_pos = first.tool_change_start_pos;
    }
    else if (second.is_tool_change) {
        out.is_tool_change = true;
        out.tool_change_start_pos = second.tool_change_start_pos;
    }
    else {
        out.is_tool_change = false;
    }
 
    // BBS
    out.purge_volume += second.purge_volume;
    return out;
}

Referenced by generate_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ move_box_inside_polygon()

Vec2f Slic3r::WipeTower::move_box_inside_polygon	(	const BoundingBox &	box,
		const Polygons &	polygons,
		coord_t	offset = 0 )

static

{
    if (polygons.empty()) return Vec2f{0.f, 0.f};
 
    const BoundingBox bed = get_extents(polygons);
    // No position fits the footprint.
    if (box.size().x() >= bed.size().x() - 2 * offset || box.size().y() >= bed.size().y() - 2 * offset)
        return Vec2f{0.f, 0.f};
 
    // Clamp against the bounding box first, moving only along the axis that is violated so a dragged
    // prime tower slides along the bed edge instead of jumping inwards.
    Point shift(0, 0);
    for (int axis = 0; axis < 2; ++axis) {
        if (box.max[axis] > bed.max[axis] - offset)
            shift[axis] = (bed.max[axis] - offset) - box.max[axis];
        else if (box.min[axis] < bed.min[axis] + offset)
            shift[axis] = (bed.min[axis] + offset) - box.min[axis];
    }
 
    // A bed that fills its own bounding box is fully clamped by that, so every rectangular bed — all
    // but the delta-style profiles — stops here and keeps its historic placement, including when a
    // negative margin lets the footprint hang over the edge. The tolerance is relative because an
    // exact rectangle loses a few ulps once the areas are squared world coordinates.
    double area = 0.;
    for (const Polygon &poly : polygons) area += std::abs(poly.area());
    const double bed_area = double(bed.size().x()) * double(bed.size().y());
    if (area >= bed_area * (1. - EPSILON)) return unscaled<float>(shift);
 
    // Clamp a negative margin (an auto brim width that has not been resolved yet) to zero: padding by
    // it would shrink the footprint and hand back a position the validation still rejects. The
    // epsilon lets the move's round trip through millimeters land on the outline without counting as
    // a violation.
    BoundingBox padded = box.inflated(std::max<coord_t>(offset, 0) - SCALED_EPSILON);
    padded.translate(shift);
    auto fits = [&padded, &polygons](const Point &move) {
        BoundingBox moved = padded;
        moved.translate(move);
        return diff(Polygons{moved.polygon()}, polygons).empty();
    };
    if (fits(Point(0, 0))) return unscaled<float>(shift);
 
    // Walk towards the middle of the bed. On every non-rectangular bed we ship, the fitting positions
    // form a convex region around it, so bisecting stops just inside the outline.
    Point lo(0, 0), hi = bed.center() - padded.center();
    if (!fits(hi)) return unscaled<float>(shift);
    for (int i = 0; i < 12; ++i) {
        const Point mid = (lo + hi) / 2;
        if (fits(mid)) hi = mid; else lo = mid;
    }
    return unscaled<float>(Point(shift + hi));
}

References Slic3r::area(), Slic3r::BoundingBoxBase< PointType, APointsType >::center(), Slic3r::diff(), Slic3r::empty(), EPSILON, Slic3r::get_extents(), Slic3r::BoundingBox::inflated(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::offset(), Slic3r::BoundingBox::polygon(), SCALED_EPSILON, Slic3r::BoundingBoxBase< PointType, APointsType >::size(), Slic3r::BoundingBoxBase< PointType, APointsType >::translate(), and Slic3r::unscaled().

Referenced by anonymous_namespace{OrcaSlicer_profile_validator.cpp}::place_wipe_tower(), Slic3r::GUI::PartPlateList::set_default_wipe_tower_pos_for_plate(), and Slic3r::GUI::Selection::translate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ need_thick_bridge_flow()

bool Slic3r::WipeTower::need_thick_bridge_flow ( float pos_y ) const

                                                        {
    if (m_layer_height >= 0.2)
        return false;
 
    float y_min = 0., y_max = 0.;
    if (get_floating_area(y_min, y_max)) {
        return pos_y > y_min && pos_y < y_max;
    }
    return false;
}

References get_floating_area(), and m_layer_height.

Referenced by Slic3r::WipeTowerWriter::line(), ramming(), Slic3r::WipeTowerWriter::rectangle_fill_box(), toolchange_Wipe(), and toolchange_wipe_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ never_skip_tag()

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

inlinestatic

46{ return "_GCODE_WIPE_TOWER_NEVER_SKIP_TAG"; }

Referenced by Slic3r::WipeTowerIntegration::post_process_wipe_tower_moves(), toolchange_Change(), and Slic3r::transform_gcode().

Here is the caller graph for this function:

◆ nozzle_change()

NozzleChangeResult Slic3r::WipeTower::nozzle_change	(	int	old_filament_id,
		int	new_filament_id )

◆ nozzle_change_extrusion_flow()

float Slic3r::WipeTower::nozzle_change_extrusion_flow ( float layer_height = -1.f ) const

inline

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

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

Referenced by plan_toolchange(), ramming(), and set_toolchange().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ nozzle_change_perimeter_width()

float Slic3r::WipeTower::nozzle_change_perimeter_width ( float nozzle_diameter )

static

{
    auto it = nozzle_diameter_to_nozzle_change_width.find(nozzle_diameter);
    return it != nozzle_diameter_to_nozzle_change_width.end() ? it->second : 2.f * nozzle_diameter * 1.25f;
}

References Slic3r::nozzle_diameter(), and Slic3r::nozzle_diameter_to_nozzle_change_width.

Referenced by estimate_tower_blocks_depth().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ only_generate_out_wall()

WipeTower::ToolChangeResult Slic3r::WipeTower::only_generate_out_wall ( bool is_new_mode = false )

{
    size_t old_tool = m_current_tool;
 
    WipeTowerWriter 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));
 
    set_for_wipe_tower_writer(writer);
 
    // Slow down on the 1st layer.
    bool first_layer = is_first_layer();
    // BBS: speed up perimeter speed to 90mm/s for non-first layer
    float feedrate   = first_layer ? std::min(m_first_layer_speed * 60.f, m_max_speed) : std::min(60.0f * m_filpar[m_current_tool].max_e_speed / m_extrusion_flow, m_max_speed);
    float           fill_box_y = m_layer_info->toolchanges_depth() + m_perimeter_width;
    box_coordinates fill_box(Vec2f(m_perimeter_width, fill_box_y), m_wipe_tower_width - 2 * m_perimeter_width, m_layer_info->depth - fill_box_y);
 
    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;
 
    // we are in one of the corners, travel to ld along the perimeter:
    // BBS: Delete some unnecessary travel
    //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());
    writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Wipe_Tower_Start) + "\n");
    // outer perimeter (always):
    // BBS
 
    float wipe_tower_depth = m_layer_info->depth + m_perimeter_width;
    if (is_new_mode && (m_enable_timelapse_print || m_enable_wrapping_detection))
        wipe_tower_depth = m_wipe_tower_depth;
    box_coordinates wt_box(Vec2f(0.f, (m_current_shape == SHAPE_REVERSED ? m_layer_info->toolchanges_depth() : 0.f)), m_wipe_tower_width, wipe_tower_depth);
    wt_box = align_perimeter(wt_box);
    Polygon outer_wall;
    //if (m_use_gap_wall)
    //    generate_support_wall(writer, wt_box, feedrate, first_layer);
    //else
    //    writer.rectangle(wt_box, feedrate);
    outer_wall = generate_support_wall_new(writer, wt_box, feedrate, first_layer, m_use_rib_wall, true, m_use_gap_wall);
    m_outer_wall[m_z_pos].push_back(to_polyline(outer_wall));
    // Now prepare future wipe. box contains rectangle that was extruded last (ccw).
 
    // Vec2f target = (writer.pos() == wt_box.ld ? wt_box.rd : (writer.pos() == wt_box.rd ? wt_box.ru : (writer.pos() == wt_box.ru ? wt_box.lu : wt_box.ld)));
    //writer.add_wipe_point(writer.pos()).add_wipe_point(target);
 
    writer.add_wipe_path(outer_wall, m_filpar[m_current_tool].wipe_dist);
    writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Wipe_Tower_End) + "\n");
 
    // 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.
    if (layer_is_printed(toolchanges_on_layer))
        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, true, false, 0.f, false);
}

Referenced by generate_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ plan_toolchange()

void Slic3r::WipeTower::plan_toolchange	(	float	z_par,
		float	layer_height_par,
		unsigned int	old_tool,
		unsigned int	new_tool,
		float	wipe_volume_ec = 0.f,
		float	wipe_volume_nc = 0.f,
		float	prime_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_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
    float depth = 0.f;
    float width = m_wipe_tower_width - 2 * m_perimeter_width;
 
    // BBS: if the wipe tower width is too small, the depth will be infinity
    if (width <= EPSILON)
        return;
    int   layer_id    = static_cast<int>(m_plan.size()) - 1;
    float wipe_volume = is_same_extruder(old_tool, new_tool, layer_id) && !is_same_nozzle(old_tool, new_tool, layer_id) ? wipe_volume_nc : wipe_volume_ec;
    // BBS: remove old filament ramming and first line
#if 0
  float length_to_extrude = volume_to_length(0.25f * 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_par);
  depth = (int(length_to_extrude / width) + 1) * (m_perimeter_width * m_filpar[old_tool].ramming_line_width_multiplicator * m_filpar[old_tool].ramming_step_multiplicator);
    float ramming_depth = depth;
    length_to_extrude = width*((length_to_extrude / width)-int(length_to_extrude / width)) - width;
    float first_wipe_line = -length_to_extrude;
    length_to_extrude += volume_to_length(wipe_volume, m_perimeter_width, layer_height_par);
    length_to_extrude = std::max(length_to_extrude,0.f);
 
    depth += (int(length_to_extrude / width) + 1) * m_perimeter_width;
    depth *= m_extra_spacing;
 
    m_plan.back().tool_changes.push_back(WipeTowerInfo::ToolChange(old_tool, new_tool, depth, ramming_depth, first_wipe_line, wipe_volume));
#else
    float length_to_extrude = volume_to_length(wipe_volume, m_perimeter_width, layer_height_par);
 
    depth += std::ceil(length_to_extrude / width) * m_perimeter_width;
    //depth *= m_extra_spacing;
    float filament_change_length = !is_same_extruder(old_tool, new_tool, layer_id) ? at_or_front(m_filaments_change_length.first, old_tool) : at_or_front(m_filaments_change_length.second, old_tool);
    float nozzle_change_depth = 0;
    float nozzle_change_length = 0;
    if (is_need_ramming(old_tool, new_tool, layer_id)) {
        double e_flow                   = nozzle_change_extrusion_flow(layer_height_par);
        double length                   = filament_change_length / e_flow;
        int    nozzle_change_line_count = std::ceil(length / (m_wipe_tower_width - 2*m_nozzle_change_perimeter_width));
        nozzle_change_depth = nozzle_change_line_count * m_nozzle_change_perimeter_width;
        depth += nozzle_change_depth;
        nozzle_change_length = length;
    }
    WipeTowerInfo::ToolChange tool_change = WipeTowerInfo::ToolChange(old_tool, new_tool, depth, 0.f, 0.f, wipe_volume, length_to_extrude, purge_volume);
    tool_change.nozzle_change_depth       = nozzle_change_depth;
    tool_change.nozzle_change_length      = nozzle_change_length;
    m_plan.back().tool_changes.push_back(tool_change);
#endif
}

References Slic3r::at_or_front(), EPSILON, is_need_ramming(), is_same_extruder(), is_same_nozzle(), Slic3r::length(), m_extra_spacing, m_filaments_change_length, m_filpar, m_first_layer_idx, m_nozzle_change_perimeter_width, m_perimeter_width, m_plan, m_sparse_layers_skipped, m_wipe_tower_width, nozzle_change_extrusion_flow(), tool_change(), volume_to_length(), width(), 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::WipeTower::plan_tower ( )

private

◆ plan_tower_new()

void Slic3r::WipeTower::plan_tower_new ( )

{
    if (m_wipe_tower_brim_width < 0) m_wipe_tower_brim_width = get_auto_brim_by_height(m_wipe_tower_height);
    calc_block_infill_gap();
    if (m_use_rib_wall) {
        // recalculate wipe_tower_with and layer's depth
        generate_wipe_tower_blocks(false);
        float max_depth    = std::accumulate(m_wipe_tower_blocks.begin(), m_wipe_tower_blocks.end(), 0.f, [](float a, const auto &t) { return a + t.depth; }) + m_perimeter_width;
        float square_width = align_ceil(std::sqrt(max_depth * m_wipe_tower_width * m_extra_spacing), m_perimeter_width);
        m_wipe_tower_width = square_width;
        for (int 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, toolchange.purge_volume,idx);
            }
        }
    }
 
    generate_wipe_tower_blocks(true);
 
    float max_depth = 0.f;
    for (const auto &block : m_wipe_tower_blocks) {
        max_depth += block.depth;
    }
    //std::cout << " after square " << m_wipe_tower_width << "  depth  " << max_depth << std::endl;
 
    float min_wipe_tower_depth = get_limit_depth_by_height(m_wipe_tower_height);
 
    // only for get m_extra_spacing
    {
        if (m_enable_wrapping_detection && max_depth < EPSILON) {
            max_depth = wrapping_wipe_tower_depth;
            if (m_use_rib_wall) {
                m_wipe_tower_width = max_depth;
            }
        }
 
        if (m_enable_timelapse_print && max_depth < EPSILON) {
            max_depth = min_wipe_tower_depth;
            if (m_use_rib_wall) { m_wipe_tower_width = max_depth; }
        }
 
        if (max_depth + EPSILON < min_wipe_tower_depth) {
            //if enable rib_wall, there is no need to set extra_spacing
            if (m_use_rib_wall)
                m_rib_length = std::max(m_rib_length, min_wipe_tower_depth * (float) std::sqrt(2));
            else
                m_extra_spacing = std::max(min_wipe_tower_depth / max_depth, m_extra_spacing);
        }
 
        for (int idx = 0; idx < m_plan.size(); idx++) {
            auto &info = m_plan[idx];
            if (idx == 0 /*&& m_extra_spacing > 1.f + EPSILON*/) {
                // apply solid fill for the first layer
                info.extra_spacing = 1.f;
                for (auto &toolchange : info.tool_changes) {
                    //float x_to_wipe     = volume_to_length(toolchange.wipe_volume, m_perimeter_width, info.height);
                    float line_len      = m_wipe_tower_width - 2 * m_perimeter_width;
                    float wipe_depth = (toolchange.required_depth - toolchange.nozzle_change_depth) * m_extra_spacing;
                    float wipe_line_count = wipe_depth / m_perimeter_width;
                    float nozzle_change_depth = toolchange.nozzle_change_depth * m_extra_spacing;
 
                    int nozzle_change_line_count = (toolchange.nozzle_change_depth * m_extra_spacing + WT_EPSILON) / m_nozzle_change_perimeter_width;
 
                    toolchange.required_depth = wipe_depth + nozzle_change_depth;
                    toolchange.wipe_length = wipe_line_count * line_len;
                    toolchange.wipe_volume          = length_to_volume(toolchange.wipe_length, m_perimeter_width, info.height);
                    toolchange.nozzle_change_length = nozzle_change_line_count * (m_wipe_tower_width - (m_nozzle_change_perimeter_width + m_perimeter_width));
                    toolchange.nozzle_change_depth  = nozzle_change_depth;
                }
            } else {
                info.extra_spacing = m_extra_spacing;
                for (auto &toolchange : info.tool_changes) {
                    toolchange.required_depth *= m_extra_spacing;
                    toolchange.nozzle_change_depth *= m_extra_spacing;
                    toolchange.wipe_length = volume_to_length(toolchange.wipe_volume, m_perimeter_width, info.height);
                }
            }
        }
    }
 
    update_all_layer_depth(max_depth);
    set_nozzle_last_layer_id();
    if(m_use_gap_wall) get_all_wall_skip_points();
    float diagonal = 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);
    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.
 
}

References Slic3r::align_ceil(), calc_block_infill_gap(), EPSILON, generate_wipe_tower_blocks(), get_all_wall_skip_points(), get_auto_brim_by_height(), get_limit_depth_by_height(), length_to_volume(), m_enable_timelapse_print, m_enable_wrapping_detection, m_extra_rib_length, m_extra_spacing, m_nozzle_change_perimeter_width, m_perimeter_width, m_plan, m_rib_length, m_rib_width, m_use_gap_wall, m_use_rib_wall, m_wipe_tower_blocks, m_wipe_tower_brim_width, m_wipe_tower_depth, m_wipe_tower_height, m_wipe_tower_width, set_nozzle_last_layer_id(), set_toolchange(), update_all_layer_depth(), volume_to_length(), Slic3r::wrapping_wipe_tower_depth, and WT_EPSILON.

Referenced by generate_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ position()

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

inline

313{ 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::WipeTower::prime	(	float	initial_layer_print_height,
		const std::vector< unsigned int > &	tools,
		bool	last_wipe_inside_wipe_tower )

{
    return std::vector<ToolChangeResult>();
}

References Slic3r::initial_layer_print_height().

Here is the call graph for this function:

◆ ramming()

WipeTower::NozzleChangeResult Slic3r::WipeTower::ramming	(	int	old_filament_id,
		int	new_filament_id,
		bool	solid_change = false,
		bool	extruder_change = true )

{
    auto format_line_M106 = []() { return std::string{"M106 S255\n"};};
    auto format_line_M633 = []() { return std::string{"M633\n"};};
    auto format_line_M632 = [](int filament_id, int nozzle_id) {
        std::string buffer = "M632 S" + std::to_string(filament_id);
        if (nozzle_id >= 0)
            buffer += " H" + std::to_string(nozzle_id);
        buffer += " M N\n";
        return buffer;
    };
 
    int   nozzle_change_line_count = 0;
    float x_offset                 = m_perimeter_width + (m_nozzle_change_perimeter_width - m_perimeter_width) / 2;
    float nozzle_change_box_width  = m_wipe_tower_width - 2 * x_offset;
    float nozzle_change_depth      = 0.f;
    if (new_filament_id != (unsigned int) (-1)) {
        for (const auto &b : m_layer_info->tool_changes)
            if (b.new_tool == new_filament_id) {
                nozzle_change_line_count = std::ceil(b.nozzle_change_length  / nozzle_change_box_width);
                nozzle_change_depth      = b.nozzle_change_depth;
                break;
            }
    }
    auto format_nozzle_change_line = [this](bool start, int old_filament_id, int new_filament_id) -> std::string {
        char        buff[64];
        // Orca: the nozzle-change markers are standalone tag constants, not ETags entries
        // (the Reserved_Tags parallel arrays have a non-BBL variant that must stay aligned).
        std::string tag = start ? GCodeProcessor::Nozzle_Change_Start_Tag : GCodeProcessor::Nozzle_Change_End_Tag;
        int         old_nozzle_id = get_nozzle_id(old_filament_id, m_cur_layer_id);
        int         new_nozzle_id = get_nozzle_id(new_filament_id, m_cur_layer_id);
        snprintf(buff, sizeof(buff), ";%s OF%d NF%d ON%d NN%d\n", tag.c_str(), old_filament_id, new_filament_id,old_nozzle_id,new_nozzle_id);
        return std::string(buff);
    };
 
    float nz_extrusion_flow = nozzle_change_extrusion_flow(m_layer_height);
    WipeTowerWriter writer(m_layer_height, m_nozzle_change_perimeter_width, m_gcode_flavor, m_filpar, m_enable_arc_fitting);
    writer.set_extrusion_flow(nz_extrusion_flow)
        .set_z(m_z_pos)
        .set_initial_tool(m_current_tool)
        .set_y_shift(m_y_shift + (new_filament_id != (unsigned int) (-1) && (m_current_shape == SHAPE_REVERSED) ? m_layer_info->depth - m_layer_info->toolchanges_depth() : 0.f));
    set_for_wipe_tower_writer(writer);
 
    WipeTowerBlock* block = get_block_by_category(m_filpar[old_filament_id].category, false);
    if (!block) {
        assert(false);
        return WipeTower::NozzleChangeResult();
    }
    m_cur_block = block;
 
    float dy = is_first_layer() ? m_nozzle_change_perimeter_width : m_layer_info->extra_spacing * get_block_gap_width(m_current_tool, true);
    box_coordinates cleaning_box(Vec2f(x_offset, block->cur_depth + (m_nozzle_change_perimeter_width - m_perimeter_width) / 2),
                                 nozzle_change_box_width,
                                 nozzle_change_depth);
    Vec2f initial_position = cleaning_box.ld;
    writer.set_initial_position(initial_position, m_wipe_tower_width, m_wipe_tower_depth, m_internal_rotation);
 
    // --- Nozzle change preamble: notify firmware + precool ---
    writer.append(format_nozzle_change_line(true, old_filament_id, new_filament_id));
    if (!extruder_change) {
        int new_nozzle_id = m_multi_nozzle_group_result->is_support_dynamic_nozzle_map()
                                ? get_nozzle_id(new_filament_id, m_cur_layer_id) : -1;
        writer.append(format_line_M632(new_filament_id, new_nozzle_id));
        if (m_filpar[m_current_tool].precool_target_temp.second != 0) {
            writer.format_line_M104(m_filpar[m_current_tool].precool_target_temp.second, get_extruder_id(m_current_tool, m_cur_layer_id))
                .append(format_line_M106());
        }
        writer.append(format_line_M633());
    }
 
    NozzleChangeResult result;
 
    if (nozzle_change_line_count > 0) {
        float max_e_ramming_speed = extruder_change ? m_filpar[m_current_tool].max_e_ramming_speed.first : m_filpar[m_current_tool].max_e_ramming_speed.second;
        float nozzle_change_speed = 60.0f * max_e_ramming_speed / nz_extrusion_flow;
        if (solid_infill)
            nozzle_change_speed = std::min(40.f * 60.f, nozzle_change_speed);
        float bridge_speed = std::min(60.0f * max_e_ramming_speed / nozzle_change_extrusion_flow(0.2), nozzle_change_speed);
 
        const float &xl = cleaning_box.ld.x();
        const float &xr = cleaning_box.rd.x();
        dy = solid_infill ? m_nozzle_change_perimeter_width : dy;
        if (solid_infill)
            nozzle_change_line_count = std::floor(EPSILON + (cleaning_box.ru[1] - cleaning_box.rd[1] + (m_nozzle_change_perimeter_width - m_perimeter_width) / 2.f) /
                                                                m_nozzle_change_perimeter_width);
        m_left_to_right = true;
        bool need_change_flow   = false;
        float ramming_length    = nozzle_change_line_count * (xr - xl);
        int   extruder_id      = get_extruder_id(m_current_tool, m_cur_layer_id);
        // -1: the filament is not in this layer's nozzle map.
        float precool_t             = extruder_id < 0 ? 0.f :
                                      extruder_change ? m_filpar[m_current_tool].precool_t.first[extruder_id] : m_filpar[m_current_tool].precool_t.second[extruder_id];
        float precool_t_first_layer = extruder_id < 0 ? 0.f :
                                      extruder_change ? m_filpar[m_current_tool].precool_t_first_layer.first[extruder_id] :
                                                        m_filpar[m_current_tool].precool_t_first_layer.second[extruder_id];
        float per_cooling_max_speed = nozzle_change_speed;
        if (extruder_change) {
            if (is_first_layer() && precool_t_first_layer > EPSILON)
                per_cooling_max_speed = ramming_length / precool_t_first_layer * 60.f;
            else if (precool_t > EPSILON)
                per_cooling_max_speed = ramming_length / precool_t * 60.f;
        }//BBS:nozzle change does not require forcing a cooldown to a specific temperature.
        if (nozzle_change_speed > per_cooling_max_speed) nozzle_change_speed = per_cooling_max_speed;
        if (bridge_speed > per_cooling_max_speed) bridge_speed = per_cooling_max_speed;
        LimitFlow LimitRamming = extruder_change ? LimitFlow::LimitRammingFlow : LimitFlow::LimitRammingFlowNC;
        for (int i = 0; true; ++i) {
            if (need_thick_bridge_flow(writer.pos().y())) {
                writer.set_extrusion_flow(nozzle_change_extrusion_flow(0.2));
                writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height) + Slic3r::float_to_string_decimal_point(0.2, 6) + "\n");
                need_change_flow = true;
            }
            if (m_left_to_right)
                writer.extrude(xr + wipe_tower_wall_infill_overlap * m_perimeter_width, writer.y(), need_change_flow ? bridge_speed : nozzle_change_speed, LimitRamming);
            else
                writer.extrude(xl - wipe_tower_wall_infill_overlap * m_perimeter_width, writer.y(), need_change_flow ? bridge_speed : nozzle_change_speed, LimitRamming);
            if (i == nozzle_change_line_count - 1)
                break;
            if ((writer.y() + dy - cleaning_box.ru.y()+(m_nozzle_change_perimeter_width+m_perimeter_width)/2) > (float)EPSILON) break;
            if (need_change_flow) {
                writer.set_extrusion_flow(nozzle_change_extrusion_flow(m_layer_height));
                writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height) + Slic3r::float_to_string_decimal_point(m_layer_height, 6) + "\n");
                need_change_flow = false;
            }
            writer.extrude(writer.x(), writer.y() + dy, nozzle_change_speed, LimitRamming);
            m_left_to_right = !m_left_to_right;
        }
        if (need_change_flow) {
            writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height) + Slic3r::float_to_string_decimal_point(m_layer_height, 6) + "\n");
        }
 
        writer.set_extrusion_flow(nz_extrusion_flow);
        block->cur_depth += nozzle_change_depth;
        block->last_nozzle_change_id = old_filament_id;
        // --- Post-ramming: re-arm nozzle change for travel phase ---
        if (!extruder_change) {
            int new_nozzle_id = m_multi_nozzle_group_result->is_support_dynamic_nozzle_map()
                                    ? get_nozzle_id(new_filament_id, m_cur_layer_id) : -1;
            writer.append(format_line_M632(new_filament_id, new_nozzle_id));
        }
 
        if (is_need_reverse_travel(m_current_tool, extruder_change)) {
            bool   left_to_right     = !m_left_to_right;
            int  tpu_line_count = nozzle_change_line_count;
            nozzle_change_speed *= 2; // due to nozzle change 2 perimeter
            float ramming_travel_time     = extruder_change ? m_filpar[m_current_tool].ramming_travel_time.first : m_filpar[m_current_tool].ramming_travel_time.second;
            float need_reverse_travel_dis = ramming_travel_time * nozzle_change_speed / 60.f;
            float real_travel_dis         = tpu_line_count * (xr - xl - 2 * m_perimeter_width);
            if (real_travel_dis < need_reverse_travel_dis)
                nozzle_change_speed *= real_travel_dis / need_reverse_travel_dis;
            writer.travel(writer.x(), writer.y() + dy/2);
 
            for (int i = 0; true; ++i) {
                need_reverse_travel_dis -= (xr - xl - 2 * m_perimeter_width);
                float offset_dis = 0.f;
                if (need_reverse_travel_dis < 0) {
                    offset_dis              = -need_reverse_travel_dis;
                }
                if (left_to_right)
                    writer.travel(xr - m_perimeter_width - offset_dis, writer.y(), nozzle_change_speed);
                else
                    writer.travel(xl + m_perimeter_width + offset_dis , writer.y(), nozzle_change_speed);
                if (need_reverse_travel_dis < EPSILON) break;
                if (i == tpu_line_count - 1)
                    break;
 
                writer.travel(writer.x(), writer.y() - dy);
                left_to_right = !left_to_right;
            }
        } else {
            result.wipe_path.push_back(writer.pos_rotated());
            if (m_left_to_right) {
                result.wipe_path.push_back(Vec2f(0, writer.pos_rotated().y()));
            } else {
                result.wipe_path.push_back(Vec2f(m_wipe_tower_width, writer.pos_rotated().y()));
            }
        }
        if (!extruder_change) writer.append(format_line_M633());
    }
 
    writer.append(format_nozzle_change_line(false, old_filament_id, new_filament_id));
 
    result.start_pos = writer.start_pos_rotated();
    result.origin_start_pos = initial_position;
    result.end_pos   = writer.pos_rotated();
    result.gcode     = writer.gcode();
    result.is_extruder_change = extruder_change;
    return result;
}

Referenced by tool_change_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_block_status()

void Slic3r::WipeTower::reset_block_status ( )

{
    for (auto &block : m_wipe_tower_blocks) {
        block.cur_depth = block.start_depth;
        block.last_filament_change_id = -1;
        block.last_nozzle_change_id   = -1;
    }
}

References m_wipe_tower_blocks.

Referenced by generate_new().

Here is the caller graph for this function:

◆ rib_footprint_side()

float Slic3r::WipeTower::rib_footprint_side	(	float	width,
		float	depth,
		float	rib_width,
		float	extra_rib_length,
		float	max_height )

static

{
    if (width < EPSILON || depth < EPSILON)
        return 0.f;
    // Ribs run the diagonal; below the height-based minimum they are extended rather than the
    // body, then by the extra length, never ending up shorter than the diagonal.
    const float diagonal   = std::sqrt(width * width + depth * depth);
    float       rib_length = diagonal;
    if (depth + EPSILON < get_limit_depth_by_height(max_height))
        rib_length = std::max(rib_length, get_limit_depth_by_height(max_height) * float(std::sqrt(2.)));
    rib_length = std::max(diagonal, rib_length + extra_rib_length);
    // Half the extension at each end of the diagonal plus half the rib width, projected onto the axes.
    const float rib_w    = std::min(rib_width, std::min(width, depth) / 2.f);
    const float per_side = ((rib_length - diagonal) / 2.f + rib_w / 2.f) / float(std::sqrt(2.));
    return std::max(width, depth) + 2.f * per_side;
}

References EPSILON, get_limit_depth_by_height(), and width().

Referenced by estimate_rib_tower_bbox_side(), and Slic3r::estimate_wipe_tower_footprint().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rib_section()

Polygon Slic3r::WipeTower::rib_section	(	float	width,
		float	depth,
		float	rib_length,
		float	rib_width,
		bool	fillet_wall )

static

{
    Polygon res;
    res.points.resize(16);
    float              theta     = std::atan(width / depth);
    float              costheta  = std::cos(theta);
    float              sintheta  = std::sin(theta);
    float              w         = rib_width / 2.f;
    float              diag      = std::sqrt(width * width + depth * depth);
    float              l         = (rib_length - diag) / 2;
    Vec2f              diag_dir1 = Vec2f{width, depth}.normalized();
    Vec2f              diag_dir1_perp{-diag_dir1[1], diag_dir1[0]};
    Vec2f              diag_dir2 = Vec2f{-width, depth}.normalized();
    Vec2f              diag_dir2_perp{-diag_dir2[1], diag_dir2[0]};
    std::vector<Vec2f> p{{0, 0}, {width, 0}, {width, depth}, {0, depth}};
    Polyline           p_render;
    for (auto &x : p) p_render.points.push_back(scaled(x));
    res.points[0] = scaled(Vec2f{p[0].x(), p[0].y() + w / sintheta});
    res.points[1] = scaled(Vec2f{p[0] - diag_dir1 * l + diag_dir1_perp * w});
    res.points[2] = scaled(Vec2f{p[0] - diag_dir1 * l - diag_dir1_perp * w});
    res.points[3] = scaled(Vec2f{p[0].x() + w / costheta, p[0].y()});
 
    res.points[4] = scaled(Vec2f{p[1].x() - w / costheta, p[1].y()});
    res.points[5] = scaled(Vec2f{p[1] - diag_dir2 * l + diag_dir2_perp * w});
    res.points[6] = scaled(Vec2f{p[1] - diag_dir2 * l - diag_dir2_perp * w});
    res.points[7] = scaled(Vec2f{p[1].x(), p[1].y() + w / sintheta});
 
    res.points[8]  = scaled(Vec2f{p[2].x(), p[2].y() - w / sintheta});
    res.points[9]  = scaled(Vec2f{p[2] + diag_dir1 * l - diag_dir1_perp * w});
    res.points[10] = scaled(Vec2f{p[2] + diag_dir1 * l + diag_dir1_perp * w});
    res.points[11] = scaled(Vec2f{p[2].x() - w / costheta, p[2].y()});
 
    res.points[12] = scaled(Vec2f{p[3].x() + w / costheta, p[3].y()});
    res.points[13] = scaled(Vec2f{p[3] + diag_dir2 * l - diag_dir2_perp * w});
    res.points[14] = scaled(Vec2f{p[3] + diag_dir2 * l + diag_dir2_perp * w});
    res.points[15] = scaled(Vec2f{p[3].x(), p[3].y() - w / sintheta});
    res.remove_duplicate_points();
    if (fillet_wall) { res = rounding_polygon(res); }
    res.points.shrink_to_fit();
    return res;
}

References Slic3r::MultiPoint::points, Slic3r::MultiPoint::remove_duplicate_points(), rounding_polygon(), Slic3r::scaled(), and width().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rounding_polygon()

Polygon Slic3r::WipeTower::rounding_polygon	(	Polygon &	polygon,
		double	rounding = 2.,
		double	angle_tol = 30. / 180. * PI )

static

{
    if (polygon.points.size() < 3) return polygon;
    Polygon res;
    res.points.reserve(polygon.points.size() * 2);
    int    mod           = polygon.points.size();
    double cos_angle_tol = abs(std::cos(angle_tol));
 
    for (int i = 0; i < polygon.points.size(); i++) {
        Vec2d  a      = unscaled(polygon.points[(i - 1 + mod) % mod]);
        Vec2d  b      = unscaled(polygon.points[i]);
        Vec2d  c      = unscaled(polygon.points[(i + 1) % mod]);
        double ab_len = (a - b).norm();
        double bc_len = (b - c).norm();
        Vec2d  ab     = (b - a) / ab_len;
        Vec2d  bc     = (c - b) / bc_len;
        assert(ab_len != 0);
        assert(bc_len != 0);
        float cosangle = ab.dot(bc);
        cosangle       = std::clamp(cosangle, -1.f, 1.f);
        bool  is_ccw   = cross2(ab, bc) > 0;
        if (abs(cosangle) < cos_angle_tol) {
            float real_rounding_dis = std::min({rounding, ab_len / 2.1, bc_len / 2.1}); // 2.1 to ensure the points do not coincide
            Vec2d left              = b - ab * real_rounding_dis;
            Vec2d right             = b + bc * real_rounding_dis;
            //Point r_left            = scaled(left);
            //Point r_right            = scaled(right);
           // std::cout << " r_left  " << r_left[0] << " " << r_left[1] << std::endl;
            //std::cout << " r_right  " << r_right[0] << " " << r_right[1] << std::endl;
            {
                float half_angle = std::acos(cosangle)/2.f;
                //std::cout << " half_angle  " << cos(half_angle) << std::endl;
 
                Vec2d dir        = (right - left).normalized();
                dir              = Vec2d{-dir[1], dir[0]};
                dir                  = is_ccw ? dir : -dir;
                double dis       = real_rounding_dis / sin(half_angle);
                //std::cout << " dis  " << dis << std::endl;
 
                Vec2d  center    = b + dir * dis;
                double radius    = (left - center).norm();
                ArcSegment arc(scaled(center), scaled(radius), scaled(left), scaled(right), is_ccw ? ArcDirection::Arc_Dir_CCW : ArcDirection::Arc_Dir_CW);
                int        n            = arc_fit_size;
                //std::cout << "start  " << arc.start_point[0] << " " << arc.start_point[1] << std::endl;
                //std::cout << "end  " << arc.end_point[0] << " " << arc.end_point[1] << std::endl;
                //std::cout << "start angle   " << arc.polar_start_theta << " end angle " << arc.polar_end_theta << std::endl;
                for (int j = 0; j < n; j++) {
                    float cur_angle = arc.polar_start_theta + (float)j/n * arc.angle_radians ;
                    //std::cout << " cur_angle " << cur_angle << std::endl;
                    if (cur_angle > 2 * PI)
                        cur_angle -= 2 * PI;
                    else if (cur_angle < 0)
                        cur_angle += 2 * PI;
                    Point tmp = arc.center + Point{arc.radius * std::cos(cur_angle), arc.radius *std::sin(cur_angle)};
                    //std::cout << "j = " << j << std::endl;
                    //std::cout << "tmp  = " << tmp[0]<<" "<<tmp[1] << std::endl;
                    res.points.push_back(tmp);
                }
            }
            res.points.push_back(scaled(right));
        } else
            res.points.push_back(polygon.points[i]);
    }
    res.remove_duplicate_points();
    res.points.shrink_to_fit();
    return res;
}

References Slic3r::Arc_Dir_CCW, Slic3r::Arc_Dir_CW, Slic3r::arc_fit_size, Slic3r::center(), Slic3r::cross2(), Slic3r::Geometry::is_ccw(), PI, Slic3r::MultiPoint::points, Slic3r::MultiPoint::remove_duplicate_points(), Slic3r::scaled(), and Slic3r::unscaled().

Referenced by generate_support_wall_new(), and rib_section().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ save_on_last_wipe()

void Slic3r::WipeTower::save_on_last_wipe ( )

private

References WipeTowerWriter.

Here is the call graph for this function:

◆ set_accelerations()

void Slic3r::WipeTower::set_accelerations	(	const std::vector< double > &	normal,
		const std::vector< double > &	first_layer_normal,
		const std::vector< double > &	travel,
		const std::vector< double > &	first_layer_travel )

{
    auto to_accels = [](const std::vector<double> &values, std::vector<unsigned int> &accels) {
        accels.clear();
        for (double value : values)
            accels.emplace_back((unsigned int) floor(value + 0.5));
    };
    to_accels(normal, m_normal_accels);
    to_accels(first_layer_normal, m_first_layer_normal_accels);
    to_accels(travel, m_travel_accels);
    to_accels(first_layer_travel, m_first_layer_travel_accels);
}

References m_first_layer_normal_accels, m_first_layer_travel_accels, m_normal_accels, m_travel_accels, and Slic3r::normal().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_extruder()

void Slic3r::WipeTower::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());
 
    m_filpar[idx].material = config.filament_type.get_at(idx);
    // Orca: wipe_tower_filament (issue #10971) forces a specific filament to print the tower wall by
    // marking every other filament as "soluble"; 0 keeps the plain per-filament soluble flag.
    m_filpar[idx].is_soluble = config.wipe_tower_filament == 0 ? config.filament_soluble.get_at(idx) : (idx != size_t(config.wipe_tower_filament - 1));
    // BBS
    m_filpar[idx].is_support = config.filament_is_support.get_at(idx);
    m_filpar[idx].nozzle_temperature = config.nozzle_temperature.get_at(idx);
    m_filpar[idx].nozzle_temperature_initial_layer = config.nozzle_temperature_initial_layer.get_at(idx);
    m_filpar[idx].category = config.filament_adhesiveness_category.get_at(idx);
    m_filpar[idx].flat_iron_area = config.filament_tower_ironing_area.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.
    // BBS: remove useless config
#if 0
    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));
    }
#endif
 
    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());
 
    //set extruder change and nozzle change ramming speed
    {
        float ramming_vol_speed = float(config.filament_ramming_volumetric_speed.get_at(idx));
        if (config.filament_ramming_volumetric_speed.is_nil(idx) || is_approx(config.filament_ramming_volumetric_speed.get_at(idx), -1.)) ramming_vol_speed = max_vol_speed;
        m_filpar[idx].max_e_ramming_speed.first = (ramming_vol_speed / filament_area());
 
        float ramming_vol_speed_nc = float(config.filament_ramming_volumetric_speed_nc.get_at(idx));
        if (config.filament_ramming_volumetric_speed_nc.is_nil(idx) || is_approx(config.filament_ramming_volumetric_speed_nc.get_at(idx), -1.))
            ramming_vol_speed_nc = max_vol_speed;
        m_filpar[idx].max_e_ramming_speed.second = (ramming_vol_speed_nc / filament_area());
    }
 
    //set precooling time/precooling target temp during extruder change and nozzle change
    {
        int extruder_count = m_multi_nozzle_group_result->get_extruder_count();
        m_filpar[idx].precool_t.first.resize(extruder_count, 0.f);
        m_filpar[idx].precool_t_first_layer.first.resize(extruder_count, 0.f);
        m_filpar[idx].precool_t.second.resize(extruder_count, 0.f);
        m_filpar[idx].precool_t_first_layer.second.resize(extruder_count, 0.f);
        m_filpar[idx].precool_target_temp.first     = 0;
        m_filpar[idx].precool_target_temp.second     = 0;
        float nozzle_temp_first_layer = config.nozzle_temperature_initial_layer.is_nil(idx) ? -1.f : float(config.nozzle_temperature_initial_layer.get_at(idx));
        float nozzle_temp_other_layer = config.nozzle_temperature.is_nil(idx) ? -1.f : float(config.nozzle_temperature.get_at(idx));
        auto  is_need_precooling      = [&](bool extruder_change) -> bool
        {
            bool res = config.enable_pre_heating.value; 
            if (extruder_change) return res &&!config.filament_pre_cooling_temperature.is_nil(idx) && config.filament_pre_cooling_temperature.get_at(idx) != 0;
            return res &&!config.filament_pre_cooling_temperature_nc.is_nil(idx) && config.filament_pre_cooling_temperature_nc.get_at(idx) != 0;
        };
        if (is_need_precooling(true)) {
            for (int i = 0; i < m_filpar[idx].precool_t.first.size(); i++) {
                if (config.hotend_cooling_rate.is_nil(i)) continue;
                m_filpar[idx].precool_t.first[i] = std::max(0.f, nozzle_temp_other_layer - float(config.filament_pre_cooling_temperature.get_at(idx))) / float(config.hotend_cooling_rate.get_at(i));
                m_filpar[idx].precool_t_first_layer.first[i] = std::max(0.f, nozzle_temp_first_layer -float(config.filament_pre_cooling_temperature.get_at(idx))) /float(config.hotend_cooling_rate.get_at(i));
            }
            m_filpar[idx].precool_target_temp.first = config.filament_pre_cooling_temperature.get_at(idx);
        }
 
        if (is_need_precooling(false)) {
            for (int i = 0; i < m_filpar[idx].precool_t.second.size(); i++) {
                if (config.hotend_cooling_rate.is_nil(i)) continue;
                m_filpar[idx].precool_t.second[i] = std::max(0.f, nozzle_temp_other_layer - float(config.filament_pre_cooling_temperature_nc.get_at(idx))) / float(config.hotend_cooling_rate.get_at(i));
                m_filpar[idx].precool_t_first_layer.second[i] = std::max(0.f, nozzle_temp_first_layer -float(config.filament_pre_cooling_temperature_nc.get_at(idx))) /float(config.hotend_cooling_rate.get_at(i));
            }
            m_filpar[idx].precool_target_temp.second = config.filament_pre_cooling_temperature_nc.get_at(idx);
        }
 
    }
    //set ramming reverse travel time during extruder change and nozzle change
    {
        m_filpar[idx].ramming_travel_time = {0, 0};
        if (!config.filament_ramming_travel_time.is_nil(idx)) m_filpar[idx].ramming_travel_time.first = float(config.filament_ramming_travel_time.get_at(idx));
        if (!config.filament_ramming_travel_time_nc.is_nil(idx)) m_filpar[idx].ramming_travel_time.second = float(config.filament_ramming_travel_time_nc.get_at(idx));
    }
    m_perimeter_width = nozzle_diameter * Width_To_Nozzle_Ratio; // all extruders are now assumed to have the same diameter
    // Orca: custom presets may use nozzle diameters outside the BBS table; fall back to the
    // previous 2*perimeter_width rule (identical to the table for 0.4) instead of throwing.
    {
        auto nc_width_it = nozzle_diameter_to_nozzle_change_width.find(nozzle_diameter);
        m_nozzle_change_perimeter_width = nc_width_it != nozzle_diameter_to_nozzle_change_width.end() ? nc_width_it->second : 2.f * m_perimeter_width;
    }
    // BBS: remove useless config
#if 0
    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);
    }
#endif
 
    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);
    m_filpar[idx].wipe_dist      = config.wipe_distance.get_at(idx);
    m_filpar[idx].filament_cooling_before_tower = config.filament_cooling_before_tower.get_at(idx);
    m_filpar[idx].filament_petg_pre_extrusion_offset_dist = config.filament_tower_interface_pre_extrusion_dist.get_at(idx);
    if (config.enable_tower_interface_features.value) {
        m_filpar[idx].filament_tower_interface_print_temp = config.filament_tower_interface_print_temp.get_at(idx) == -1 ? config.nozzle_temperature_range_high.get_at(idx) :
                                                                                                                           config.filament_tower_interface_print_temp.get_at(idx);
        m_filpar[idx].filament_tower_interface_pre_extrusion_dist = config.filament_tower_interface_pre_extrusion_dist.get_at(idx);
        m_filpar[idx].filament_tower_interface_pre_extrusion_length = config.filament_tower_interface_pre_extrusion_length.get_at(idx);
    } else {
        m_filpar[idx].filament_tower_interface_print_temp = config.nozzle_temperature.get_at(idx);
        m_filpar[idx].filament_tower_interface_pre_extrusion_dist = 0.f;
        m_filpar[idx].filament_tower_interface_pre_extrusion_length = 0.f;
    }
}

References filament_area(), Slic3r::filament_map(), Slic3r::is_approx(), m_filpar, m_multi_nozzle_group_result, m_nozzle_change_perimeter_width, m_perimeter_width, M_PI, m_semm, m_used_filament_length, Slic3r::nozzle_diameter(), Slic3r::nozzle_diameter_to_nozzle_change_width, 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_filament_categories()

void Slic3r::WipeTower::set_filament_categories ( const std::vector< int > & filament_categories )

inline

411{ m_filament_categories = filament_categories;};

References m_filament_categories.

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

Here is the caller graph for this function:

◆ set_first_layer_flow_ratio()

void Slic3r::WipeTower::set_first_layer_flow_ratio ( const float flow_ratio )

{
    m_first_layer_flow_ratio = flow_ratio;
}

References m_first_layer_flow_ratio.

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

Here is the caller graph for this function:

◆ set_for_wipe_tower_writer()

void Slic3r::WipeTower::set_for_wipe_tower_writer ( WipeTowerWriter & writer )

private

{
    writer.set_normal_acceleration(m_normal_accels);
    writer.set_travel_acceleration(m_travel_accels);
    writer.set_first_layer_normal_acceleration(m_first_layer_normal_accels);
    writer.set_first_layer_travel_acceleration(m_first_layer_travel_accels);
    writer.set_max_acceleration(m_max_accels);
    writer.set_multi_nozzle_group_result(m_multi_nozzle_group_result);
    writer.set_accel_to_decel_enable(m_accel_to_decel_enable);
    writer.set_accel_to_decel_factor(m_accel_to_decel_factor);
    writer.set_first_layer(m_cur_layer_id == 0);
    writer.set_layer_id(m_cur_layer_id);
    writer.set_physical_extruder_map(m_physical_extruder_map);
}

Referenced by finish_block(), finish_block_solid(), finish_layer_new(), only_generate_out_wall(), ramming(), tool_change(), and tool_change_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_has_filament_switcher()

void Slic3r::WipeTower::set_has_filament_switcher ( bool v )

inline

242{ m_has_filament_switcher = v; }

References m_has_filament_switcher.

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

Here is the caller graph for this function:

◆ set_has_tpu_filament()

void Slic3r::WipeTower::set_has_tpu_filament ( bool has_tpu )

inline

365{ m_has_tpu_filament = has_tpu; }

References m_has_tpu_filament.

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

Here is the caller graph for this function:

◆ set_last_layer_extruder_fill()

void Slic3r::WipeTower::set_last_layer_extruder_fill ( bool extruder_fill )

inline

                                                        {
        if (!m_plan.empty()) {
      m_plan.back().extruder_fill = extruder_fill;
    }
  }

References m_plan.

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

Here is the caller graph for this function:

◆ set_layer()

void Slic3r::WipeTower::set_layer	(	float	print_z,
		float	layer_height,
		size_t	max_tool_changes,
		bool	is_first_layer,
		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_current_shape = (! is_first_layer && m_current_shape == SHAPE_NORMAL) ? SHAPE_REVERSED : SHAPE_NORMAL;
    m_current_shape = SHAPE_NORMAL;
    if (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);
        // 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;
  }

References extrusion_flow(), is_first_layer(), Slic3r::layer_height(), m_current_layer_finished, 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_z_pos, SHAPE_NORMAL, and WT_EPSILON.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_nozzle_group_result()

void Slic3r::WipeTower::set_nozzle_group_result ( const MultiNozzleUtils::LayeredNozzleGroupResult & multi_nozzle_group_result )

inline

412{ m_multi_nozzle_group_result = &multi_nozzle_group_result; };

References m_multi_nozzle_group_result.

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

Here is the caller graph for this function:

◆ set_nozzle_last_layer_id()

void Slic3r::WipeTower::set_nozzle_last_layer_id ( )

{
    for (int idx = 0; idx < m_plan.size(); idx++) {
        auto &info = m_plan[idx];
        for(int i =0 ; i<info.tool_changes.size();i++) {
            int old_tool = info.tool_changes[i].old_tool;
            int new_tool = info.tool_changes[i].new_tool;
            if (int ex = old_tool >= 0 ? get_extruder_id(old_tool, idx) : -1; ex >= 0 && ex < (int) m_last_layer_id.size())
                m_last_layer_id[ex] = idx;
            if (int ex = get_extruder_id(new_tool, idx); ex >= 0 && ex < (int) m_last_layer_id.size())
                m_last_layer_id[ex] = idx;
        }
    }
}

References get_extruder_id(), m_last_layer_id, and m_plan.

Referenced by plan_tower_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_shared_print_bed()

void Slic3r::WipeTower::set_shared_print_bed ( const Polygons & bed )

inline

239{ m_shared_print_bed = bed; }

References m_shared_print_bed.

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

Here is the caller graph for this function:

◆ set_toolchange()

WipeTower::WipeTowerInfo::ToolChange Slic3r::WipeTower::set_toolchange	(	int	old_tool,
		int	new_tool,
		float	layer_height,
		float	wipe_volume,
		float	purge_volume,
		int	layer_id )

private

{
    float depth             = 0.f;
    float width             = m_wipe_tower_width - 2 * m_perimeter_width;
    float                             nozzle_change_width     = m_wipe_tower_width - (m_nozzle_change_perimeter_width + m_perimeter_width);
    float length_to_extrude = volume_to_length(wipe_volume, m_perimeter_width, layer_height);
    float                             toolchange_gap_width    = get_block_gap_width(new_tool,false);
    float                             nozzlechange_gap_width  = get_block_gap_width(old_tool,true);
    float filament_change_length = !is_same_extruder(old_tool, new_tool, layer_id) ? at_or_front(m_filaments_change_length.first, old_tool) : at_or_front(m_filaments_change_length.second, old_tool);
    depth += std::ceil(length_to_extrude / width) * toolchange_gap_width;
    // depth *= m_extra_spacing;
 
    float nozzle_change_depth  = 0;
    float nozzle_change_length = 0;
    if (is_need_ramming(old_tool, new_tool, layer_id)) {
        double e_flow                   = nozzle_change_extrusion_flow(layer_height);
        double length                   = filament_change_length / e_flow;
        int    nozzle_change_line_count = std::ceil(length / nozzle_change_width);
        nozzle_change_depth             = nozzle_change_line_count * nozzlechange_gap_width;
        depth += nozzle_change_depth;
        nozzle_change_length = length;
    }
    WipeTowerInfo::ToolChange tool_change = WipeTowerInfo::ToolChange(old_tool, new_tool, depth, 0.f, 0.f, wipe_volume, length_to_extrude, purge_volume);
    tool_change.nozzle_change_depth       = nozzle_change_depth;
    tool_change.nozzle_change_length      = nozzle_change_length;
    return tool_change;
}

References Slic3r::at_or_front(), get_block_gap_width(), is_need_ramming(), is_same_extruder(), Slic3r::layer_height(), Slic3r::length(), m_filaments_change_length, m_nozzle_change_perimeter_width, m_perimeter_width, m_wipe_tower_width, nozzle_change_extrusion_flow(), tool_change(), volume_to_length(), and width().

Referenced by calc_block_infill_gap(), and plan_tower_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_used_filament_ids()

void Slic3r::WipeTower::set_used_filament_ids ( const std::vector< int > & used_filament_ids )

inline

410{ m_used_filament_ids = used_filament_ids; };

Slic3r::WipeTower::m_used_filament_ids

std::vector< int > m_used_filament_ids

Definition WipeTower.hpp:413

References m_used_filament_ids.

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

Here is the caller graph for this function:

◆ tool_change()

WipeTower::ToolChangeResult Slic3r::WipeTower::tool_change	(	size_t	new_tool,
		bool	extrude_perimeter = false,
		bool	first_toolchange_to_nonsoluble = false )

{
    //only for tool = unsigned (-1) ,never get here
    //m_nozzle_change_result.gcode.clear();
    //if (!m_filament_map.empty() && tool < m_filament_map.size() && m_filament_map[m_current_tool] != m_filament_map[tool]) {
    //    m_nozzle_change_result = nozzle_change(m_current_tool, tool);
    //}
 
    size_t old_tool = m_current_tool;
 
    float wipe_depth = 0.f;
  float wipe_length = 0.f;
    float purge_volume = 0.f;
    float nozzle_change_depth = 0.f;
  // Finds this toolchange info
  if (tool != (unsigned int)(-1))
  {
    for (const auto &b : m_layer_info->tool_changes)
      if ( b.new_tool == tool ) {
                wipe_length = b.wipe_length;
                wipe_depth = b.required_depth;
                purge_volume = b.purge_volume;
                nozzle_change_depth = b.nozzle_change_depth;
        break;
      }
  }
  else {
    // Otherwise we are going to Unload only. And m_layer_info would be invalid.
  }
 
    box_coordinates cleaning_box(
    Vec2f(m_perimeter_width, m_perimeter_width),
    m_wipe_tower_width - 2 * m_perimeter_width,
        (tool != (unsigned int)(-1) ? wipe_depth + m_depth_traversed - m_perimeter_width
                                    : m_wipe_tower_depth - m_perimeter_width));
 
  WipeTowerWriter 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")
    .comment_with_value(" toolchange #", m_num_tool_changes + 1); // the number is zero-based
 
    set_for_wipe_tower_writer(writer);
 
    if (tool != (unsigned)(-1))
        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.speed_override_backup();
    writer.speed_override(100);
 
    float feedrate = is_first_layer() ? std::min(m_first_layer_speed * 60.f, 5400.f) : std::min(60.0f * m_filpar[m_current_tool].max_e_speed / m_extrusion_flow, 5400.f);
 
    // Increase the extruder driver current to allow fast ramming.
    //BBS
  //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.
        writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Wipe_Tower_Start) + "\n");
        toolchange_Unload(writer, cleaning_box, m_filpar[m_current_tool].material,
                          is_first_layer() ? m_filpar[tool].nozzle_temperature_initial_layer : m_filpar[tool].nozzle_temperature);
        toolchange_Change(writer, tool, m_filpar[tool].material); // Change the tool, set a speed override for soluble and flex materials.
        toolchange_Load(writer, cleaning_box);
        // BBS
        //writer.travel(writer.x(), writer.y()-m_perimeter_width); // cooling and loading were done a bit down the road
 
        if (m_is_multi_extruder && is_tpu_filament(tool)) {
            float dy                  = 2 * m_perimeter_width;
            float nozzle_change_speed = 60.0f * m_filpar[tool].max_e_speed / m_extrusion_flow;
            nozzle_change_speed *= 0.25;
 
            const float &xl = cleaning_box.ld.x();
            const float &xr = cleaning_box.rd.x();
 
            Vec2f start_pos = m_nozzle_change_result.start_pos + Vec2f(0, m_perimeter_width);
            bool   left_to_right     = true;
            double tpu_travel_length = 5;
            double e_flow            = extrusion_flow(m_layer_height);
            double length            = tpu_travel_length / e_flow;
            int    tpu_line_count    = length / (m_wipe_tower_width - 2 * m_perimeter_width) + 1;
 
            writer.travel(start_pos);
 
            for (int i = 0; true; ++i) {
                if (left_to_right)
                    writer.travel(xr - m_perimeter_width, writer.y(), nozzle_change_speed);
                else
                    writer.travel(xl + m_perimeter_width, writer.y(), nozzle_change_speed);
 
                if (i == tpu_line_count - 1)
                    break;
 
                writer.travel(writer.x(), writer.y() + dy);
                left_to_right = !left_to_right;
            }
        }
 
        Vec2f initial_position = get_next_pos(cleaning_box, wipe_length,false);
        writer.set_initial_position(initial_position, m_wipe_tower_width, m_wipe_tower_depth, m_internal_rotation);
 
        if (extrude_perimeter) {
            box_coordinates wt_box(Vec2f(0.f, (m_current_shape == SHAPE_REVERSED) ? m_layer_info->toolchanges_depth() - m_layer_info->depth : 0.f), m_wipe_tower_width,
                                   m_layer_info->depth + m_perimeter_width);
 
            // align the perimeter
            Vec2f pos = initial_position;
            switch (m_cur_layer_id % 4){
            case 0:
                pos = wt_box.ld;
                break;
            case 1:
                pos = wt_box.rd;
                break;
            case 2:
                pos = wt_box.ru;
                break;
            case 3:
                pos = wt_box.lu;
                break;
            default: break;
            }
            writer.set_initial_position(pos, m_wipe_tower_width, m_wipe_tower_depth, m_internal_rotation);
 
            wt_box = align_perimeter(wt_box);
            writer.rectangle(wt_box, feedrate);
        }
 
        writer.travel(initial_position);
 
        toolchange_Wipe(writer, cleaning_box, wipe_length);     // Wipe the newly loaded filament until the end of the assigned wipe area.
 
        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].nozzle_temperature);
 
    m_depth_traversed += (wipe_depth - nozzle_change_depth);
 
    //BBS
  //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, true, purge_volume,false);
}

Referenced by Slic3r::Print::_make_wipe_tower(), generate_wipe_tower_blocks(), get_wall_skip_points(), plan_toolchange(), and set_toolchange().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tool_change_new()

WipeTower::ToolChangeResult Slic3r::WipeTower::tool_change_new	(	size_t	new_tool,
		bool	solid_change = false,
		bool	solid_nozzlechange = false )

{
    m_nozzle_change_result.gcode.clear();
    bool hotend_change = false;
    if (is_need_ramming(m_current_tool,new_tool, m_cur_layer_id)) {
        hotend_change = is_same_extruder(m_current_tool, new_tool, m_cur_layer_id);
        //If it is the last layer and exceeds the printable height, cancel ramming
        if (is_valid_last_layer(m_current_tool, m_cur_layer_id, m_z_pos)) m_nozzle_change_result = ramming(m_current_tool, new_tool, solid_nozzlechange, !hotend_change);
    }
 
    size_t old_tool = m_current_tool;
    float wipe_depth          = 0.f;
    float wipe_length         = 0.f;
    float purge_volume        = 0.f;
    float nozzle_change_depth = 0.f;
    int   nozzle_change_line_count = 0;
 
    if (new_tool != (unsigned int) (-1)) {
        for (const auto &b : m_layer_info->tool_changes)
            if (b.new_tool == new_tool) {
                wipe_length         = b.wipe_length;
                wipe_depth          = b.required_depth;
                purge_volume        = b.purge_volume;
                nozzle_change_depth = b.nozzle_change_depth;
                break;
            }
    }
    m_current_tool        = new_tool;
    WipeTowerBlock* block = get_block_by_category(m_filpar[new_tool].category, false);
    if (!block) {
        assert(block != nullptr);
        return WipeTower::ToolChangeResult();
    }
    m_cur_block = block;
    box_coordinates cleaning_box(Vec2f(m_perimeter_width, block->cur_depth), m_wipe_tower_width - 2 * m_perimeter_width, wipe_depth-nozzle_change_depth);
 
    WipeTowerWriter 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 + (new_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")
        .comment_with_value(" toolchange #", m_num_tool_changes + 1); // the number is zero-based
 
    set_for_wipe_tower_writer(writer);
 
    if (new_tool != (unsigned) (-1))
        writer.append( std::string("; material : " + (m_current_tool < m_filpar.size() ? m_filpar[m_current_tool].material : "(NONE)") + " -> " + m_filpar[new_tool].material + "\n").c_str())
            .append(";--------------------\n");
 
    writer.speed_override_backup();
    writer.speed_override(100);
 
    // Ram the hot material out of the melt zone, retract the filament into the cooling tubes and let it cool.
    if (new_tool != (unsigned int) -1) { // This is not the last change.
        Vec2f initial_position = get_next_pos(cleaning_box, wipe_length, solid_toolchange);
        writer.set_initial_position(initial_position, m_wipe_tower_width, m_wipe_tower_depth, m_internal_rotation);
 
        writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Wipe_Tower_Start) + "\n");
        toolchange_Unload(writer, cleaning_box, m_filpar[m_current_tool].material,
                          is_first_layer() ? m_filpar[new_tool].nozzle_temperature_initial_layer : m_filpar[new_tool].nozzle_temperature);
        toolchange_Change(writer, new_tool, m_filpar[new_tool].material); // Change the tool, set a speed override for soluble and flex materials.
        toolchange_Load(writer, cleaning_box);
# if 0
        if (m_is_multi_extruder && is_need_reverse_travel(new_tool)) {
            float dy = m_layer_info->extra_spacing * m_nozzle_change_perimeter_width;
            if (m_layer_info->extra_spacing < m_tpu_fixed_spacing) {
                dy = m_tpu_fixed_spacing * m_nozzle_change_perimeter_width;
            }
 
            float nozzle_change_speed = 60.0f * m_filpar[new_tool].max_e_speed / m_extrusion_flow;
            nozzle_change_speed *= 0.25;
 
            const float &xl = cleaning_box.ld.x();
            const float &xr = cleaning_box.rd.x();
 
            Vec2f  start_pos         = m_nozzle_change_result.origin_start_pos + Vec2f(0, m_nozzle_change_perimeter_width);
            bool   left_to_right     = true;
            int tpu_line_count = (nozzle_change_line_count + 2 - 1) / 2; // nozzle_change_line_count / 2 round up
 
            writer.travel(start_pos);
 
            for (int i = 0; true; ++i) {
                if (left_to_right)
                    writer.travel(xr - m_perimeter_width, writer.y(), nozzle_change_speed);
                else
                    writer.travel(xl + m_perimeter_width, writer.y(), nozzle_change_speed);
 
                if (i == tpu_line_count - 1) break;
 
                writer.travel(writer.x(), writer.y() + dy);
                left_to_right = !left_to_right;
            }
            writer.travel(initial_position);
        }
#endif
        toolchange_wipe_new(writer, cleaning_box, wipe_length, solid_toolchange);
 
        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].nozzle_temperature);
 
    block->cur_depth += (wipe_depth - nozzle_change_depth);
    block->last_filament_change_id = new_tool;
 
    // BBS
    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, true, purge_volume, solid_toolchange);
}

Referenced by generate_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toolchange_Change()

void Slic3r::WipeTower::toolchange_Change	(	WipeTowerWriter &	writer,
		const size_t	new_tool,
		const std::string &	new_material )

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("[filament_end_gcode]\n");
    writer.append("[change_filament_gcode]\n");
 
    // BBS: do travel in GCode::append_tcr() for lazy_lift
#if 0
    // 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)
          .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");
#endif
 
    // 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;
}

References Slic3r::WipeTowerWriter::append(), Slic3r::WipeTowerWriter::feedrate(), Slic3r::float_to_string_decimal_point(), Slic3r::WipeTowerWriter::flush_planner_queue(), Slic3r::WipeTowerWriter::get_and_reset_used_filament_length(), m_current_tool, m_travel_speed, m_used_filament_length, never_skip_tag(), Slic3r::WipeTowerWriter::pos_rotated(), Slic3r::WipeTowerWriter::set_tool(), and WipeTowerWriter.

Referenced by tool_change(), and tool_change_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toolchange_Load()

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

private

{
    // BBS: tool load is done in change_filament_gcode
#if 0
    if (m_semm && (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);
    }
#endif
}

Referenced by tool_change(), and tool_change_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toolchange_Unload()

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

private

{
    // BBS: toolchange unload is done in change_filament_gcode
#if 0
  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; // spacing between lines in mm
 
    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
 
  writer.travel(xl, cleaning_box.ld.y() + m_depth_traversed + y_step/2.f ); // move to starting position
 
    // if the ending point of the ram would end up in mid air, align it with the end of the wipe tower:
    if (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-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;
        }
    }
 
    writer.disable_linear_advance();
 
    // now the ramming itself:
    while (i < m_filpar[m_current_tool].ramming_speed.size())
    {
        const float x = volume_to_length(m_filpar[m_current_tool].ramming_speed[i] * 0.25f, line_width, m_layer_height);
        const float e = m_filpar[m_current_tool].ramming_speed[i] * 0.25f / 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 0.25s, or to the next turnaround
        const float actual_time = dist/x * 0.25f;
        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;
    }
  }
  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:
    float old_x = writer.x();
    float turning_point = (!m_left_to_right ? xl : xr );
    if (m_semm && (m_cooling_tube_retraction != 0 || m_cooling_tube_length != 0)) {
        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();
    }
    // 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()) ) {  // 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).
            writer.set_extruder_temp(new_temperature, false);
            m_old_temperature = new_temperature;
        }
    }
 
    // Cooling:
    const int& number_of_moves = m_filpar[m_current_tool].cooling_moves;
    if (number_of_moves > 0) {
        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_moves - 1.f);
 
        writer.suppress_preview()
              .travel(writer.x(), writer.y() + y_step);
        old_x = writer.x();
        turning_point = xr-old_x > old_x-xl ? xr : xl;
        for (int i=0; i<number_of_moves; ++i) {
            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);
        }
    }
 
    // 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:
    writer.retract(-m_cooling_tube_length/2.f+m_parking_pos_retraction-m_cooling_tube_retraction, 2000);
 
  // 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
  writer.travel(end_of_ramming.x(), end_of_ramming.y() + (y_step/m_extra_spacing-m_perimeter_width) / 2.f + m_perimeter_width, 2400.f);
 
  writer.resume_preview()
      .flush_planner_queue();
#endif
}

Referenced by tool_change(), and tool_change_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toolchange_Wipe()

void Slic3r::WipeTower::toolchange_Wipe	(	WipeTowerWriter &	writer,
		const box_coordinates &	cleaning_box,
		float	wipe_volume )

private

{
  // Increase flow on first layer, slow down print.
    writer.set_extrusion_flow(m_extrusion_flow * (is_first_layer() ? m_first_layer_flow_ratio : 1.f))
      .append("; CP TOOLCHANGE WIPE\n");
 
    // BBS: add the note for gcode-check, when the flow changed, the width should follow the change
    if (is_first_layer()) {
        writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Width) + Slic3r::float_to_string_decimal_point(m_first_layer_flow_ratio * m_perimeter_width, 6) + "\n");
    }
 
  const float& xl = cleaning_box.ld.x();
  const float& xr = cleaning_box.rd.x();
 
  // 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 = wipe_length;
    float dy = m_layer_info->extra_spacing * m_perimeter_width;
 
    const float target_speed = is_first_layer() ? std::min(m_first_layer_speed * 60.f, 4800.f) : 4800.f;
    float wipe_speed = 0.33f * target_speed;
 
    float start_y = writer.y();
 
#if 0
    // if there is less than 2.5*m_perimeter_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*m_perimeter_width) {
        writer.travel((m_left_to_right ? xr-m_perimeter_width : xl+m_perimeter_width),writer.y()+dy);
        m_left_to_right = !m_left_to_right;
    }
#endif
 
    m_left_to_right = ((m_cur_layer_id + 3) % 4 >= 2);
    bool is_from_up = (m_cur_layer_id % 2 == 1);
 
    // BBS: do not need to move dy
#if 0
    if (m_depth_traversed != 0)
        writer.travel(xl, writer.y() + dy);
#endif
 
    bool need_change_flow = false;
    // 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);
    }
 
        // BBS: check the bridging area and use the bridge flow
        if (need_change_flow || need_thick_bridge_flow(writer.y())) {
            writer.set_extrusion_flow(extrusion_flow(0.2));
            writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height) + Slic3r::float_to_string_decimal_point(0.2, 6) + "\n");
            need_change_flow = true;
        }
 
        if (m_left_to_right)
            writer.extrude(xr + wipe_tower_wall_infill_overlap * m_perimeter_width, writer.y(), wipe_speed);
        else
            writer.extrude(xl - wipe_tower_wall_infill_overlap * m_perimeter_width, writer.y(), wipe_speed);
 
        // BBS: recover the flow in non-bridging area
        if (need_change_flow) {
            writer.set_extrusion_flow(m_extrusion_flow);
            writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height) + Slic3r::float_to_string_decimal_point(m_layer_height, 6) + "\n");
        }
 
        if (!is_from_up && (writer.y() - float(EPSILON) > cleaning_box.lu.y()))
            break;    // in case next line would not fit
 
        if (is_from_up && (writer.y() + float(EPSILON) < cleaning_box.ld.y()))
            break;
 
        x_to_wipe -= (xr - xl);
    if (x_to_wipe < WT_EPSILON) {
            // BBS: Delete some unnecessary travel
            //writer.travel(m_left_to_right ? xl + 1.5f*m_perimeter_width : xr - 1.5f*m_perimeter_width, writer.y(), 7200);
      break;
    }
    // stepping to the next line:
        if (is_from_up)
            writer.extrude(writer.x(), writer.y() - dy);
        else
            writer.extrude(writer.x(), writer.y() + dy);
 
    m_left_to_right = !m_left_to_right;
  }
 
    float end_y = writer.y();
 
    // 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);
    // BBS: modify the wipe_path after toolchange
    writer.add_wipe_point(writer.x(), writer.y())
          .add_wipe_point(! m_left_to_right ? m_wipe_tower_width : 0.f, writer.y());
 
    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.
    // BBS: add the note for gcode-check when the flow changed
    if (is_first_layer()) {
        writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Width) + Slic3r::float_to_string_decimal_point(m_perimeter_width, 6) + "\n");
    }
}

References Slic3r::WipeTowerWriter::add_wipe_point(), Slic3r::WipeTowerWriter::append(), EPSILON, Slic3r::WipeTowerWriter::extrude(), extrusion_flow(), Slic3r::float_to_string_decimal_point(), Slic3r::GCodeProcessor::Height, is_first_layer(), Slic3r::WipeTower::box_coordinates::ld, Slic3r::WipeTower::box_coordinates::lu, m_cur_layer_id, m_current_tool, m_depth_traversed, m_extrusion_flow, m_first_layer_flow_ratio, m_first_layer_speed, m_layer_height, m_layer_info, m_left_to_right, m_perimeter_width, m_plan, m_wipe_tower_width, need_thick_bridge_flow(), Slic3r::WipeTower::box_coordinates::rd, Slic3r::GCodeProcessor::reserved_tag(), Slic3r::WipeTowerWriter::set_extrusion_flow(), Slic3r::WipeTowerWriter::travel(), Slic3r::GCodeProcessor::Width, Slic3r::wipe_tower_wall_infill_overlap, WipeTowerWriter, WT_EPSILON, Slic3r::WipeTowerWriter::x(), and Slic3r::WipeTowerWriter::y().

Referenced by tool_change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toolchange_wipe_new()

void Slic3r::WipeTower::toolchange_wipe_new	(	WipeTowerWriter &	writer,
		const box_coordinates &	cleaning_box,
		float	wipe_length,
		bool	solid_toolchange = false )

{
    writer.set_extrusion_flow(m_extrusion_flow * (is_first_layer() ? m_first_layer_flow_ratio : 1.f))
          // Orca: CP_TOOLCHANGE_WIPE is a standalone tag constant, not an ETags entry
          .append(";" + GCodeProcessor::Toolchange_Wipe_Tag + " CT" + std::to_string(solid_tool_toolchange) + " FL" + std::to_string(is_first_layer()) + "\n");
    if (!m_nozzle_change_result.gcode.empty())
        writer.change_analyzer_line_width(m_perimeter_width);
 
    // BBS: add the note for gcode-check, when the flow changed, the width should follow the change
    if (is_first_layer()) {
        writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Width) + Slic3r::float_to_string_decimal_point(m_first_layer_flow_ratio * m_perimeter_width, 6) + "\n");
    }
 
    //if (solid_tool_toolchange && m_filpar[m_current_tool].filament_tower_interface_print_temp != m_filpar[m_current_tool].nozzle_temperature)
    //    writer.append(format_line_M109(m_filpar[m_current_tool].filament_tower_interface_print_temp, m_filament_map[this->m_current_tool] - 1));
    //if (solid_tool_toolchange && m_filpar[m_current_tool].filament_tower_interface_pre_extrusion_length != 0)
    //    writer.retract(-m_filpar[m_current_tool].filament_tower_interface_pre_extrusion_length, 100.f);
 
    float        retract_length = m_filpar[m_current_tool].retract_length;
    float        retract_speed  = m_filpar[m_current_tool].retract_speed * 60;
    const float &xl = cleaning_box.ld.x();
    const float &xr = cleaning_box.rd.x();
    bool         should_flat_ironging = m_flat_ironing;
    bool         should_line_ironing  = true;
    if (!m_contact_ironing && solid_tool_toolchange) {
        should_flat_ironging     = false;
        should_line_ironing = false;
    }
    bool  should_cooling_before_tower = !solid_tool_toolchange;
    bool  should_cooling_before_object = false;//interface layer heating print tower, then cooling print object
    int cooling_begin_line = 2;
    float x_to_wipe = wipe_length;
    float dy                 = is_first_layer() ? m_perimeter_width : m_layer_info->extra_spacing * get_block_gap_width(m_current_tool,false);
    if (solid_tool_toolchange)
        dy = m_perimeter_width;
    x_to_wipe                = solid_tool_toolchange ? std::numeric_limits<float>::max(): x_to_wipe;
    float target_speed       = is_first_layer() ? std::min(m_first_layer_speed * 60.f, m_max_speed) : m_max_speed;
    target_speed             = solid_tool_toolchange ? m_contact_speed : target_speed;
    const std::vector<float> WipeSpeedMap{0.33f * target_speed, 0.375f * target_speed, 0.458f * target_speed, 0.875f * target_speed,
                                                       std::min(target_speed, 0.875f * target_speed + 50.f)};
    float                    wipe_speed = WipeSpeedMap[0];
 
    m_left_to_right = ((m_cur_layer_id + 3) % 4 >= 2);
 
    bool is_from_up = (m_cur_layer_id % 2 == 1);
 
    auto estimate_time_kernel = [&WipeSpeedMap,&xr,&xl](int n) {
        float time = std::numeric_limits<float>::max();
        float one_line_len = xr - xl;
        if (n <= 1)
            time = one_line_len / WipeSpeedMap[0];
        else if (n <= 2)
            time = one_line_len / WipeSpeedMap[0] + one_line_len / WipeSpeedMap[1];
        else if (n <= 3)
            time = one_line_len / WipeSpeedMap[0] + one_line_len / WipeSpeedMap[1] + one_line_len / WipeSpeedMap[2];
        else if (n <= 4)
            time = one_line_len / WipeSpeedMap[0] + one_line_len / WipeSpeedMap[1] + one_line_len / WipeSpeedMap[2] + one_line_len / WipeSpeedMap[3];
        else {
            time = one_line_len / WipeSpeedMap[0] + one_line_len / WipeSpeedMap[1] + one_line_len / WipeSpeedMap[2] + one_line_len / WipeSpeedMap[3];
            time += (n - 4) * one_line_len / WipeSpeedMap[4];
        }
        return time * 60.f;
    };
    auto estimate_wipe_time = [&estimate_time_kernel, & cleaning_box, &x_to_wipe, &xr, &xl, &dy, &solid_tool_toolchange](int begin_line) -> float {
        int                      n            = std::ceil(x_to_wipe / (xr - xl));
        if (solid_tool_toolchange) n = (cleaning_box.lu[1] - cleaning_box.ld[1]) / dy;
        float total_time   = estimate_time_kernel(n);
        float beg_time   = n <= 0 ? 0 : estimate_time_kernel(begin_line);
        return total_time-beg_time;
    };
 
    bool should_heating = m_filpar[m_current_tool].filament_cooling_before_tower > EPSILON && !solid_tool_toolchange && !is_first_layer();
    auto add_M104_by_requirement = [&writer, &should_heating, this]() {
        if (m_filpar[m_current_tool].filament_cooling_before_tower < EPSILON) return;
        if (!should_heating) return;
        float target_temp = is_first_layer() ? m_filpar[m_current_tool].nozzle_temperature_initial_layer : m_filpar[m_current_tool].nozzle_temperature;
        writer.format_line_M104(target_temp, get_extruder_id(m_current_tool, m_cur_layer_id));
    };
    float speed_factor = 1.f;
    if (should_heating)
    {
        //No additional heating time is required.
        //float estimate_time = estimate_wipe_time(0);
        //int   extruder_id   = m_filament_map[m_current_tool] - 1;
        //float heat_time     = m_filpar[m_current_tool].filament_cooling_before_tower / m_hotend_heating_rate[extruder_id];
        //heat_time /= 2.f;
        //speed_factor = estimate_time / (heat_time+estimate_time);
        //wipe_speed *= speed_factor;
    }
    if (should_cooling_before_object) {
        int n = (cleaning_box.lu[1] - cleaning_box.ld[1]) / dy;
        int extruder_id = get_extruder_id(m_current_tool, m_cur_layer_id);
        float cooling_time     = (m_filpar[m_current_tool].filament_tower_interface_print_temp - m_filpar[m_current_tool].nozzle_temperature) / at_or_front(m_hotend_cooling_rate, extruder_id);
        if (n < 2) {
            float estimate_time = estimate_wipe_time(0);
            speed_factor        = estimate_time > cooling_time? 1: estimate_time / cooling_time;
            cooling_begin_line = 0;
        } else {
            float estimate_time = estimate_wipe_time(2);
            speed_factor        = estimate_time > cooling_time ? 1 : estimate_time / cooling_time;
            cooling_begin_line = 2; //TODO: No slowdown for the first two lines.
        }
        wipe_speed *= speed_factor;
    }
 
 
    for (int i = 0; true; ++i) {
        if (i < WipeSpeedMap.size()) wipe_speed = WipeSpeedMap[i] * speed_factor;
 
        bool need_change_flow = need_thick_bridge_flow(writer.y());
        // BBS: check the bridging area and use the bridge flow
        if (need_change_flow) {
            writer.set_extrusion_flow(extrusion_flow(0.2));
            writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height) + Slic3r::float_to_string_decimal_point(0.2, 6) + "\n");
        }
        float flat_iron_area = m_filpar[m_current_tool].flat_iron_area;
        float ironing_length = 3.;
 
        if (should_cooling_before_object && i == cooling_begin_line) {
            writer.format_line_M104(m_filpar[m_current_tool].nozzle_temperature, get_extruder_id(m_current_tool, m_cur_layer_id));
        }
 
        if (i == 0 && m_use_gap_wall) { // BBS: add ironing after extruding start
            if (m_left_to_right) {
                if (should_line_ironing) {
                    float dx = xr + wipe_tower_wall_infill_overlap * m_perimeter_width - writer.pos().x();
                    if (abs(dx) < ironing_length) ironing_length = abs(dx);
                    writer.extrude(writer.x() + ironing_length, writer.y(), wipe_speed);
                    writer.retract(retract_length, retract_speed);
                    writer.travel(writer.x() - 1.5 * ironing_length, writer.y(), 600.);
                    if (should_flat_ironging) {
                        writer.travel(writer.x() + 0.5f * ironing_length, writer.y(), 240.);
                        Vec2f pos{writer.x() + 1.f * ironing_length, writer.y()};
                        writer.spiral_flat_ironing(writer.pos(), flat_iron_area, m_perimeter_width, flat_iron_speed);
                        writer.travel(pos, wipe_speed);
                    } else
                        writer.travel(writer.x() + 1.5 * ironing_length, writer.y(), 240.);
                    writer.retract(-retract_length, retract_speed);
                }
                add_M104_by_requirement();
                writer.extrude(xr + wipe_tower_wall_infill_overlap * m_perimeter_width, writer.y(), wipe_speed);
            } else {
                if (should_line_ironing) {
                    float dx = xl - wipe_tower_wall_infill_overlap * m_perimeter_width - writer.pos().x();
                    if (abs(dx) < ironing_length) ironing_length = abs(dx);
                    writer.extrude(writer.x() - ironing_length, writer.y(), wipe_speed);
                    writer.retract(retract_length, retract_speed);
                    writer.travel(writer.x() + 1.5 * ironing_length, writer.y(), 600.);
                    if (should_flat_ironging) {
                        writer.travel(writer.x() - 0.5f * ironing_length, writer.y(), 240.);
                        Vec2f pos{writer.x() - 1.0f * ironing_length, writer.y()};
                        writer.spiral_flat_ironing(writer.pos(), flat_iron_area, m_perimeter_width, flat_iron_speed);
                        writer.travel(pos, wipe_speed);
                    } else
                        writer.travel(writer.x() - 1.5 * ironing_length, writer.y(), 240.);
                    writer.retract(-retract_length, retract_speed);
                }
                add_M104_by_requirement();
                writer.extrude(xl - wipe_tower_wall_infill_overlap * m_perimeter_width, writer.y(), wipe_speed);
            }
        } else {
            if (i == 0) add_M104_by_requirement();
            if (m_left_to_right)
                writer.extrude(xr + wipe_tower_wall_infill_overlap * m_perimeter_width, writer.y(), wipe_speed);
            else
                writer.extrude(xl - wipe_tower_wall_infill_overlap * m_perimeter_width, writer.y(), wipe_speed);
        }
 
        // BBS: recover the flow in non-bridging area
        if (need_change_flow) {
            writer.set_extrusion_flow(m_extrusion_flow);
            writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height) + Slic3r::float_to_string_decimal_point(m_layer_height, 6) + "\n");
        }
 
        if (!is_from_up && (writer.y() + dy - float(EPSILON) >cleaning_box.lu.y() - m_perimeter_width))
            break; // in case next line would not fit
 
        if (is_from_up && (writer.y() - dy+ float(EPSILON))<cleaning_box.ld.y()) // Because the top of the clean box cannot have wiring, but the bottom can have wiring.
            break;
 
        x_to_wipe -= (xr - xl);
        if (x_to_wipe < WT_EPSILON) {
            // BBS: Delete some unnecessary travel
            // writer.travel(m_left_to_right ? xl + 1.5f*m_perimeter_width : xr - 1.5f*m_perimeter_width, writer.y(), 7200);
            break;
        }
        // stepping to the next line:
        if (is_from_up)
            writer.extrude(writer.x(), writer.y() - dy);
        else
            writer.extrude(writer.x(), writer.y() + dy);
 
        m_left_to_right = !m_left_to_right;
    }
 
    writer.add_wipe_point(writer.x(), writer.y()).add_wipe_point(!m_left_to_right ? m_wipe_tower_width : 0.f, writer.y());
 
    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.
    // BBS: add the note for gcode-check when the flow changed
    if (is_first_layer()) { writer.append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Width) + Slic3r::float_to_string_decimal_point(m_perimeter_width, 6) + "\n"); }
}

Referenced by tool_change_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_all_layer_depth()

void Slic3r::WipeTower::update_all_layer_depth ( float wipe_tower_depth )

{
    m_wipe_tower_depth = 0.f;
    float start_offset = m_perimeter_width;
    float start_depth = start_offset;
    for (auto& block : m_wipe_tower_blocks) {
        block.depth *= m_extra_spacing;
        block.start_depth = start_depth;
        start_depth += block.depth;
        m_wipe_tower_depth += block.depth;
 
        for (auto& layer_depth : block.layer_depths) {
            layer_depth *= m_extra_spacing;
        }
 
        for (WipeTowerInfo& plan_info : m_plan) {
            plan_info.depth *= m_extra_spacing;
        }
    }
    if (m_wipe_tower_depth > 0)
        m_wipe_tower_depth += start_offset;
 
    if (m_enable_wrapping_detection || m_enable_timelapse_print) {
        if (is_approx(m_wipe_tower_depth, 0.f))
            m_wipe_tower_depth = wipe_tower_depth;
        for (WipeTowerInfo &plan_info : m_plan) {
            plan_info.depth = m_wipe_tower_depth;
        }
    }
}

References Slic3r::is_approx(), m_enable_timelapse_print, m_enable_wrapping_detection, m_extra_spacing, m_perimeter_width, m_plan, m_wipe_tower_blocks, and m_wipe_tower_depth.

Referenced by plan_tower_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ volume_to_length()

float Slic3r::WipeTower::volume_to_length	(	float	volume,
		float	line_width,
		float	layer_height ) const

inlineprivate

                                                                                   {
    return std::max(0.f, volume / (layer_height * (line_width - layer_height * (1.f - float(M_PI) / 4.f))));
  }

References Slic3r::layer_height(), and M_PI.

Referenced by plan_toolchange(), plan_tower_new(), set_toolchange(), and toolchange_Unload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ width()

float Slic3r::WipeTower::width ( ) const

inline

315{ return m_wipe_tower_width; }

References m_wipe_tower_width.

Referenced by Slic3r::WipeTower::box_coordinates::box_coordinates(), Slic3r::WipeTower::box_coordinates::box_coordinates(), Slic3r::Print::_make_wipe_tower(), estimate_rib_tower_bbox_side(), estimate_tower_blocks_depth(), its_make_rib_tower(), plan_toolchange(), rib_footprint_side(), rib_section(), and set_toolchange().

Here is the caller graph for this function:

◆ WipeTowerWriter

friend class WipeTowerWriter

friend

Member Data Documentation

◆ m_accel_to_decel_enable

bool Slic3r::WipeTower::m_accel_to_decel_enable

private

Referenced by WipeTower(), and set_for_wipe_tower_writer().

◆ m_accel_to_decel_factor

float Slic3r::WipeTower::m_accel_to_decel_factor

private

Referenced by WipeTower(), and set_for_wipe_tower_writer().

◆ m_adhesion

bool Slic3r::WipeTower::m_adhesion = true

private

Referenced by finish_block(), finish_layer_new(), and toolchange_Unload().

◆ m_all_layers_depth

std::vector<std::vector<BlockDepthInfo> > Slic3r::WipeTower::m_all_layers_depth

Referenced by add_depth_to_block(), and generate_wipe_tower_blocks().

◆ m_bed_bottom_left

Vec2f Slic3r::WipeTower::m_bed_bottom_left

private

Referenced by WipeTower().

◆ []

enum { ... } Slic3r::WipeTower::m_bed_shape

Referenced by WipeTower().

◆ m_bed_width

float Slic3r::WipeTower::m_bed_width

private

Referenced by WipeTower().

◆ m_block_infill_gap_width

std::unordered_map<int, std::pair<float,float> > Slic3r::WipeTower::m_block_infill_gap_width

private

Referenced by calc_block_infill_gap(), and get_block_gap_width().

◆ m_bridging

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

private

Referenced by WipeTower(), finish_block(), and finish_layer_new().

◆ m_contact_ironing

bool Slic3r::WipeTower::m_contact_ironing = false

private

Referenced by toolchange_wipe_new().

◆ m_contact_speed

float Slic3r::WipeTower::m_contact_speed = 20 * 60.f

private

Referenced by WipeTower(), and toolchange_wipe_new().

◆ m_cur_block

WipeTowerBlock* Slic3r::WipeTower::m_cur_block {nullptr}

444{nullptr};

Referenced by get_floating_area(), ramming(), and tool_change_new().

◆ m_cur_layer_id

size_t Slic3r::WipeTower::m_cur_layer_id

private

Referenced by add_depth_to_block(), finish_block(), finish_block_solid(), finish_layer_new(), generate_new(), generate_support_wall(), generate_support_wall_new(), generate_wipe_tower_blocks(), get_floating_area(), get_next_pos(), ramming(), set_for_wipe_tower_writer(), tool_change(), tool_change_new(), toolchange_Wipe(), and toolchange_wipe_new().

◆ m_current_layer_finished

bool Slic3r::WipeTower::m_current_layer_finished = false

private

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

◆ m_current_shape

wipe_shape Slic3r::WipeTower::m_current_shape = SHAPE_NORMAL

private

Referenced by finish_block(), finish_block_solid(), finish_layer_new(), only_generate_out_wall(), ramming(), set_layer(), tool_change(), tool_change_new(), and toolchange_Unload().

◆ m_current_tool

size_t Slic3r::WipeTower::m_current_tool = 0

private

Referenced by WipeTower(), construct_tcr(), finish_block_solid(), finish_layer_new(), generate_new(), generate_support_wall(), generate_support_wall_new(), get_next_pos(), get_wall_filament_for_all_layer(), only_generate_out_wall(), ramming(), tool_change(), tool_change_new(), toolchange_Change(), toolchange_Load(), toolchange_Unload(), toolchange_Wipe(), and toolchange_wipe_new().

◆ m_depth_traversed

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

private

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

◆ m_enable_arc_fitting

bool Slic3r::WipeTower::m_enable_arc_fitting = true

private

Referenced by WipeTower(), finish_block(), finish_block_solid(), finish_layer_new(), only_generate_out_wall(), ramming(), tool_change(), and tool_change_new().

◆ m_enable_timelapse_print

bool Slic3r::WipeTower::m_enable_timelapse_print = false

private

Referenced by WipeTower(), generate_new(), only_generate_out_wall(), plan_tower_new(), and update_all_layer_depth().

◆ m_enable_tower_interface_features

bool Slic3r::WipeTower::m_enable_tower_interface_features {false}

private

529{false};

Referenced by WipeTower(), finish_block_solid(), get_next_pos(), and get_wall_skip_points().

◆ m_enable_wrapping_detection

bool Slic3r::WipeTower::m_enable_wrapping_detection = false

private

Referenced by WipeTower(), generate_new(), only_generate_out_wall(), plan_tower_new(), and update_all_layer_depth().

◆ m_extra_rib_length

float Slic3r::WipeTower::m_extra_rib_length =0.f

private

Referenced by WipeTower(), and plan_tower_new().

◆ m_extra_spacing

float Slic3r::WipeTower::m_extra_spacing = 1.f

private

Referenced by WipeTower(), align_perimeter(), calc_block_infill_gap(), generate_new(), plan_toolchange(), plan_tower_new(), toolchange_Unload(), and update_all_layer_depth().

◆ m_extrusion_flow

float Slic3r::WipeTower::m_extrusion_flow = 0.038f

private

Referenced by extrusion_flow(), finish_block(), finish_block_solid(), finish_layer_new(), get_extrusion_flow(), nozzle_change_extrusion_flow(), only_generate_out_wall(), set_layer(), tool_change(), tool_change_new(), toolchange_Wipe(), and toolchange_wipe_new().

◆ m_filament_categories

std::vector<int> Slic3r::WipeTower::m_filament_categories

Referenced by get_filament_category(), and set_filament_categories().

◆ m_filaments_change_length

std::pair<std::vector<double>,std::vector<double> > Slic3r::WipeTower::m_filaments_change_length

private

Referenced by WipeTower(), is_need_reverse_travel(), plan_toolchange(), and set_toolchange().

◆ m_filpar

◆ m_first_layer_flow_ratio

float Slic3r::WipeTower::m_first_layer_flow_ratio

private

Referenced by set_first_layer_flow_ratio(), toolchange_Wipe(), and toolchange_wipe_new().

◆ m_first_layer_idx

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

private

Referenced by finish_layer_new(), generate_new(), is_first_layer(), and plan_toolchange().

◆ m_first_layer_normal_accels

std::vector<unsigned int> Slic3r::WipeTower::m_first_layer_normal_accels

private

Referenced by set_accelerations(), and set_for_wipe_tower_writer().

◆ m_first_layer_speed

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

private

Referenced by WipeTower(), finish_block(), finish_block_solid(), finish_layer_new(), only_generate_out_wall(), tool_change(), toolchange_Wipe(), and toolchange_wipe_new().

◆ m_first_layer_travel_accels

std::vector<unsigned int> Slic3r::WipeTower::m_first_layer_travel_accels

private

Referenced by set_accelerations(), and set_for_wipe_tower_writer().

◆ m_flat_ironing

bool Slic3r::WipeTower::m_flat_ironing =false

private

Referenced by WipeTower(), and toolchange_wipe_new().

◆ m_gcode_flavor

GCodeFlavor Slic3r::WipeTower::m_gcode_flavor

private

Referenced by WipeTower(), finish_block(), finish_block_solid(), finish_layer_new(), only_generate_out_wall(), ramming(), tool_change(), and tool_change_new().

◆ m_has_filament_switcher

bool Slic3r::WipeTower::m_has_filament_switcher = false

private

Referenced by get_next_pos(), and set_has_filament_switcher().

◆ m_has_tpu_filament

bool Slic3r::WipeTower::m_has_tpu_filament {false}

private

518{false};

Referenced by has_tpu_filament(), and set_has_tpu_filament().

◆ m_hotend_cooling_rate

std::vector<double> Slic3r::WipeTower::m_hotend_cooling_rate

private

Referenced by WipeTower(), and toolchange_wipe_new().

◆ m_hotend_heating_rate

std::vector<double> Slic3r::WipeTower::m_hotend_heating_rate

private

Referenced by WipeTower().

◆ m_internal_rotation

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

private

Referenced by finish_block(), finish_block_solid(), finish_layer_new(), only_generate_out_wall(), ramming(), tool_change(), and tool_change_new().

◆ m_is_multi_extruder

bool Slic3r::WipeTower::m_is_multi_extruder {false}

private

519{false};

Referenced by WipeTower(), tool_change(), and tool_change_new().

◆ m_is_multiple_nozzle

bool Slic3r::WipeTower::m_is_multiple_nozzle = false

private

Referenced by WipeTower().

◆ m_last_block_id

int Slic3r::WipeTower::m_last_block_id

◆ m_last_layer_id

std::vector<int> Slic3r::WipeTower::m_last_layer_id

private

Referenced by WipeTower(), is_valid_last_layer(), and set_nozzle_last_layer_id().

◆ m_layer_height

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

private

Referenced by construct_block_tcr(), construct_tcr(), finish_block(), finish_block_solid(), finish_layer_new(), get_layer_height(), need_thick_bridge_flow(), only_generate_out_wall(), ramming(), set_layer(), tool_change(), tool_change_new(), toolchange_Unload(), toolchange_Wipe(), and toolchange_wipe_new().

◆ m_layer_info

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

private

Referenced by finish_block(), finish_block_solid(), finish_layer_new(), generate_new(), get_floating_area(), get_next_pos(), is_first_layer(), layer_is_printed(), only_generate_out_wall(), ramming(), set_layer(), tool_change(), tool_change_new(), toolchange_Unload(), toolchange_Wipe(), and toolchange_wipe_new().

◆ m_left_to_right

bool Slic3r::WipeTower::m_left_to_right = true

private

Referenced by finish_block(), finish_block_solid(), finish_layer_new(), only_generate_out_wall(), ramming(), toolchange_Unload(), toolchange_Wipe(), and toolchange_wipe_new().

◆ m_max_accels

unsigned int Slic3r::WipeTower::m_max_accels

private

Referenced by WipeTower(), and set_for_wipe_tower_writer().

◆ m_max_color_changes

size_t Slic3r::WipeTower::m_max_color_changes = 0

private

Referenced by finished().

◆ m_max_speed

float Slic3r::WipeTower::m_max_speed = 5400.f

private

Referenced by WipeTower(), finish_block(), finish_block_solid(), finish_layer_new(), merge_tcr(), only_generate_out_wall(), and toolchange_wipe_new().

◆ m_multi_nozzle_group_result

const MultiNozzleUtils::LayeredNozzleGroupResult* Slic3r::WipeTower::m_multi_nozzle_group_result {nullptr}

415{nullptr};

Referenced by get_extruder_id(), get_nozzle_id(), is_need_ramming(), is_same_extruder(), is_same_nozzle(), ramming(), set_extruder(), set_for_wipe_tower_writer(), and set_nozzle_group_result().

◆ m_need_reverse_travel

bool Slic3r::WipeTower::m_need_reverse_travel {false}

private

528{false};

◆ m_normal_accels

std::vector<unsigned int> Slic3r::WipeTower::m_normal_accels

private

Referenced by set_accelerations(), and set_for_wipe_tower_writer().

◆ m_nozzle_change_perimeter_width

float Slic3r::WipeTower::m_nozzle_change_perimeter_width = 0.4f * Width_To_Nozzle_Ratio

private

Referenced by calc_block_infill_gap(), get_block_gap_width(), nozzle_change_extrusion_flow(), plan_toolchange(), plan_tower_new(), ramming(), set_extruder(), set_toolchange(), and tool_change_new().

◆ m_nozzle_change_result

NozzleChangeResult Slic3r::WipeTower::m_nozzle_change_result

private

Referenced by construct_tcr(), finish_layer_new(), tool_change(), tool_change_new(), and toolchange_wipe_new().

◆ m_num_layer_changes

unsigned int Slic3r::WipeTower::m_num_layer_changes = 0

private

Referenced by finish_block(), finish_block_solid(), finish_layer_new(), and set_layer().

◆ m_num_tool_changes

unsigned int Slic3r::WipeTower::m_num_tool_changes = 0

private

Referenced by get_number_of_toolchanges(), set_layer(), tool_change(), and tool_change_new().

◆ m_old_temperature

int Slic3r::WipeTower::m_old_temperature = -1

private

Referenced by toolchange_Unload().

◆ m_origin

Vec2f Slic3r::WipeTower::m_origin

private

Referenced by WipeTower().

◆ m_outer_wall

std::map<float,Polylines> Slic3r::WipeTower::m_outer_wall

private

Referenced by finish_layer_new(), generate_new(), get_bbx(), get_outer_wall(), and only_generate_out_wall().

◆ m_perimeter_width

◆ m_physical_extruder_map

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

private

Referenced by WipeTower(), and set_for_wipe_tower_writer().

◆ m_plan

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

private

◆ m_print_brim

bool Slic3r::WipeTower::m_print_brim = true

private

unsigned int m_idx_tool_change_in_layer = 0; // Layer change counter in this layer. Counting up to m_max_color_changes.

◆ m_printable_height

std::vector<double> Slic3r::WipeTower::m_printable_height

private

Referenced by WipeTower(), and is_valid_last_layer().

◆ m_rib_length

float Slic3r::WipeTower::m_rib_length =0.f

private

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

◆ m_rib_offset

Vec2f Slic3r::WipeTower::m_rib_offset {Vec2f(0.f, 0.f)}

private

526{Vec2f(0.f, 0.f)};

Referenced by finish_block_solid(), generate_support_wall_new(), get_next_pos(), and get_rib_offset().

◆ m_rib_width

float Slic3r::WipeTower::m_rib_width =0.f

private

Referenced by WipeTower(), generate_rib_polygon(), get_rib_width(), and plan_tower_new().

◆ m_semm

bool Slic3r::WipeTower::m_semm = true

private

Referenced by WipeTower(), set_extruder(), toolchange_Load(), and toolchange_Unload().

◆ m_shared_print_bed

Polygons Slic3r::WipeTower::m_shared_print_bed

private

Referenced by finish_block_solid(), get_next_pos(), and set_shared_print_bed().

◆ m_slice_used_filaments

int Slic3r::WipeTower::m_slice_used_filaments = 0

private

Referenced by WipeTower(), and generate_new().

◆ m_sparse_layers_combined

bool Slic3r::WipeTower::m_sparse_layers_combined = false

private

Referenced by WipeTower(), and generate_new().

◆ m_sparse_layers_skipped

bool Slic3r::WipeTower::m_sparse_layers_skipped = false

private

Referenced by WipeTower(), layer_is_printed(), and plan_toolchange().

◆ m_tower_framework

bool Slic3r::WipeTower::m_tower_framework {false}

private

527{false};

Referenced by WipeTower(), and generate_wipe_tower_blocks().

◆ m_tpu_fixed_spacing

float Slic3r::WipeTower::m_tpu_fixed_spacing = 2

private

Referenced by calc_block_infill_gap(), and tool_change_new().

◆ m_travel_accels

std::vector<unsigned int> Slic3r::WipeTower::m_travel_accels

private

Referenced by set_accelerations(), and set_for_wipe_tower_writer().

◆ m_travel_speed

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

private

Referenced by WipeTower(), tool_change(), tool_change_new(), and toolchange_Change().

◆ m_use_gap_wall

bool Slic3r::WipeTower::m_use_gap_wall {false}

private

520{false};

Referenced by WipeTower(), finish_layer_new(), only_generate_out_wall(), plan_tower_new(), and toolchange_wipe_new().

◆ m_use_rib_wall

bool Slic3r::WipeTower::m_use_rib_wall {false}

private

521{false};

Referenced by WipeTower(), calc_block_infill_gap(), finish_layer_new(), only_generate_out_wall(), and plan_tower_new().

◆ m_used_filament_ids

std::vector<int> Slic3r::WipeTower::m_used_filament_ids

Referenced by set_used_filament_ids().

◆ m_used_filament_length

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

private

Referenced by finish_block(), finish_block_solid(), finish_layer_new(), generate_new(), get_used_filament(), only_generate_out_wall(), set_extruder(), tool_change(), tool_change_new(), and toolchange_Change().

◆ m_used_fillet

bool Slic3r::WipeTower::m_used_fillet {false}

private

525{false};

Referenced by WipeTower(), and generate_support_wall_new().

◆ m_wall_skip_points

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

private

Referenced by generate_support_wall(), generate_support_wall_new(), get_all_wall_skip_points(), and get_wall_skip_points().

◆ m_wipe_tower_blocks

std::vector<WipeTowerBlock> Slic3r::WipeTower::m_wipe_tower_blocks

Referenced by finish_layer_new(), generate_new(), generate_wipe_tower_blocks(), get_block_by_category(), get_wall_skip_points(), plan_tower_new(), reset_block_status(), and update_all_layer_depth().

◆ m_wipe_tower_brim_width

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

private

Referenced by WipeTower(), finish_layer_new(), and plan_tower_new().

◆ m_wipe_tower_brim_width_real

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

private

Referenced by finish_layer_new(), and get_brim_width().

◆ m_wipe_tower_depth

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

private

Referenced by align_perimeter(), finish_block(), finish_block_solid(), finish_layer_new(), generate_new(), generate_rib_polygon(), get_depth(), only_generate_out_wall(), plan_tower_new(), ramming(), tool_change(), tool_change_new(), and update_all_layer_depth().

◆ m_wipe_tower_height

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

private

Referenced by WipeTower(), calc_block_infill_gap(), generate_new(), generate_rib_polygon(), get_height(), and plan_tower_new().

◆ m_wipe_tower_pos

Vec2f Slic3r::WipeTower::m_wipe_tower_pos

private

Referenced by WipeTower(), finish_block_solid(), get_next_pos(), and position().

◆ m_wipe_tower_rotation_angle

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

private

Referenced by WipeTower().

◆ m_wipe_tower_width

float Slic3r::WipeTower::m_wipe_tower_width

private

Referenced by WipeTower(), finish_block(), finish_block_solid(), finish_layer_new(), generate_rib_polygon(), generate_support_wall(), generate_support_wall_new(), get_next_pos(), get_wall_skip_points(), only_generate_out_wall(), plan_toolchange(), plan_tower_new(), ramming(), set_toolchange(), tool_change(), tool_change_new(), toolchange_Wipe(), toolchange_wipe_new(), and width().

◆ m_wrapping_detection_layers

int Slic3r::WipeTower::m_wrapping_detection_layers = 0

private

Referenced by WipeTower().

◆ m_y_shift

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

private

Referenced by WipeTower(), align_perimeter(), finish_block(), finish_block_solid(), finish_layer_new(), generate_new(), generate_rib_polygon(), generate_support_wall_new(), only_generate_out_wall(), ramming(), tool_change(), and tool_change_new().

◆ m_z_pos

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

private

Referenced by WipeTower(), construct_block_tcr(), construct_tcr(), finish_block(), finish_block_solid(), finish_layer_new(), generate_rib_polygon(), only_generate_out_wall(), ramming(), set_layer(), tool_change(), and tool_change_new().

◆ min_depth_per_height

const std::map< float, float > Slic3r::WipeTower::min_depth_per_height

static

Initial value:

= {
    {5.f,5.f}, {100.f, 20.f}, {250.f, 40.f}, {350.f, 60.f}
}

Referenced by get_limit_depth_by_height().

◆ Width_To_Nozzle_Ratio

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

private

Referenced by set_extruder().

◆ WT_EPSILON

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

private

Referenced by finish_block(), finish_block_solid(), finish_layer_new(), only_generate_out_wall(), plan_toolchange(), plan_tower_new(), Slic3r::WipeTowerWriter::rectangle_fill_box(), set_layer(), toolchange_Unload(), toolchange_Wipe(), and toolchange_wipe_new().

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

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

	OrcaSlicer latest OrcaSlicer

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Class Documentation

◆ Slic3r::WipeTower::PurgeEstimate

◆ Slic3r::WipeTower::NozzleChangeResult

◆ Slic3r::WipeTower::FilamentParameters

◆ Slic3r::WipeTower::WipeTowerBlock

◆ Slic3r::WipeTower::BlockDepthInfo

Member Enumeration Documentation

◆ anonymous enum

◆ wipe_shape

◆ WipeTowerLayerType

Constructor & Destructor Documentation

◆ WipeTower()

Member Function Documentation

◆ add_depth_to_block()

◆ align_perimeter()

◆ calc_block_infill_gap()

◆ construct_block_tcr()

◆ construct_tcr()

◆ estimate_brim_real_width()

◆ estimate_rib_tower_bbox_side()

◆ estimate_tower_blocks_depth()

◆ extrusion_flow()

◆ filament_area()

◆ finish_block()

◆ finish_block_solid()

◆ finish_layer()

◆ finish_layer_new()

◆ finished()

◆ first_toolchange_to_nonsoluble_nonsupport()

◆ generate()

◆ generate_new()

◆ generate_rib_polygon()

◆ generate_support_wall()

◆ generate_support_wall_new()

◆ generate_wipe_tower_blocks()

◆ get_all_wall_skip_points()

◆ get_auto_brim_by_height()

◆ get_bbx()

◆ get_block_by_category()

◆ get_block_gap_width()

◆ get_brim_width()

◆ get_depth()

◆ get_extruder_id()

◆ get_extrusion_flow()

◆ get_filament_category()

◆ get_floating_area()

◆ get_height()

◆ get_layer_height()

◆ get_limit_depth_by_height()

◆ get_next_pos()

◆ get_nozzle_id()

◆ get_number_of_toolchanges()

◆ get_outer_wall()

◆ get_rib_length()

◆ get_rib_offset()

◆ get_rib_width()

◆ get_used_filament()

◆ get_wall_filament_for_all_layer()

◆ get_wall_skip_points()

◆ get_wrapping_detection_depth()

◆ has_tpu_filament()

◆ is_first_layer()

◆ is_need_ramming()

◆ is_need_reverse_travel()

◆ is_petg_filament()

◆ is_same_extruder()

◆ is_same_nozzle()

◆ is_tpu_filament()

◆ is_valid_last_layer()