Collaboration diagram for Slic3r::WipeTowerWriter:

Public Member Functions
	WipeTowerWriter (float layer_height, float line_width, GCodeFlavor flavor, const std::vector< WipeTower::FilamentParameters > &filament_parameters, bool enable_arc_fitting)
WipeTowerWriter &	change_analyzer_line_width (float line_width)
WipeTowerWriter &	set_initial_position (const Vec2f &pos, float width=0.f, float depth=0.f, float internal_angle=0.f)
WipeTowerWriter &	set_initial_tool (size_t tool)
WipeTowerWriter &	set_z (float z)
WipeTowerWriter &	set_extrusion_flow (float flow)
WipeTowerWriter &	set_y_shift (float shift)
WipeTowerWriter &	disable_linear_advance ()
WipeTowerWriter &	suppress_preview ()
WipeTowerWriter &	resume_preview ()
WipeTowerWriter &	feedrate (float f)
const std::string &	gcode () const
const std::vector< WipeTower::Extrusion > &	extrusions () const
float	x () const
float	y () const
const Vec2f &	pos () const
const Vec2f	start_pos_rotated () const
const Vec2f	pos_rotated () const
float	elapsed_time () const
float	get_and_reset_used_filament_length ()
WipeTowerWriter &	extrude_explicit (float x, float y, float e, float f=0.f, bool record_length=false, LimitFlow limit_flow=LimitFlow::LimitPrintFlow)
WipeTowerWriter &	extrude_arc_explicit (ArcSegment &arc, float f=0.f, bool record_length=false, LimitFlow limit_flow=LimitFlow::LimitPrintFlow)
WipeTowerWriter &	extrude_explicit (const Vec2f &dest, float e, float f=0.f, bool record_length=false, LimitFlow limit_flow=LimitFlow::LimitPrintFlow)
WipeTowerWriter &	travel (float x, float y, float f=0.f)
WipeTowerWriter &	travel (const Vec2f &dest, float f=0.f)
WipeTowerWriter &	extrude (float x, float y, float f=0.f, LimitFlow limit_flow=LimitFlow::LimitPrintFlow)
WipeTowerWriter &	extrude_arc (ArcSegment &arc, float f=0.f, LimitFlow limit_flow=LimitFlow::LimitPrintFlow)
WipeTowerWriter &	extrude (const Vec2f &dest, const float f=0.f)
WipeTowerWriter &	rectangle (const Vec2f &ld, float width, float height, const float f=0.f)
WipeTowerWriter &	rectangle_fill_box (const WipeTower *wipe_tower, const Vec2f &ld, float width, float height, const float f=0.f)
WipeTowerWriter &	line (const WipeTower *wipe_tower, Vec2f p0, Vec2f p1, const float f=0.f)
WipeTowerWriter &	rectangle_fill_box (const WipeTower *wipe_tower, const WipeTower::box_coordinates &fill_box, std::vector< Vec2f > &finish_rect_wipe_path, const float f=0.f)
WipeTowerWriter &	rectangle (const WipeTower::box_coordinates &box, const float f=0.f)
WipeTowerWriter &	polygon (const Polygon &wall_polygon, const float f=0.f)
WipeTowerWriter &	load (float e, float f=0.f)
WipeTowerWriter &	retract (float e, float f=0.f)
WipeTowerWriter &	load_move_x_advanced (float farthest_x, float loading_dist, float loading_speed, float max_x_speed=50.f)
WipeTowerWriter &	z_hop (float hop, float f=0.f)
WipeTowerWriter &	z_hop_reset (float f=0.f)
WipeTowerWriter &	ram (float x1, float x2, float dy, float e0, float e, float f)
WipeTowerWriter &	cool (float x1, float x2, float e1, float e2, float f)
WipeTowerWriter &	set_tool (size_t tool)
WipeTowerWriter &	set_extruder_temp (int temperature, bool wait=false)
WipeTowerWriter &	wait (float time)
WipeTowerWriter &	speed_override (int speed)
WipeTowerWriter &	speed_override_backup ()
WipeTowerWriter &	speed_override_restore ()
WipeTowerWriter &	set_extruder_trimpot (int current)
WipeTowerWriter &	flush_planner_queue ()
WipeTowerWriter &	reset_extruder ()
WipeTowerWriter &	comment_with_value (const char *comment, int value)
WipeTowerWriter &	set_fan (unsigned speed)
WipeTowerWriter &	append (const std::string &text)
const std::vector< Vec2f > &	wipe_path () const
WipeTowerWriter &	add_wipe_point (const Vec2f &pt)
WipeTowerWriter &	add_wipe_point (float x, float y)
WipeTowerWriter &	add_wipe_path (const Polygon &polygon, double wipe_dist)
void	generate_path (Polylines &pls, float feedrate, float retract_length, float retract_speed, bool used_fillet)
void	spiral_flat_ironing (const Vec2f &center, float area, float step_length, float feedrate)
WipeTowerWriter &	format_line_M104 (int target_temp, int target_extruder, bool wait_for_moves=true, const std::string &comment=std::string())
WipeTowerWriter &	format_line_M109 (int target_temp, int target_extruder, const std::string &comment=std::string())
void	set_first_layer (bool is_first_layer)
void	set_normal_acceleration (const std::vector< unsigned int > &accelerations)
void	set_first_layer_normal_acceleration (const std::vector< unsigned int > &accelerations)
void	set_travel_acceleration (const std::vector< unsigned int > &accelerations)
void	set_first_layer_travel_acceleration (const std::vector< unsigned int > &accelerations)
void	set_max_acceleration (unsigned int acceleration)
void	set_accel_to_decel_enable (bool enable)
void	set_accel_to_decel_factor (float factor)
void	set_layer_id (int layer_id)
void	set_multi_nozzle_group_result (const MultiNozzleUtils::LayeredNozzleGroupResult *multi_nozzle_group_result)
void	set_physical_extruder_map (const std::vector< int > &physical_extruder_map)

Private Member Functions
std::string	set_normal_acceleration ()
std::string	set_travel_acceleration ()
std::string	set_acceleration_impl (unsigned int acceleration)
std::string	set_format_X (float x)
std::string	set_format_Y (float y)
std::string	set_format_Z (float z)
std::string	set_format_E (float e)
std::string	set_format_F (float f)
std::string	set_format_I (float i)
std::string	set_format_J (float j)
WipeTowerWriter &	operator= (const WipeTowerWriter &rhs)
Vec2f	rotate (Vec2f pt) const

Private Attributes
std::vector< unsigned int >	m_normal_accelerations
std::vector< unsigned int >	m_first_layer_normal_accelerations
std::vector< unsigned int >	m_travel_accelerations
std::vector< unsigned int >	m_first_layer_travel_accelerations
bool	m_is_first_layer {false}
unsigned int	m_max_acceleration {0}
unsigned int	m_last_acceleration {0}
bool	m_accel_to_decel_enable
float	m_accel_to_decel_factor
const MultiNozzleUtils::LayeredNozzleGroupResult *	m_multi_nozzle_group_result {nullptr}
int	m_layer_id = -1
std::vector< int >	m_physical_extruder_map
Vec2f	m_start_pos
Vec2f	m_current_pos
std::vector< Vec2f >	m_wipe_path
float	m_current_z
float	m_current_feedrate
size_t	m_current_tool
float	m_layer_height
float	m_extrusion_flow
bool	m_preview_suppressed
std::string	m_gcode
std::vector< WipeTower::Extrusion >	m_extrusions
float	m_elapsed_time
float	m_internal_angle = 0.f
float	m_y_shift = 0.f
float	m_wipe_tower_width = 0.f
float	m_wipe_tower_depth = 0.f
unsigned	m_last_fan_speed = 0
int	current_temp = -1
float	m_used_filament_length = 0.f
GCodeFlavor	m_gcode_flavor
bool	m_enable_arc_fitting = true
const std::vector< WipeTower::FilamentParameters > &	m_filpar

Detailed Description

Constructor & Destructor Documentation

◆ WipeTowerWriter()

Slic3r::WipeTowerWriter::WipeTowerWriter	(	float	layer_height,
		float	line_width,
		GCodeFlavor	flavor,
		const std::vector< WipeTower::FilamentParameters > &	filament_parameters,
		bool	enable_arc_fitting )

inline

                                                                                                                                                                        :
    m_current_pos(std::numeric_limits<float>::max(), std::numeric_limits<float>::max()),
    m_current_z(0.f),
    m_current_feedrate(0.f),
    m_layer_height(layer_height),
    m_extrusion_flow(0.f),
    m_preview_suppressed(false),
    m_elapsed_time(0.f),
#if ENABLE_GCODE_VIEWER_DATA_CHECKING
        m_default_analyzer_line_width(line_width),
#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
        m_gcode_flavor(flavor),
        m_enable_arc_fitting(enable_arc_fitting),
        m_filpar(filament_parameters)
        {
            // ORCA: This class is only used by BBL printers, so set the parameter appropriately.
            // This fixes an issue where the wipe tower was using BBL tags resulting in statistics for purging in the purge tower not being displayed.
            GCodeProcessor::s_IsBBLPrinter = true;
            // adds tag for analyzer:
            std::ostringstream str;
            str << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height) << Slic3r::float_to_string_decimal_point(m_layer_height, 6) << "\n"; // don't rely on GCodeAnalyzer knowing the layer height - it knows nothing at priming
            str << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role) << ExtrusionEntity::role_to_string(erWipeTower) << "\n";
            m_gcode += str.str();
            change_analyzer_line_width(line_width);
    }

References change_analyzer_line_width(), Slic3r::erWipeTower, Slic3r::float_to_string_decimal_point(), Slic3r::GCodeProcessor::Height, Slic3r::layer_height(), m_current_feedrate, m_current_pos, m_current_z, m_elapsed_time, m_enable_arc_fitting, m_extrusion_flow, m_filpar, m_gcode, m_gcode_flavor, m_layer_height, m_preview_suppressed, Slic3r::GCodeProcessor::reserved_tag(), Slic3r::GCodeProcessor::Role, Slic3r::ExtrusionEntity::role_to_string(), and Slic3r::GCodeProcessor::s_IsBBLPrinter.

Referenced by add_wipe_path(), add_wipe_point(), add_wipe_point(), append(), change_analyzer_line_width(), comment_with_value(), cool(), disable_linear_advance(), extrude(), extrude(), extrude_arc(), extrude_arc_explicit(), extrude_explicit(), extrude_explicit(), feedrate(), flush_planner_queue(), format_line_M104(), format_line_M109(), line(), load(), load_move_x_advanced(), operator=(), polygon(), ram(), rectangle(), rectangle(), rectangle_fill_box(), rectangle_fill_box(), reset_extruder(), resume_preview(), retract(), set_extruder_temp(), set_extruder_trimpot(), set_extrusion_flow(), set_fan(), set_initial_position(), set_initial_tool(), set_tool(), set_y_shift(), set_z(), speed_override(), speed_override_backup(), speed_override_restore(), suppress_preview(), travel(), travel(), wait(), z_hop(), and z_hop_reset().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

◆ add_wipe_path()

WipeTowerWriter & Slic3r::WipeTowerWriter::add_wipe_path	(	const Polygon &	polygon,
		double	wipe_dist )

inline

    {
        int closest_idx = polygon.closest_point_index(scaled(m_current_pos));
        Polyline wipe_path   = polygon.split_at_index(closest_idx);
        wipe_path.reverse();
        for (int i = 0; i < wipe_path.size(); ++i) {
            if (wipe_dist < EPSILON) break;
            add_wipe_point(unscaled<float>(wipe_path[i]));
            if (i != 0) wipe_dist -= (unscaled(wipe_path[i]) - unscaled(wipe_path[i - 1])).norm();
        }
        return *this;
    }

References WipeTowerWriter(), add_wipe_point(), EPSILON, m_current_pos, polygon(), Slic3r::scaled(), Slic3r::unscaled(), and wipe_path().

Referenced by Slic3r::WipeTower::finish_layer_new(), and Slic3r::WipeTower::only_generate_out_wall().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_wipe_point() [1/2]

WipeTowerWriter & Slic3r::WipeTowerWriter::add_wipe_point ( const Vec2f & pt )

inline

    {
        m_wipe_path.push_back(rotate(pt));
        return *this;
    }

References WipeTowerWriter(), m_wipe_path, and rotate().

Referenced by add_wipe_path(), add_wipe_point(), Slic3r::WipeTower::finish_block(), Slic3r::WipeTower::finish_block_solid(), Slic3r::WipeTower::finish_layer_new(), Slic3r::WipeTower::toolchange_Wipe(), and Slic3r::WipeTower::toolchange_wipe_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_wipe_point() [2/2]

WipeTowerWriter & Slic3r::WipeTowerWriter::add_wipe_point	(	float	x,
		float	y )

inline

    {
        return add_wipe_point(Vec2f(x, y));
    }

References WipeTowerWriter(), add_wipe_point(), x(), and y().

Here is the call graph for this function:

◆ append()

WipeTowerWriter & Slic3r::WipeTowerWriter::append ( const std::string & text )

inline

1334{ m_gcode += text; return *this; }

References WipeTowerWriter(), and m_gcode.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ change_analyzer_line_width()

WipeTowerWriter & Slic3r::WipeTowerWriter::change_analyzer_line_width ( float line_width )

inline

                                                                  {
        // adds tag for analyzer:
        std::stringstream str;
        str << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Width) << Slic3r::float_to_string_decimal_point(line_width, 6) << "\n";
        m_gcode += str.str();
        return *this;
    }

References WipeTowerWriter(), Slic3r::float_to_string_decimal_point(), m_gcode, Slic3r::GCodeProcessor::reserved_tag(), and Slic3r::GCodeProcessor::Width.

Referenced by WipeTowerWriter(), Slic3r::WipeTower::toolchange_Unload(), and Slic3r::WipeTower::toolchange_wipe_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ comment_with_value()

WipeTowerWriter & Slic3r::WipeTowerWriter::comment_with_value	(	const char *	comment,
		int	value )

inline

    {
        m_gcode += std::string(";") + comment + std::to_string(value) + "\n";
    return *this;
    }

References WipeTowerWriter(), and m_gcode.

Referenced by Slic3r::WipeTower::finish_block(), Slic3r::WipeTower::finish_block_solid(), Slic3r::WipeTower::finish_layer_new(), Slic3r::WipeTower::tool_change(), and Slic3r::WipeTower::tool_change_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cool()

WipeTowerWriter & Slic3r::WipeTowerWriter::cool	(	float	x1,
		float	x2,
		float	e1,
		float	e2,
		float	f )

inline

  {
    extrude_explicit(x1, m_current_pos.y(), e1, f, false, LimitFlow::None);
        extrude_explicit(x2, m_current_pos.y(), e2, 0.f, false, LimitFlow::None);
    return *this;
  }

References WipeTowerWriter(), extrude_explicit(), Slic3r::f(), m_current_pos, and Slic3r::None.

Here is the call graph for this function:

◆ disable_linear_advance()

WipeTowerWriter & Slic3r::WipeTowerWriter::disable_linear_advance ( )

inline

                                                         {
        if (m_gcode_flavor == gcfKlipper)
            m_gcode += "SET_PRESSURE_ADVANCE ADVANCE=0\n";
        else if (m_gcode_flavor == gcfRepRapFirmware)
            m_gcode += std::string("M572 D") + std::to_string(m_current_tool) + " S0\n";
        else
            m_gcode += "M900 K0\n";
 
        return *this;
    }

References WipeTowerWriter(), Slic3r::gcfKlipper, Slic3r::gcfRepRapFirmware, m_current_tool, m_gcode, and m_gcode_flavor.

Referenced by Slic3r::WipeTower::toolchange_Unload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elapsed_time()

float Slic3r::WipeTowerWriter::elapsed_time ( ) const

inline

841{ return m_elapsed_time; }

References m_elapsed_time.

Referenced by Slic3r::WipeTower::construct_block_tcr(), and Slic3r::WipeTower::construct_tcr().

Here is the caller graph for this function:

◆ extrude() [1/2]

WipeTowerWriter & Slic3r::WipeTowerWriter::extrude	(	const Vec2f &	dest,
		const float	f = 0.f )

inline

1015 { return extrude(dest.x(), dest.y(), f); }

Slic3r::WipeTowerWriter::extrude

WipeTowerWriter & extrude(float x, float y, float f=0.f, LimitFlow limit_flow=LimitFlow::LimitPrintFlow)

Definition WipeTower.cpp:1003

References WipeTowerWriter(), extrude(), and Slic3r::f().

Here is the call graph for this function:

◆ extrude() [2/2]

WipeTowerWriter & Slic3r::WipeTowerWriter::extrude	(	float	x,
		float	y,
		float	f = 0.f,
		LimitFlow	limit_flow = LimitFlow::LimitPrintFlow )

inline

  {
    float dx = x - m_current_pos.x();
    float dy = y - m_current_pos.y();
        return extrude_explicit(x, y, std::sqrt(dx * dx + dy * dy) * m_extrusion_flow, f, false, limit_flow);
  }

References WipeTowerWriter(), extrude_explicit(), Slic3r::f(), Slic3r::LimitPrintFlow, m_current_pos, m_extrusion_flow, x(), and y().

Referenced by extrude(), Slic3r::WipeTower::finish_block(), Slic3r::WipeTower::finish_block_solid(), Slic3r::WipeTower::finish_layer_new(), generate_path(), Slic3r::WipeTower::generate_support_wall(), line(), polygon(), Slic3r::WipeTower::ramming(), rectangle(), rectangle_fill_box(), Slic3r::WipeTower::toolchange_Unload(), Slic3r::WipeTower::toolchange_Wipe(), and Slic3r::WipeTower::toolchange_wipe_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extrude_arc()

WipeTowerWriter & Slic3r::WipeTowerWriter::extrude_arc	(	ArcSegment &	arc,
		float	f = 0.f,
		LimitFlow	limit_flow = LimitFlow::LimitPrintFlow )

inline

    {
        return extrude_arc_explicit(arc, f, false , limit_flow);
    }

References WipeTowerWriter(), extrude_arc_explicit(), Slic3r::f(), and Slic3r::LimitPrintFlow.

Referenced by generate_path(), and polygon().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extrude_arc_explicit()

WipeTowerWriter & Slic3r::WipeTowerWriter::extrude_arc_explicit	(	ArcSegment &	arc,
		float	f = 0.f,
		bool	record_length = false,
		LimitFlow	limit_flow = LimitFlow::LimitPrintFlow )

inline

    {
        float x   = (float)unscale(arc.end_point).x();
        float y   = (float)unscale(arc.end_point).y();
        float len = unscaled<float>(arc.length);
        float e   = len * m_extrusion_flow;
        if (len < (float) EPSILON && e == 0.f && (f == 0.f || f == m_current_feedrate))
            // Neither extrusion nor a travel move.
            return *this;
        if (record_length) m_used_filament_length += e;
 
        // Now do the "internal rotation" with respect to the wipe tower center
        Vec2f rotated_current_pos(this->pos_rotated());
        Vec2f rot(this->rotate(Vec2f(x, y))); // this is where we want to go
 
        if (!m_preview_suppressed && e > 0.f && len > 0.f) {
#if ENABLE_GCODE_VIEWER_DATA_CHECKING
            change_analyzer_mm3_per_mm(len, e);
#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
       // Width of a squished extrusion, corrected for the roundings of the squished extrusions.
       // This is left zero if it is a travel move.
            float width = e * m_filpar[0].filament_area / (len * m_layer_height);
            // Correct for the roundings of a squished extrusion.
            width += m_layer_height * float(1. - M_PI / 4.);
            if (m_extrusions.empty() || m_extrusions.back().pos != rotated_current_pos) m_extrusions.emplace_back(WipeTower::Extrusion(rotated_current_pos, 0, m_current_tool));
            {
                int   n            = arc_fit_size;
                for (int j = 0; j < n; j++) {
                    float cur_angle = arc.polar_start_theta + (float) j / n * arc.angle_radians;
                    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)};
                    m_extrusions.emplace_back(WipeTower::Extrusion(this->rotate(unscaled<float>(tmp)), width, m_current_tool));
                }
                m_extrusions.emplace_back(WipeTower::Extrusion(rot, width, m_current_tool));
            }
 
        }
 
        if (e == 0.f) {
            m_gcode += set_travel_acceleration();
        } else {
            m_gcode += set_normal_acceleration();
        }
 
        m_gcode += arc.direction == ArcDirection::Arc_Dir_CCW ? "G3" : "G2";
        const Vec2f center_offset = this->rotate(unscaled<float>(arc.center)) - rotated_current_pos;
        m_gcode += set_format_X(rot.x());
        m_gcode += set_format_Y(rot.y());
        m_gcode += set_format_I(center_offset.x());
        m_gcode += set_format_J(center_offset.y());
 
        if (e != 0.f) m_gcode += set_format_E(e);
 
        if (f != 0.f && f != m_current_feedrate) {
            if (limit_flow != LimitFlow::None) {
                float e_speed = e / (((len == 0.f) ? std::abs(e) : len) / f * 60.f);
                float tmp     = m_filpar[m_current_tool].max_e_speed;
                if (limit_flow == LimitFlow::LimitRammingFlow) tmp = m_filpar[m_current_tool].max_e_ramming_speed.first;
                else if (limit_flow == LimitFlow::LimitRammingFlowNC)
                    tmp = m_filpar[m_current_tool].max_e_ramming_speed.second;
                f /= std::max(1.f, e_speed / tmp);
            }
            m_gcode += set_format_F(f);
        }
 
        m_current_pos.x() = x;
        m_current_pos.y() = y;
 
        // Update the elapsed time with a rough estimate.
        m_elapsed_time += ((len == 0.f) ? std::abs(e) : len) / m_current_feedrate * 60.f;
        m_gcode += "\n";
        return *this;
    }

References WipeTowerWriter(), Slic3r::Arc_Dir_CCW, Slic3r::arc_fit_size, EPSILON, Slic3r::f(), Slic3r::LimitPrintFlow, Slic3r::LimitRammingFlow, Slic3r::LimitRammingFlowNC, m_current_feedrate, m_current_pos, m_current_tool, m_elapsed_time, m_extrusion_flow, m_extrusions, m_filpar, m_gcode, m_layer_height, M_PI, m_preview_suppressed, m_used_filament_length, Slic3r::None, PI, pos_rotated(), rotate(), set_format_E(), set_format_F(), set_format_I(), set_format_J(), set_format_X(), set_format_Y(), set_normal_acceleration(), set_travel_acceleration(), Slic3r::unscale(), Slic3r::unscaled(), x(), and y().

Referenced by extrude_arc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extrude_explicit() [1/2]

WipeTowerWriter & Slic3r::WipeTowerWriter::extrude_explicit	(	const Vec2f &	dest,
		float	e,
		float	f = 0.f,
		bool	record_length = false,
		LimitFlow	limit_flow = LimitFlow::LimitPrintFlow )

inline

    {
        return extrude_explicit(dest.x(), dest.y(), e, f, record_length, limit_flow);
    }

References WipeTowerWriter(), extrude_explicit(), Slic3r::f(), and Slic3r::LimitPrintFlow.

Here is the call graph for this function:

◆ extrude_explicit() [2/2]

WipeTowerWriter & Slic3r::WipeTowerWriter::extrude_explicit	(	float	x,
		float	y,
		float	e,
		float	f = 0.f,
		bool	record_length = false,
		LimitFlow	limit_flow = LimitFlow::LimitPrintFlow )

inline

  {
        if ((std::abs(x - m_current_pos.x()) <= (float)EPSILON) && (std::abs(y - m_current_pos.y()) < (float)EPSILON) && e == 0.f && (f == 0.f || f == m_current_feedrate))
      // Neither extrusion nor a travel move.
      return *this;
 
    float dx = x - m_current_pos.x();
    float dy = y - m_current_pos.y();
        float len = std::sqrt(dx*dx+dy*dy);
        if (record_length)
            m_used_filament_length += e;
 
    // Now do the "internal rotation" with respect to the wipe tower center
    Vec2f rotated_current_pos(this->pos_rotated());
    Vec2f rot(this->rotate(Vec2f(x,y)));                               // this is where we want to go
 
        if (! m_preview_suppressed && e > 0.f && len > 0.f) {
#if ENABLE_GCODE_VIEWER_DATA_CHECKING
            change_analyzer_mm3_per_mm(len, e);
#endif // ENABLE_GCODE_VIEWER_DATA_CHECKING
            // Width of a squished extrusion, corrected for the roundings of the squished extrusions.
      // This is left zero if it is a travel move.
            float width = e * m_filpar[0].filament_area / (len * m_layer_height);
      // Correct for the roundings of a squished extrusion.
      width += m_layer_height * float(1. - M_PI / 4.);
      if (m_extrusions.empty() || m_extrusions.back().pos != rotated_current_pos)
        m_extrusions.emplace_back(WipeTower::Extrusion(rotated_current_pos, 0, m_current_tool));
      m_extrusions.emplace_back(WipeTower::Extrusion(rot, width, m_current_tool));
    }
 
        if (e == 0.f) {
            m_gcode += set_travel_acceleration();
        } else {
            m_gcode += set_normal_acceleration();
        }
 
    m_gcode += "G1";
        if (std::abs(rot.x() - rotated_current_pos.x()) > (float)EPSILON)
      m_gcode += set_format_X(rot.x());
 
        if (std::abs(rot.y() - rotated_current_pos.y()) > (float)EPSILON)
      m_gcode += set_format_Y(rot.y());
 
 
    if (e != 0.f)
      m_gcode += set_format_E(e);
 
    if (f != 0.f && f != m_current_feedrate) {
            if (limit_flow!= LimitFlow::None) {
                float e_speed = e / (((len == 0.f) ? std::abs(e) : len) / f * 60.f);
                float tmp     = m_filpar[m_current_tool].max_e_speed;
                if (limit_flow == LimitFlow::LimitRammingFlow) tmp = m_filpar[m_current_tool].max_e_ramming_speed.first;
                else if (limit_flow == LimitFlow::LimitRammingFlowNC) tmp = m_filpar[m_current_tool].max_e_ramming_speed.second;
                f /= std::max(1.f, e_speed / tmp);
            }
      m_gcode += set_format_F(f);
        }
 
        m_current_pos.x() = x;
        m_current_pos.y() = y;
 
    // Update the elapsed time with a rough estimate.
        m_elapsed_time += ((len == 0.f) ? std::abs(e) : len) / m_current_feedrate * 60.f;
    m_gcode += "\n";
    return *this;
  }

References WipeTowerWriter(), EPSILON, Slic3r::f(), Slic3r::LimitPrintFlow, Slic3r::LimitRammingFlow, Slic3r::LimitRammingFlowNC, m_current_feedrate, m_current_pos, m_current_tool, m_elapsed_time, m_extrusions, m_filpar, m_gcode, m_layer_height, M_PI, m_preview_suppressed, m_used_filament_length, Slic3r::None, pos_rotated(), rotate(), set_format_E(), set_format_F(), set_format_X(), set_format_Y(), set_normal_acceleration(), set_travel_acceleration(), x(), and y().

Referenced by cool(), extrude(), extrude_explicit(), load_move_x_advanced(), ram(), travel(), and travel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extrusions()

const std::vector< WipeTower::Extrusion > & Slic3r::WipeTowerWriter::extrusions ( ) const

inline

835{ return m_extrusions; }

References m_extrusions.

Referenced by Slic3r::WipeTower::construct_block_tcr(), and Slic3r::WipeTower::construct_tcr().

Here is the caller graph for this function:

◆ feedrate()

WipeTowerWriter & Slic3r::WipeTowerWriter::feedrate ( float f )

inline

  {
        if (f != m_current_feedrate) {
      m_gcode += "G1" + set_format_F(f) + "\n";
            m_current_feedrate = f;
        }
    return *this;
  }

References WipeTowerWriter(), Slic3r::f(), m_current_feedrate, m_gcode, and set_format_F().

Referenced by generate_path(), spiral_flat_ironing(), Slic3r::WipeTower::tool_change(), Slic3r::WipeTower::tool_change_new(), and Slic3r::WipeTower::toolchange_Change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flush_planner_queue()

WipeTowerWriter & Slic3r::WipeTowerWriter::flush_planner_queue ( )

inline

  {
    m_gcode += flush_planner_queue_command(m_gcode_flavor);
    return *this;
  }

References WipeTowerWriter(), Slic3r::flush_planner_queue_command(), m_gcode, and m_gcode_flavor.

Referenced by Slic3r::WipeTower::tool_change(), Slic3r::WipeTower::tool_change_new(), Slic3r::WipeTower::toolchange_Change(), and Slic3r::WipeTower::toolchange_Unload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ format_line_M104()

WipeTowerWriter & Slic3r::WipeTowerWriter::format_line_M104	(	int	target_temp,
		int	target_extruder,
		bool	wait_for_moves = true,
		const std::string &	comment = std::string() )

inline

    {
        std::string buffer;
        if (wait_for_moves)
            // Not flush_planner_queue_command(): this BBL precool path wants M400, which every
            // flavor it reaches understands, not the zero dwell the other flavors flush with.
            buffer += "M400\n";
        buffer += "M104";
        if (target_extruder != -1 && target_extruder < int(m_physical_extruder_map.size()))
            buffer += (" T" + std::to_string(m_physical_extruder_map[target_extruder]));
        buffer += " S" + std::to_string(target_temp) + " N0"; // N0 means the gcode is generated by slicer
        if (!comment.empty()) buffer += " ;" + comment;
        buffer += '\n';
        append(buffer);
        return *this;
    }

References WipeTowerWriter(), append(), and m_physical_extruder_map.

Referenced by Slic3r::WipeTower::finish_block_solid(), Slic3r::WipeTower::ramming(), and Slic3r::WipeTower::toolchange_wipe_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ format_line_M109()

WipeTowerWriter & Slic3r::WipeTowerWriter::format_line_M109	(	int	target_temp,
		int	target_extruder,
		const std::string &	comment = std::string() )

inline

    {
        std::string buffer = "M109";
        if (target_extruder != -1 && target_extruder < int(m_physical_extruder_map.size()))
            buffer += (" T" + std::to_string(m_physical_extruder_map[target_extruder]));
        buffer += " S" + std::to_string(target_temp) + " N0"; // N0 means the gcode is generated by slicer
        if (!comment.empty()) buffer += " ;" + comment;
        buffer += '\n';
        append(buffer);
        return *this;
    };

References WipeTowerWriter(), append(), and m_physical_extruder_map.

Referenced by Slic3r::WipeTower::finish_block_solid().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gcode()

const std::string & Slic3r::WipeTowerWriter::gcode ( ) const

inline

834{ return m_gcode; }

References m_gcode.

Referenced by Slic3r::WipeTower::construct_block_tcr(), Slic3r::WipeTower::construct_tcr(), Slic3r::WipeTower::ramming(), and set_acceleration_impl().

Here is the caller graph for this function:

◆ generate_path()

void Slic3r::WipeTowerWriter::generate_path	(	Polylines &	pls,
		float	feedrate,
		float	retract_length,
		float	retract_speed,
		bool	used_fillet )

inline

    {
        auto get_closet_idx = [this](std::vector<Segment> &corners) -> int {
            Vec2f anchor{this->m_current_pos.x(), this->m_current_pos.y()};
            int   closestIndex = -1;
            float minDistance  = std::numeric_limits<float>::max();
            for (int i = 0; i < corners.size(); ++i) {
                float distance = (corners[i].start - anchor).squaredNorm();
                if (distance < minDistance) {
                    minDistance  = distance;
                    closestIndex = i;
                }
            }
            return closestIndex;
        };
        if (m_enable_arc_fitting) {
            for (auto &pl : pls) pl.simplify_by_fitting_arc(SCALED_WIPE_TOWER_RESOLUTION);
        } else {
            for (auto &pl : pls) {
                pl.simplify(SCALED_WIPE_TOWER_RESOLUTION);
                pl.reset_to_linear_move();
            }
        }
 
        std::vector<Segment> segments;
        for (const auto &pl : pls) {
            if (pl.points.size()<2) continue;
            for (int i = 0; i < pl.fitting_result.size(); i++) {
                if (pl.fitting_result[i].path_type == EMovePathType::Linear_move) {
                    for (int j = pl.fitting_result[i].start_point_index; j < pl.fitting_result[i].end_point_index; j++)
                        segments.push_back({unscaled<float>(pl.points[j]), unscaled<float>(pl.points[j + 1])});
                } else {
                    int beg = pl.fitting_result[i].start_point_index;
                    int end = pl.fitting_result[i].end_point_index;
                    segments.push_back({unscaled<float>(pl.points[beg]), unscaled<float>(pl.points[end])});
                    segments.back().is_arc = true;
                    segments.back().arcsegment = pl.fitting_result[i].arc_data;
                }
            }
        }
        if (segments.empty())
            return;
 
        int index_of_closest = get_closet_idx(segments);
        int i = index_of_closest;
        travel(segments[i].start); // travel to the closest points
        segments[i].is_arc? extrude_arc(segments[i].arcsegment,feedrate) : extrude(segments[i].end, feedrate);
        do {
            i         = (i + 1) % segments.size();
            if (i == index_of_closest) break;
            float dx  = segments[i].start.x() - m_current_pos.x();
            float dy  = segments[i].start.y() - m_current_pos.y();
            float len = std::sqrt(dx * dx + dy * dy);
            if (len > EPSILON) {
                retract(retract_length, retract_speed);
                travel(segments[i].start, 600.);
                retract(-retract_length, retract_speed);
            }
            segments[i].is_arc ? extrude_arc(segments[i].arcsegment, feedrate) : extrude(segments[i].end, feedrate);
        } while (1);
    }

References EPSILON, extrude(), extrude_arc(), feedrate(), Slic3r::Linear_move, m_current_pos, m_enable_arc_fitting, retract(), SCALED_WIPE_TOWER_RESOLUTION, travel(), and Slic3r::unscaled().

Referenced by Slic3r::WipeTower::generate_support_wall_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_and_reset_used_filament_length()

float Slic3r::WipeTowerWriter::get_and_reset_used_filament_length ( )

inline

842{ float temp = m_used_filament_length; m_used_filament_length = 0.f; return temp; }

References m_used_filament_length.

Referenced by Slic3r::WipeTower::finish_block(), Slic3r::WipeTower::finish_block_solid(), Slic3r::WipeTower::finish_layer_new(), Slic3r::WipeTower::only_generate_out_wall(), Slic3r::WipeTower::tool_change(), Slic3r::WipeTower::tool_change_new(), and Slic3r::WipeTower::toolchange_Change().

Here is the caller graph for this function:

◆ line()

WipeTowerWriter & Slic3r::WipeTowerWriter::line	(	const WipeTower *	wipe_tower,
		Vec2f	p0,
		Vec2f	p1,
		const float	f = 0.f )

inline

    {
        bool need_change_flow = wipe_tower->need_thick_bridge_flow(p0.y());
        if (need_change_flow) {
            set_extrusion_flow(wipe_tower->extrusion_flow(0.2));
            append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height) + Slic3r::float_to_string_decimal_point(0.2, 6) + "\n");
        }
        if (abs(x() - p0.x()) > abs(x() - p1.x())) std::swap(p0, p1);
        travel(p0.x(), y());
        travel(x(), p0.y());
        extrude(p1, f);
        if (need_change_flow) {
            set_extrusion_flow(wipe_tower->get_extrusion_flow());
            append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height) + Slic3r::float_to_string_decimal_point(m_layer_height, 6) + "\n");
        }
        return (*this);
    }

References WipeTowerWriter(), append(), extrude(), Slic3r::WipeTower::extrusion_flow(), Slic3r::f(), Slic3r::float_to_string_decimal_point(), Slic3r::WipeTower::get_extrusion_flow(), Slic3r::GCodeProcessor::Height, m_layer_height, Slic3r::WipeTower::need_thick_bridge_flow(), Slic3r::GCodeProcessor::reserved_tag(), set_extrusion_flow(), travel(), x(), and y().

Referenced by rectangle_fill_box().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load()

WipeTowerWriter & Slic3r::WipeTowerWriter::load	(	float	e,
		float	f = 0.f )

inline

  {
    if (e == 0.f && (f == 0.f || f == m_current_feedrate))
      return *this;
    m_gcode += "G1";
    if (e != 0.f)
      m_gcode += set_format_E(e);
    if (f != 0.f && f != m_current_feedrate)
      m_gcode += set_format_F(f);
    m_gcode += "\n";
    return *this;
  }

References WipeTowerWriter(), Slic3r::f(), m_current_feedrate, m_gcode, set_format_E(), and set_format_F().

Referenced by retract(), and Slic3r::WipeTower::toolchange_Load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_move_x_advanced()

WipeTowerWriter & Slic3r::WipeTowerWriter::load_move_x_advanced	(	float	farthest_x,
		float	loading_dist,
		float	loading_speed,
		float	max_x_speed = 50.f )

inline

    {
        float time = std::abs(loading_dist / loading_speed); // time that the move must take
        float x_distance = std::abs(farthest_x - x());       // max x-distance that we can travel
        float x_speed = x_distance / time;                   // x-speed to do it in that time
 
        if (x_speed > max_x_speed) {
            // Necessary x_speed is too high - we must shorten the distance to achieve max_x_speed and still respect the time.
            x_distance = max_x_speed * time;
            x_speed = max_x_speed;
        }
 
        float end_point = x() + (farthest_x > x() ? 1.f : -1.f) * x_distance;
        return extrude_explicit(end_point, y(), loading_dist, x_speed * 60.f, false, LimitFlow::None);
    }

References WipeTowerWriter(), extrude_explicit(), Slic3r::None, x(), and y().

Referenced by Slic3r::WipeTower::toolchange_Load(), and Slic3r::WipeTower::toolchange_Unload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=()

WipeTowerWriter & Slic3r::WipeTowerWriter::operator= ( const WipeTowerWriter & rhs )

private

References WipeTowerWriter().

Here is the call graph for this function:

◆ polygon()

WipeTowerWriter & Slic3r::WipeTowerWriter::polygon	(	const Polygon &	wall_polygon,
		const float	f = 0.f )

inline

    {
        Polyline    pl = to_polyline(wall_polygon);
        pl.simplify(WT_SIMPLIFY_TOLERANCE_SCALED);
        if (m_enable_arc_fitting) {
            pl.simplify_by_fitting_arc(SCALED_WIPE_TOWER_RESOLUTION);
        } else {
            pl.simplify(SCALED_WIPE_TOWER_RESOLUTION);
            pl.reset_to_linear_move();
        }
 
        auto get_closet_idx = [this](std::vector<Segment> &corners) -> int {
            Vec2f anchor{this->m_current_pos.x(), this->m_current_pos.y()};
            int   closestIndex = -1;
            float minDistance  = std::numeric_limits<float>::max();
            for (int i = 0; i < corners.size(); ++i) {
                float distance = (corners[i].start - anchor).squaredNorm();
                if (distance < minDistance) {
                    minDistance  = distance;
                    closestIndex = i;
                }
            }
            return closestIndex;
        };
        std::vector<Segment> segments;
        for (int i = 0; i < pl.fitting_result.size(); i++) {
            if (pl.fitting_result[i].path_type == EMovePathType::Linear_move) {
                for (int j = pl.fitting_result[i].start_point_index; j < pl.fitting_result[i].end_point_index; j++)
                    segments.push_back({unscaled<float>(pl.points[j]), unscaled<float>(pl.points[j + 1])});
            } else {
                int beg = pl.fitting_result[i].start_point_index;
                int end = pl.fitting_result[i].end_point_index;
                segments.push_back({unscaled<float>(pl.points[beg]), unscaled<float>(pl.points[end])});
                segments.back().is_arc     = true;
                segments.back().arcsegment = pl.fitting_result[i].arc_data;
            }
        }
 
        if (segments.empty())
            return (*this);
 
        int index_of_closest = get_closet_idx(segments);
        int i                = index_of_closest;
        travel(segments[i].start); // travel to the closest points
        segments[i].is_arc ? extrude_arc(segments[i].arcsegment, f) : extrude(segments[i].end, f);
        do {
            i = (i + 1) % segments.size();
            if (i == index_of_closest) break;
            segments[i].is_arc ? extrude_arc(segments[i].arcsegment, f) : extrude(segments[i].end, f);
        } while (1);
        return (*this);
    }

References WipeTowerWriter(), extrude(), extrude_arc(), Slic3r::f(), Slic3r::Polyline::fitting_result, Slic3r::Linear_move, m_current_pos, m_enable_arc_fitting, Slic3r::MultiPoint::points, Slic3r::Polyline::reset_to_linear_move(), SCALED_WIPE_TOWER_RESOLUTION, Slic3r::Polyline::simplify(), Slic3r::Polyline::simplify_by_fitting_arc(), Slic3r::to_polyline(), travel(), Slic3r::unscaled(), and Slic3r::WT_SIMPLIFY_TOLERANCE_SCALED.

Referenced by add_wipe_path(), and Slic3r::WipeTower::finish_layer_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pos()

const Vec2f & Slic3r::WipeTowerWriter::pos ( ) const

inline

838{ return m_current_pos; }

References m_current_pos.

Referenced by Slic3r::WipeTower::construct_block_tcr(), Slic3r::WipeTower::construct_tcr(), Slic3r::WipeTower::finish_block(), Slic3r::WipeTower::finish_block_solid(), Slic3r::WipeTower::finish_layer_new(), Slic3r::WipeTower::generate_support_wall(), Slic3r::WipeTower::ramming(), rectangle_fill_box(), set_initial_position(), and Slic3r::WipeTower::toolchange_wipe_new().

Here is the caller graph for this function:

◆ pos_rotated()

const Vec2f Slic3r::WipeTowerWriter::pos_rotated ( ) const

inline

840{ return this->rotate(m_current_pos); }

References m_current_pos, and rotate().

Referenced by Slic3r::WipeTower::construct_block_tcr(), Slic3r::WipeTower::construct_tcr(), extrude_arc_explicit(), extrude_explicit(), Slic3r::WipeTower::ramming(), and Slic3r::WipeTower::toolchange_Change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ram()

WipeTowerWriter & Slic3r::WipeTowerWriter::ram	(	float	x1,
		float	x2,
		float	dy,
		float	e0,
		float	e,
		float	f )

inline

  {
        extrude_explicit(x1, m_current_pos.y() + dy, e0, f, true, LimitFlow::None);
        extrude_explicit(x2, m_current_pos.y(), e, 0.f, true, LimitFlow::None);
    return *this;
  }

References WipeTowerWriter(), extrude_explicit(), Slic3r::f(), m_current_pos, and Slic3r::None.

Referenced by Slic3r::WipeTower::toolchange_Unload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rectangle() [1/2]

WipeTowerWriter & Slic3r::WipeTowerWriter::rectangle	(	const Vec2f &	ld,
		float	width,
		float	height,
		const float	f = 0.f )

inline

    {
        Vec2f corners[4];
        corners[0] = ld;
        corners[1] = ld + Vec2f(width,0.f);
        corners[2] = ld + Vec2f(width,height);
        corners[3] = ld + Vec2f(0.f,height);
        int index_of_closest = 0;
        if (x()-ld.x() > ld.x()+width-x())    // closer to the right
            index_of_closest = 1;
        if (y()-ld.y() > ld.y()+height-y())   // closer to the top
            index_of_closest = (index_of_closest==0 ? 3 : 2);
 
        travel(corners[index_of_closest].x(), y());      // travel to the closest corner
        travel(x(),corners[index_of_closest].y());
 
        int i = index_of_closest;
        do {
            ++i;
            if (i==4) i=0;
            extrude(corners[i], f);
        } while (i != index_of_closest);
        return (*this);
    }

References WipeTowerWriter(), extrude(), Slic3r::f(), travel(), x(), and y().

Referenced by rectangle(), and Slic3r::WipeTower::tool_change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rectangle() [2/2]

WipeTowerWriter & Slic3r::WipeTowerWriter::rectangle	(	const WipeTower::box_coordinates &	box,
		const float	f = 0.f )

inline

    {
        rectangle(Vec2f(box.ld.x(), box.ld.y()),
                  box.ru.x() - box.lu.x(),
                  box.ru.y() - box.rd.y(), f);
        return (*this);
    }

References WipeTowerWriter(), Slic3r::f(), Slic3r::WipeTower::box_coordinates::ld, Slic3r::WipeTower::box_coordinates::lu, Slic3r::WipeTower::box_coordinates::rd, rectangle(), and Slic3r::WipeTower::box_coordinates::ru.

Here is the call graph for this function:

◆ rectangle_fill_box() [1/2]

WipeTowerWriter & Slic3r::WipeTowerWriter::rectangle_fill_box	(	const WipeTower *	wipe_tower,
		const Vec2f &	ld,
		float	width,
		float	height,
		const float	f = 0.f )

inline

    {
        bool need_change_flow = wipe_tower->need_thick_bridge_flow(ld.y());
 
        Vec2f corners[4];
        corners[0]           = ld;
        corners[1]           = ld + Vec2f(width, 0.f);
        corners[2]           = ld + Vec2f(width, height);
        corners[3]           = ld + Vec2f(0.f, height);
        int index_of_closest = 0;
        if (x() - ld.x() > ld.x() + width - x()) // closer to the right
            index_of_closest = 1;
        if (y() - ld.y() > ld.y() + height - y()) // closer to the top
            index_of_closest = (index_of_closest == 0 ? 3 : 2);
 
        travel(corners[index_of_closest].x(), y()); // travel to the closest corner
        travel(x(), corners[index_of_closest].y());
 
        int i = index_of_closest;
        bool flow_changed = false;
        do {
            ++i;
            if (i == 4) i = 0;
            if (need_change_flow) {
                if (i == 1) {
                    // using bridge flow in bridge area, and add notes for gcode-check when flow changed
                    set_extrusion_flow(wipe_tower->extrusion_flow(0.2));
                    append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height) + Slic3r::float_to_string_decimal_point(0.2, 6) + "\n");
                    flow_changed = true;
                } else if (i == 2 && flow_changed) {
                    set_extrusion_flow(wipe_tower->get_extrusion_flow());
                    append(";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height) + Slic3r::float_to_string_decimal_point(m_layer_height, 6) + "\n");
                }
            }
            extrude(corners[i], f);
        } while (i != index_of_closest);
        return (*this);
    }

References WipeTowerWriter(), append(), extrude(), Slic3r::WipeTower::extrusion_flow(), Slic3r::f(), Slic3r::float_to_string_decimal_point(), Slic3r::WipeTower::get_extrusion_flow(), Slic3r::GCodeProcessor::Height, m_layer_height, Slic3r::WipeTower::need_thick_bridge_flow(), Slic3r::GCodeProcessor::reserved_tag(), set_extrusion_flow(), travel(), x(), and y().

Referenced by Slic3r::WipeTower::finish_block(), Slic3r::WipeTower::finish_layer_new(), and rectangle_fill_box().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rectangle_fill_box() [2/2]

WipeTowerWriter & Slic3r::WipeTowerWriter::rectangle_fill_box	(	const WipeTower *	wipe_tower,
		const WipeTower::box_coordinates &	fill_box,
		std::vector< Vec2f > &	finish_rect_wipe_path,
		const float	f = 0.f )

inline

    {
        float width  = fill_box.rd.x() - fill_box.ld.x();
        float height = fill_box.ru.y() - fill_box.rd.y();
        if (height > wipe_tower->m_perimeter_width - wipe_tower->WT_EPSILON) {
            rectangle_fill_box(wipe_tower, fill_box.ld, width, height, f);
            Vec2f target = (pos() == fill_box.ld ? fill_box.rd : (pos() == fill_box.rd ? fill_box.ru : (pos() == fill_box.ru ? fill_box.lu : fill_box.ld)));
            finish_rect_wipe_path.emplace_back(pos());
            finish_rect_wipe_path.emplace_back(target);
        } else if (height > wipe_tower->WT_EPSILON) {
            line(wipe_tower, fill_box.ld, fill_box.rd);
            Vec2f target = (pos() == fill_box.ld ? fill_box.rd : fill_box.ld);
            finish_rect_wipe_path.emplace_back(pos());
            finish_rect_wipe_path.emplace_back(target);
        }
        return (*this);
    }

References WipeTowerWriter(), Slic3r::f(), Slic3r::WipeTower::box_coordinates::ld, line(), Slic3r::WipeTower::box_coordinates::lu, Slic3r::WipeTower::m_perimeter_width, pos(), Slic3r::WipeTower::box_coordinates::rd, rectangle_fill_box(), Slic3r::WipeTower::box_coordinates::ru, and Slic3r::WipeTower::WT_EPSILON.

Here is the call graph for this function:

◆ reset_extruder()

WipeTowerWriter & Slic3r::WipeTowerWriter::reset_extruder ( )

inline

  {
    m_gcode += "G92 E0\n";
    return *this;
  }

References WipeTowerWriter(), and m_gcode.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resume_preview()

WipeTowerWriter & Slic3r::WipeTowerWriter::resume_preview ( )

inline

822{ m_preview_suppressed = false; return *this; }

References WipeTowerWriter(), and m_preview_suppressed.

Referenced by Slic3r::WipeTower::toolchange_Load(), and Slic3r::WipeTower::toolchange_Unload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ retract()

WipeTowerWriter & Slic3r::WipeTowerWriter::retract	(	float	e,
		float	f = 0.f )

inline

1189 { return load(-e, f); }

Slic3r::WipeTowerWriter::load

WipeTowerWriter & load(float e, float f=0.f)

Definition WipeTower.cpp:1175

References WipeTowerWriter(), Slic3r::f(), and load().

Referenced by Slic3r::WipeTower::finish_block_solid(), generate_path(), Slic3r::WipeTower::generate_support_wall(), Slic3r::WipeTower::toolchange_Unload(), and Slic3r::WipeTower::toolchange_wipe_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rotate()

Vec2f Slic3r::WipeTowerWriter::rotate ( Vec2f pt ) const

inlineprivate

  {
    pt.x() -= m_wipe_tower_width / 2.f;
    pt.y() += m_y_shift - m_wipe_tower_depth / 2.f;
      double angle = m_internal_angle * float(M_PI/180.);
      double c = cos(angle);
      double s = sin(angle);
      return Vec2f(float(pt.x() * c - pt.y() * s) + m_wipe_tower_width / 2.f, float(pt.x() * s + pt.y() * c) + m_wipe_tower_depth / 2.f);
  }

References Slic3r::angle(), m_internal_angle, M_PI, m_wipe_tower_depth, m_wipe_tower_width, and m_y_shift.

Referenced by add_wipe_point(), extrude_arc_explicit(), extrude_explicit(), pos_rotated(), and set_initial_position().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_accel_to_decel_enable()

void Slic3r::WipeTowerWriter::set_accel_to_decel_enable ( bool enable )

inline

1478{ m_accel_to_decel_enable = enable; }

Slic3r::WipeTowerWriter::m_accel_to_decel_enable

bool m_accel_to_decel_enable

Definition WipeTower.cpp:1559

References m_accel_to_decel_enable.

Referenced by Slic3r::WipeTower::set_for_wipe_tower_writer().

Here is the caller graph for this function:

◆ set_accel_to_decel_factor()

void Slic3r::WipeTowerWriter::set_accel_to_decel_factor ( float factor )

inline

1479{ m_accel_to_decel_factor = factor; }

Slic3r::WipeTowerWriter::m_accel_to_decel_factor

float m_accel_to_decel_factor

Definition WipeTower.cpp:1560

References m_accel_to_decel_factor.

Referenced by Slic3r::WipeTower::set_for_wipe_tower_writer().

Here is the caller graph for this function:

◆ set_acceleration_impl()

std::string Slic3r::WipeTowerWriter::set_acceleration_impl ( unsigned int acceleration )

inlineprivate

                                                               {
        // Clamp the acceleration to the allowed maximum.
        if (m_max_acceleration > 0 && acceleration > m_max_acceleration)
            acceleration = m_max_acceleration;
 
        if (acceleration == 0 || acceleration == m_last_acceleration)
            return std::string();
 
        m_last_acceleration = acceleration;
 
        std::ostringstream gcode;
        if (m_gcode_flavor == gcfRepetier) {
            // M201: Set max printing acceleration
            gcode << "M201 X" << acceleration << " Y" << acceleration;
            gcode << "\n";
            // M202: Set max travel acceleration
            gcode << "M202 X" << acceleration << " Y" << acceleration;
        } else if (m_gcode_flavor == gcfRepRapFirmware) {
            // M204: Set default acceleration
            gcode << "M204 P" << acceleration;
        } else if (m_gcode_flavor == gcfMarlinFirmware) {
            // This is new MarlinFirmware with separated print/retraction/travel acceleration.
            // Use M204 P, we don't want to override travel acc by M204 S (which is deprecated anyway).
            gcode << "M204 P" << acceleration;
        }
        else if (m_gcode_flavor == gcfKlipper && m_accel_to_decel_enable) {
            // One line, so Klipper derives the limit from this acceleration rather than the previous one.
            std::string limits = "SET_VELOCITY_LIMIT ACCEL=" + std::to_string(acceleration);
            GCodeWriter::append_klipper_accel_to_decel(limits, acceleration, m_accel_to_decel_factor);
            gcode << limits;
        }
        else {
            // M204: Set default acceleration
            gcode << "M204 S" << acceleration;
        }
        gcode << "\n";
        return gcode.str();
    }

References Slic3r::GCodeWriter::append_klipper_accel_to_decel(), Slic3r::gcfKlipper, Slic3r::gcfMarlinFirmware, Slic3r::gcfRepetier, Slic3r::gcfRepRapFirmware, gcode(), m_accel_to_decel_enable, m_accel_to_decel_factor, m_gcode_flavor, m_last_acceleration, and m_max_acceleration.

Referenced by set_normal_acceleration(), and set_travel_acceleration().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_extruder_temp()

WipeTowerWriter & Slic3r::WipeTowerWriter::set_extruder_temp	(	int	temperature,
		bool	wait = false )

inline

  {
        m_gcode += "M" + std::to_string(wait ? 109 : 104) + " S" + std::to_string(temperature) + "\n";
        return *this;
    }

References WipeTowerWriter(), m_gcode, and wait().

Referenced by Slic3r::WipeTower::toolchange_Unload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_extruder_trimpot()

WipeTowerWriter & Slic3r::WipeTowerWriter::set_extruder_trimpot ( int current )

inline

  {
        // BBS: don't control trimpot
#if 0
        if (m_gcode_flavor == gcfRepRapSprinter || m_gcode_flavor == gcfRepRapFirmware)
            m_gcode += "M906 E";
        else
            m_gcode += "M907 E";
        m_gcode += std::to_string(current) + "\n";
#endif
    return *this;
    }

References WipeTowerWriter(), Slic3r::gcfRepRapFirmware, Slic3r::gcfRepRapSprinter, m_gcode, and m_gcode_flavor.

Referenced by Slic3r::WipeTower::toolchange_Load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_extrusion_flow()

WipeTowerWriter & Slic3r::WipeTowerWriter::set_extrusion_flow ( float flow )

inline

795 { m_extrusion_flow = flow; return *this; }

References WipeTowerWriter(), and m_extrusion_flow.

Referenced by Slic3r::WipeTower::finish_block(), Slic3r::WipeTower::finish_block_solid(), Slic3r::WipeTower::finish_layer_new(), line(), Slic3r::WipeTower::only_generate_out_wall(), Slic3r::WipeTower::ramming(), rectangle_fill_box(), Slic3r::WipeTower::tool_change(), Slic3r::WipeTower::tool_change_new(), Slic3r::WipeTower::toolchange_Wipe(), and Slic3r::WipeTower::toolchange_wipe_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_fan()

WipeTowerWriter & Slic3r::WipeTowerWriter::set_fan ( unsigned speed )

inline

  {
    if (speed == m_last_fan_speed)
      return *this;
    if (speed == 0)
      m_gcode += "M107\n";
        else
            m_gcode += "M106 S" + std::to_string(unsigned(255.0 * speed / 100.0)) + "\n";
    m_last_fan_speed = speed;
    return *this;
  }

References WipeTowerWriter(), m_gcode, and m_last_fan_speed.

Here is the call graph for this function:

◆ set_first_layer()

void Slic3r::WipeTowerWriter::set_first_layer ( bool is_first_layer )

inline

1472{ m_is_first_layer = is_first_layer; }

Slic3r::WipeTowerWriter::m_is_first_layer

bool m_is_first_layer

Definition WipeTower.cpp:1556

References m_is_first_layer.

Referenced by Slic3r::WipeTower::set_for_wipe_tower_writer().

Here is the caller graph for this function:

◆ set_first_layer_normal_acceleration()

void Slic3r::WipeTowerWriter::set_first_layer_normal_acceleration ( const std::vector< unsigned int > & accelerations )

inline

1474{ m_first_layer_normal_accelerations = accelerations; };

Slic3r::WipeTowerWriter::m_first_layer_normal_accelerations

std::vector< unsigned int > m_first_layer_normal_accelerations

Definition WipeTower.cpp:1553

References m_first_layer_normal_accelerations.

Referenced by Slic3r::WipeTower::set_for_wipe_tower_writer().

Here is the caller graph for this function:

◆ set_first_layer_travel_acceleration()

void Slic3r::WipeTowerWriter::set_first_layer_travel_acceleration ( const std::vector< unsigned int > & accelerations )

inline

1476{ m_first_layer_travel_accelerations = accelerations; };

Slic3r::WipeTowerWriter::m_first_layer_travel_accelerations

std::vector< unsigned int > m_first_layer_travel_accelerations

Definition WipeTower.cpp:1555

References m_first_layer_travel_accelerations.

Referenced by Slic3r::WipeTower::set_for_wipe_tower_writer().

Here is the caller graph for this function:

◆ set_format_E()

std::string Slic3r::WipeTowerWriter::set_format_E ( float e )

inlineprivate

                                    {
        return " E" + Slic3r::float_to_string_decimal_point(e, 4);
  }

References Slic3r::float_to_string_decimal_point().

Referenced by extrude_arc_explicit(), extrude_explicit(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_format_F()

std::string Slic3r::WipeTowerWriter::set_format_F ( float f )

inlineprivate

                                    {
        char buf[64];
        sprintf(buf, " F%d", int(floor(f + 0.5f)));
        m_current_feedrate = f;
        return buf;
  }

References Slic3r::f(), and m_current_feedrate.

Referenced by extrude_arc_explicit(), extrude_explicit(), feedrate(), load(), and z_hop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_format_I()

std::string Slic3r::WipeTowerWriter::set_format_I ( float i )

inlineprivate

1617{ return " I" + Slic3r::float_to_string_decimal_point(i, 3); }

References Slic3r::float_to_string_decimal_point().

Referenced by extrude_arc_explicit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_format_J()

std::string Slic3r::WipeTowerWriter::set_format_J ( float j )

inlineprivate

1618{ return " J" + Slic3r::float_to_string_decimal_point(j, 3); }

References Slic3r::float_to_string_decimal_point().

Referenced by extrude_arc_explicit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_format_X()

std::string Slic3r::WipeTowerWriter::set_format_X ( float x )

inlineprivate

    {
        m_current_pos.x() = x;
        return " X" + Slic3r::float_to_string_decimal_point(x, 3);
  }

References Slic3r::float_to_string_decimal_point(), m_current_pos, and x().

Referenced by extrude_arc_explicit(), and extrude_explicit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_format_Y()

std::string Slic3r::WipeTowerWriter::set_format_Y ( float y )

inlineprivate

                                    {
        m_current_pos.y() = y;
        return " Y" + Slic3r::float_to_string_decimal_point(y, 3);
  }

References Slic3r::float_to_string_decimal_point(), m_current_pos, and y().

Referenced by extrude_arc_explicit(), and extrude_explicit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_format_Z()

std::string Slic3r::WipeTowerWriter::set_format_Z ( float z )

inlineprivate

                                    {
        return " Z" + Slic3r::float_to_string_decimal_point(z, 3);
  }

References Slic3r::float_to_string_decimal_point().

Referenced by z_hop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_initial_position()

WipeTowerWriter & Slic3r::WipeTowerWriter::set_initial_position	(	const Vec2f &	pos,
		float	width = 0.f,
		float	depth = 0.f,
		float	internal_angle = 0.f )

inline

                                                                                                                                  {
        m_wipe_tower_width = width;
        m_wipe_tower_depth = depth;
        m_internal_angle = internal_angle;
    m_start_pos = this->rotate(pos);
    m_current_pos = pos;
    return *this;
  }

References WipeTowerWriter(), m_current_pos, m_internal_angle, m_start_pos, m_wipe_tower_depth, m_wipe_tower_width, pos(), and rotate().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_initial_tool()

WipeTowerWriter & Slic3r::WipeTowerWriter::set_initial_tool ( size_t tool )

inline

789{ m_current_tool = tool; return *this; }

References WipeTowerWriter(), and m_current_tool.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_layer_id()

void Slic3r::WipeTowerWriter::set_layer_id ( int layer_id )

inline

1480{ m_layer_id = layer_id; }

Slic3r::WipeTowerWriter::m_layer_id

int m_layer_id

Definition WipeTower.cpp:1562

References m_layer_id.

Referenced by Slic3r::WipeTower::set_for_wipe_tower_writer().

Here is the caller graph for this function:

◆ set_max_acceleration()

void Slic3r::WipeTowerWriter::set_max_acceleration ( unsigned int acceleration )

inline

1477{ m_max_acceleration = acceleration; };

References m_max_acceleration.

Referenced by Slic3r::WipeTower::set_for_wipe_tower_writer().

Here is the caller graph for this function:

◆ set_multi_nozzle_group_result()

void Slic3r::WipeTowerWriter::set_multi_nozzle_group_result ( const MultiNozzleUtils::LayeredNozzleGroupResult * multi_nozzle_group_result )

inline

1481{ m_multi_nozzle_group_result = multi_nozzle_group_result; }

Slic3r::WipeTowerWriter::m_multi_nozzle_group_result

const MultiNozzleUtils::LayeredNozzleGroupResult * m_multi_nozzle_group_result

Definition WipeTower.cpp:1561

References m_multi_nozzle_group_result.

Referenced by Slic3r::WipeTower::set_for_wipe_tower_writer().

Here is the caller graph for this function:

◆ set_normal_acceleration() [1/2]

std::string Slic3r::WipeTowerWriter::set_normal_acceleration ( )

inlineprivate

                                        {
        std::vector<unsigned int> accelerations = m_is_first_layer ? m_first_layer_normal_accelerations : m_normal_accelerations;
        if (accelerations.empty() || !m_multi_nozzle_group_result)
            return std::string();
        int extruder_id = m_multi_nozzle_group_result->get_extruder_id(m_current_tool, m_layer_id);
        // Orca: get_extruder_id returns -1 when the filament is not covered by the map
        // (reachable with a stale manual filament map); skip instead of indexing out of bounds.
        if (extruder_id < 0 || extruder_id >= (int) accelerations.size())
            return std::string();
        unsigned int acc         = accelerations[extruder_id];
        return set_acceleration_impl(acc);
    }

References m_current_tool, m_first_layer_normal_accelerations, m_is_first_layer, m_layer_id, m_multi_nozzle_group_result, m_normal_accelerations, and set_acceleration_impl().

Referenced by extrude_arc_explicit(), and extrude_explicit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_normal_acceleration() [2/2]

void Slic3r::WipeTowerWriter::set_normal_acceleration ( const std::vector< unsigned int > & accelerations )

inline

1473{ m_normal_accelerations = accelerations; };

References m_normal_accelerations.

Referenced by Slic3r::WipeTower::set_for_wipe_tower_writer().

Here is the caller graph for this function:

◆ set_physical_extruder_map()

void Slic3r::WipeTowerWriter::set_physical_extruder_map ( const std::vector< int > & physical_extruder_map )

inline

1482{ m_physical_extruder_map = physical_extruder_map; }

Slic3r::physical_extruder_map

zaa_minimize_perimeter_height physical_extruder_map((ConfigOptionIntsNullable, nozzle_flush_dataset))((ConfigOptionFloatsNullable

References m_physical_extruder_map, and Slic3r::physical_extruder_map().

Referenced by Slic3r::WipeTower::set_for_wipe_tower_writer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_tool()

WipeTowerWriter & Slic3r::WipeTowerWriter::set_tool ( size_t tool )

inline

  {
    m_current_tool = tool;
    return *this;
  }

References WipeTowerWriter(), and m_current_tool.

Referenced by Slic3r::WipeTower::toolchange_Change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_travel_acceleration() [1/2]

std::string Slic3r::WipeTowerWriter::set_travel_acceleration ( )

inlineprivate

    {
        std::vector<unsigned int> accelerations = m_is_first_layer ? m_first_layer_travel_accelerations : m_travel_accelerations;
        if (accelerations.empty() || !m_multi_nozzle_group_result)
            return std::string();
        int extruder_id = m_multi_nozzle_group_result->get_extruder_id(m_current_tool, m_layer_id);
        // Orca: get_extruder_id returns -1 when the filament is not covered by the map
        // (reachable with a stale manual filament map); skip instead of indexing out of bounds.
        if (extruder_id < 0 || extruder_id >= (int) accelerations.size())
            return std::string();
        unsigned int acc = accelerations[extruder_id];
        return set_acceleration_impl(acc);
    }

References m_current_tool, m_first_layer_travel_accelerations, m_is_first_layer, m_layer_id, m_multi_nozzle_group_result, m_travel_accelerations, and set_acceleration_impl().

Referenced by extrude_arc_explicit(), and extrude_explicit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_travel_acceleration() [2/2]

void Slic3r::WipeTowerWriter::set_travel_acceleration ( const std::vector< unsigned int > & accelerations )

inline

1475{ m_travel_accelerations = accelerations; };

References m_travel_accelerations.

Referenced by Slic3r::WipeTower::set_for_wipe_tower_writer().

Here is the caller graph for this function:

◆ set_y_shift()

WipeTowerWriter & Slic3r::WipeTowerWriter::set_y_shift ( float shift )

inline

                                                    {
        m_current_pos.y() -= shift-m_y_shift;
        m_y_shift = shift;
        return (*this);
    }

References WipeTowerWriter(), m_current_pos, and m_y_shift.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_z()

WipeTowerWriter & Slic3r::WipeTowerWriter::set_z ( float z )

inline

792 { m_current_z = z; return *this; }

References WipeTowerWriter(), and m_current_z.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ speed_override()

WipeTowerWriter & Slic3r::WipeTowerWriter::speed_override ( int speed )

inline

  {
        m_gcode += "M220 S" + std::to_string(speed) + "\n";
    return *this;
    }

References WipeTowerWriter(), and m_gcode.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ speed_override_backup()

WipeTowerWriter & Slic3r::WipeTowerWriter::speed_override_backup ( )

inline

    {
        // BBS: BBL machine don't support speed backup
        if (m_gcode_flavor == gcfMarlinLegacy || m_gcode_flavor == gcfMarlinFirmware)
            m_gcode += "M220 B\n";
        return *this;
    }

References WipeTowerWriter(), Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, m_gcode, and m_gcode_flavor.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ speed_override_restore()

WipeTowerWriter & Slic3r::WipeTowerWriter::speed_override_restore ( )

inline

    {
        // BBS: BBL machine don't support speed restore
        if (m_gcode_flavor == gcfMarlinLegacy || m_gcode_flavor == gcfMarlinFirmware)
            m_gcode += "M220 R\n";
        return *this;
    }

References WipeTowerWriter(), Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, m_gcode, and m_gcode_flavor.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ spiral_flat_ironing()

void Slic3r::WipeTowerWriter::spiral_flat_ironing	(	const Vec2f &	center,
		float	area,
		float	step_length,
		float	feedrate )

inline

    {
        float edge_length = std::sqrt(area);
        Vec2f box_max     = center + Vec2f{step_length, step_length};
        Vec2f box_min     = center - Vec2f{step_length, step_length};
        int   n           = std::ceil(edge_length / step_length / 2.f);
        if (n <= 0) return;
        while (n--) {
            travel(box_max.x(), m_current_pos.y(), feedrate);
            travel(m_current_pos.x(), box_max.y(), feedrate);
            travel(box_min.x(), m_current_pos.y(), feedrate);
            travel(m_current_pos.x(), box_min.y(), feedrate);
 
            box_max += Vec2f{step_length, step_length};
            box_min -= Vec2f{step_length, step_length};
        }
    }

References Slic3r::area(), Slic3r::center(), Slic3r::edge_length(), feedrate(), m_current_pos, and travel().

Referenced by Slic3r::WipeTower::toolchange_wipe_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ start_pos_rotated()

const Vec2f Slic3r::WipeTowerWriter::start_pos_rotated ( ) const

inline

839{ return m_start_pos; }

References m_start_pos.

Referenced by Slic3r::WipeTower::construct_block_tcr(), Slic3r::WipeTower::construct_tcr(), and Slic3r::WipeTower::ramming().

Here is the caller graph for this function:

◆ suppress_preview()

WipeTowerWriter & Slic3r::WipeTowerWriter::suppress_preview ( )

inline

821{ m_preview_suppressed = true; return *this; }

References WipeTowerWriter(), and m_preview_suppressed.

Referenced by Slic3r::WipeTower::toolchange_Load(), and Slic3r::WipeTower::toolchange_Unload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ travel() [1/2]

WipeTowerWriter & Slic3r::WipeTowerWriter::travel	(	const Vec2f &	dest,
		float	f = 0.f )

inline

1000 { return extrude_explicit(dest.x(), dest.y(), 0.f, f); }

References WipeTowerWriter(), extrude_explicit(), and Slic3r::f().

Here is the call graph for this function:

◆ travel() [2/2]

WipeTowerWriter & Slic3r::WipeTowerWriter::travel	(	float	x,
		float	y,
		float	f = 0.f )

inline

997 { return extrude_explicit(x, y, 0.f, f); }

References WipeTowerWriter(), extrude_explicit(), Slic3r::f(), x(), and y().

Referenced by Slic3r::WipeTower::finish_block(), Slic3r::WipeTower::finish_layer_new(), generate_path(), Slic3r::WipeTower::generate_support_wall(), line(), polygon(), Slic3r::WipeTower::ramming(), rectangle(), rectangle_fill_box(), spiral_flat_ironing(), Slic3r::WipeTower::tool_change(), Slic3r::WipeTower::tool_change_new(), Slic3r::WipeTower::toolchange_Load(), Slic3r::WipeTower::toolchange_Unload(), Slic3r::WipeTower::toolchange_Wipe(), and Slic3r::WipeTower::toolchange_wipe_new().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ wait()

WipeTowerWriter & Slic3r::WipeTowerWriter::wait ( float time )

inline

  {
        if (time==0.f)
            return *this;
        m_gcode += wait_command(m_gcode_flavor, time);
    return *this;
    }

References WipeTowerWriter(), m_gcode, m_gcode_flavor, and Slic3r::wait_command().

Referenced by set_extruder_temp(), and Slic3r::WipeTower::toolchange_Unload().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ wipe_path()

const std::vector< Vec2f > & Slic3r::WipeTowerWriter::wipe_path ( ) const

inline

    {
        return m_wipe_path;
    }

References m_wipe_path.

Referenced by add_wipe_path(), Slic3r::WipeTower::construct_block_tcr(), and Slic3r::WipeTower::construct_tcr().

Here is the caller graph for this function:

◆ x()

float Slic3r::WipeTowerWriter::x ( ) const

inline

836{ return m_current_pos.x(); }

References m_current_pos.

Here is the caller graph for this function:

◆ y()

float Slic3r::WipeTowerWriter::y ( ) const

inline

837{ return m_current_pos.y(); }

References m_current_pos.

Here is the caller graph for this function:

◆ z_hop()

WipeTowerWriter & Slic3r::WipeTowerWriter::z_hop	(	float	hop,
		float	f = 0.f )

inline

  {
    m_gcode += std::string("G1") + set_format_Z(m_current_z + hop);
    if (f != 0 && f != m_current_feedrate)
      m_gcode += set_format_F(f);
    m_gcode += "\n";
    return *this;
  }

References WipeTowerWriter(), Slic3r::f(), m_current_feedrate, m_current_z, m_gcode, set_format_F(), and set_format_Z().

Referenced by z_hop_reset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ z_hop_reset()

WipeTowerWriter & Slic3r::WipeTowerWriter::z_hop_reset ( float f = 0.f )

inline

1220 { return z_hop(0, f); }

Slic3r::WipeTowerWriter::z_hop

WipeTowerWriter & z_hop(float hop, float f=0.f)

Definition WipeTower.cpp:1209

References WipeTowerWriter(), Slic3r::f(), and z_hop().

Here is the call graph for this function:

Member Data Documentation

◆ current_temp

int Slic3r::WipeTowerWriter::current_temp = -1

private

◆ m_accel_to_decel_enable

bool Slic3r::WipeTowerWriter::m_accel_to_decel_enable

private

Referenced by set_accel_to_decel_enable(), and set_acceleration_impl().

◆ m_accel_to_decel_factor

float Slic3r::WipeTowerWriter::m_accel_to_decel_factor

private

Referenced by set_accel_to_decel_factor(), and set_acceleration_impl().

◆ m_current_feedrate

float Slic3r::WipeTowerWriter::m_current_feedrate

private

Referenced by WipeTowerWriter(), extrude_arc_explicit(), extrude_explicit(), feedrate(), load(), set_format_F(), and z_hop().

◆ m_current_pos

Vec2f Slic3r::WipeTowerWriter::m_current_pos

private

Referenced by WipeTowerWriter(), add_wipe_path(), cool(), extrude(), extrude_arc_explicit(), extrude_explicit(), generate_path(), polygon(), pos(), pos_rotated(), ram(), set_format_X(), set_format_Y(), set_initial_position(), set_y_shift(), spiral_flat_ironing(), x(), and y().

◆ m_current_tool

size_t Slic3r::WipeTowerWriter::m_current_tool

private

Referenced by disable_linear_advance(), extrude_arc_explicit(), extrude_explicit(), set_initial_tool(), set_normal_acceleration(), set_tool(), and set_travel_acceleration().

◆ m_current_z

float Slic3r::WipeTowerWriter::m_current_z

private

Referenced by WipeTowerWriter(), set_z(), and z_hop().

◆ m_elapsed_time

float Slic3r::WipeTowerWriter::m_elapsed_time

private

Referenced by WipeTowerWriter(), elapsed_time(), extrude_arc_explicit(), and extrude_explicit().

◆ m_enable_arc_fitting

bool Slic3r::WipeTowerWriter::m_enable_arc_fitting = true

private

Referenced by WipeTowerWriter(), generate_path(), and polygon().

◆ m_extrusion_flow

float Slic3r::WipeTowerWriter::m_extrusion_flow

private

Referenced by WipeTowerWriter(), extrude(), extrude_arc_explicit(), and set_extrusion_flow().

◆ m_extrusions

std::vector<WipeTower::Extrusion> Slic3r::WipeTowerWriter::m_extrusions

private

Referenced by extrude_arc_explicit(), extrude_explicit(), and extrusions().

◆ m_filpar

const std::vector<WipeTower::FilamentParameters>& Slic3r::WipeTowerWriter::m_filpar

private

Referenced by WipeTowerWriter(), extrude_arc_explicit(), and extrude_explicit().

◆ m_first_layer_normal_accelerations

std::vector<unsigned int> Slic3r::WipeTowerWriter::m_first_layer_normal_accelerations

private

Referenced by set_first_layer_normal_acceleration(), and set_normal_acceleration().

◆ m_first_layer_travel_accelerations

std::vector<unsigned int> Slic3r::WipeTowerWriter::m_first_layer_travel_accelerations

private

Referenced by set_first_layer_travel_acceleration(), and set_travel_acceleration().

◆ m_gcode

std::string Slic3r::WipeTowerWriter::m_gcode

private

◆ m_gcode_flavor

GCodeFlavor Slic3r::WipeTowerWriter::m_gcode_flavor

private

Referenced by WipeTowerWriter(), disable_linear_advance(), flush_planner_queue(), set_acceleration_impl(), set_extruder_trimpot(), speed_override_backup(), speed_override_restore(), and wait().

◆ m_internal_angle

float Slic3r::WipeTowerWriter::m_internal_angle = 0.f

private

Referenced by rotate(), and set_initial_position().

◆ m_is_first_layer

bool Slic3r::WipeTowerWriter::m_is_first_layer {false}

private

1556{false};

Referenced by set_first_layer(), set_normal_acceleration(), and set_travel_acceleration().

◆ m_last_acceleration

unsigned int Slic3r::WipeTowerWriter::m_last_acceleration {0}

private

1558{0};

Referenced by set_acceleration_impl().

◆ m_last_fan_speed

unsigned Slic3r::WipeTowerWriter::m_last_fan_speed = 0

private

Referenced by set_fan().

◆ m_layer_height

float Slic3r::WipeTowerWriter::m_layer_height

private

Referenced by WipeTowerWriter(), extrude_arc_explicit(), extrude_explicit(), line(), and rectangle_fill_box().

◆ m_layer_id

int Slic3r::WipeTowerWriter::m_layer_id = -1

private

Referenced by set_layer_id(), set_normal_acceleration(), and set_travel_acceleration().

◆ m_max_acceleration

unsigned int Slic3r::WipeTowerWriter::m_max_acceleration {0}

private

1557{0};

Referenced by set_acceleration_impl(), and set_max_acceleration().

◆ m_multi_nozzle_group_result

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

private

1561{nullptr};

Referenced by set_multi_nozzle_group_result(), set_normal_acceleration(), and set_travel_acceleration().

◆ m_normal_accelerations

std::vector<unsigned int> Slic3r::WipeTowerWriter::m_normal_accelerations

private

Referenced by set_normal_acceleration(), and set_normal_acceleration().

◆ m_physical_extruder_map

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

private

Referenced by format_line_M104(), format_line_M109(), and set_physical_extruder_map().

◆ m_preview_suppressed

bool Slic3r::WipeTowerWriter::m_preview_suppressed

private

Referenced by WipeTowerWriter(), extrude_arc_explicit(), extrude_explicit(), resume_preview(), and suppress_preview().

◆ m_start_pos

Vec2f Slic3r::WipeTowerWriter::m_start_pos

private

Referenced by set_initial_position(), and start_pos_rotated().

◆ m_travel_accelerations

std::vector<unsigned int> Slic3r::WipeTowerWriter::m_travel_accelerations

private

Referenced by set_travel_acceleration(), and set_travel_acceleration().

◆ m_used_filament_length

float Slic3r::WipeTowerWriter::m_used_filament_length = 0.f

private

Referenced by extrude_arc_explicit(), extrude_explicit(), and get_and_reset_used_filament_length().

◆ m_wipe_path

std::vector<Vec2f> Slic3r::WipeTowerWriter::m_wipe_path

private

Referenced by add_wipe_point(), and wipe_path().

◆ m_wipe_tower_depth

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

private

Referenced by rotate(), and set_initial_position().

◆ m_wipe_tower_width

float Slic3r::WipeTowerWriter::m_wipe_tower_width = 0.f

private

Referenced by rotate(), and set_initial_position().

◆ m_y_shift

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

private

Referenced by rotate(), and set_y_shift().

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

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

	OrcaSlicer latest OrcaSlicer

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ WipeTowerWriter()

Member Function Documentation

◆ add_wipe_path()

◆ add_wipe_point() [1/2]

◆ add_wipe_point() [2/2]

◆ append()

◆ change_analyzer_line_width()

◆ comment_with_value()

◆ cool()

◆ disable_linear_advance()

◆ elapsed_time()

◆ extrude() [1/2]

◆ extrude() [2/2]

◆ extrude_arc()

◆ extrude_arc_explicit()

◆ extrude_explicit() [1/2]

◆ extrude_explicit() [2/2]

◆ extrusions()

◆ feedrate()

◆ flush_planner_queue()

◆ format_line_M104()

◆ format_line_M109()

◆ gcode()

◆ generate_path()

◆ get_and_reset_used_filament_length()

◆ line()

◆ load()

◆ load_move_x_advanced()

◆ operator=()

◆ polygon()

◆ pos()

◆ pos_rotated()

◆ ram()

◆ rectangle() [1/2]

◆ rectangle() [2/2]

◆ rectangle_fill_box() [1/2]

◆ rectangle_fill_box() [2/2]

◆ reset_extruder()

◆ resume_preview()

◆ retract()

◆ rotate()

◆ set_accel_to_decel_enable()

◆ set_accel_to_decel_factor()

◆ set_acceleration_impl()

◆ set_extruder_temp()

◆ set_extruder_trimpot()

◆ set_extrusion_flow()

◆ set_fan()

◆ set_first_layer()

◆ set_first_layer_normal_acceleration()

◆ set_first_layer_travel_acceleration()

◆ set_format_E()

◆ set_format_F()

◆ set_format_I()

◆ set_format_J()

◆ set_format_X()

◆ set_format_Y()

◆ set_format_Z()

◆ set_initial_position()

◆ set_initial_tool()

◆ set_layer_id()

◆ set_max_acceleration()

◆ set_multi_nozzle_group_result()

◆ set_normal_acceleration() [1/2]

◆ set_normal_acceleration() [2/2]

◆ set_physical_extruder_map()

◆ set_tool()

◆ set_travel_acceleration() [1/2]

◆ set_travel_acceleration() [2/2]

◆ set_y_shift()

◆ set_z()

◆ speed_override()

◆ speed_override_backup()

◆ speed_override_restore()

◆ spiral_flat_ironing()