Slic3r::WipeTowerWriter2 Class Reference

Collaboration diagram for Slic3r::WipeTowerWriter2:

Public Member Functions
	WipeTowerWriter2 (float layer_height, float line_width, GCodeFlavor flavor, const std::vector< WipeTower2::FilamentParameters > &filament_parameters, bool enable_arc_fitting)
WipeTowerWriter2 &	change_analyzer_line_width (float line_width)
WipeTowerWriter2 &	set_initial_position (const Vec2f &pos, float width=0.f, float depth=0.f, float internal_angle=0.f)
WipeTowerWriter2 &	set_position (const Vec2f &pos)
WipeTowerWriter2 &	set_initial_tool (size_t tool)
WipeTowerWriter2 &	set_z (float z)
WipeTowerWriter2 &	set_extrusion_flow (float flow)
WipeTowerWriter2 &	set_y_shift (float shift)
WipeTowerWriter2 &	disable_linear_advance ()
WipeTowerWriter2 &	switch_filament_monitoring (bool enable)
WipeTowerWriter2 &	suppress_preview ()
WipeTowerWriter2 &	resume_preview ()
WipeTowerWriter2 &	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
const Vec2f	rotated (const Vec2f &pt) const
float	elapsed_time () const
float	get_and_reset_used_filament_length ()
WipeTowerWriter2 &	extrude_explicit (float x, float y, float e, float f=0.f, bool record_length=false, bool limit_volumetric_flow=true)
WipeTowerWriter2 &	extrude_explicit (const Vec2f &dest, float e, float f=0.f, bool record_length=false, bool limit_volumetric_flow=true)
WipeTowerWriter2 &	travel (float x, float y, float f=0.f)
WipeTowerWriter2 &	travel (const Vec2f &dest, float f=0.f)
WipeTowerWriter2 &	extrude (float x, float y, float f=0.f)
WipeTowerWriter2 &	extrude (const Vec2f &dest, const float f=0.f)
WipeTowerWriter2 &	rectangle (const Vec2f &ld, float width, float height, const float f=0.f)
WipeTowerWriter2 &	rectangle (const WipeTower::box_coordinates &box, const float f=0.f)
WipeTowerWriter2 &	load (float e, float f=0.f)
WipeTowerWriter2 &	retract (float e, float f=0.f)
WipeTowerWriter2 &	load_move_x_advanced (float farthest_x, float loading_dist, float loading_speed, float max_x_speed=50.f)
WipeTowerWriter2 &	load_move_x_advanced_there_and_back (float farthest_x, float e_dist, float e_speed, float x_speed)
WipeTowerWriter2 &	z_hop (float hop, float f=0.f)
WipeTowerWriter2 &	z_hop_reset (float f=0.f)
WipeTowerWriter2 &	ram (float x1, float x2, float dy, float e0, float e, float f)
WipeTowerWriter2 &	cool (float x1, float x2, float e1, float e2, float f)
WipeTowerWriter2 &	set_tool (size_t tool)
WipeTowerWriter2 &	set_extruder_temp (int temperature, bool wait=false, const std::string &comment=std::string())
WipeTowerWriter2 &	wait (float time)
WipeTowerWriter2 &	speed_override (int speed)
WipeTowerWriter2 &	speed_override_backup ()
WipeTowerWriter2 &	speed_override_restore ()
WipeTowerWriter2 &	set_extruder_trimpot (int current)
WipeTowerWriter2 &	flush_planner_queue ()
WipeTowerWriter2 &	reset_extruder ()
WipeTowerWriter2 &	comment_with_value (const char *comment, int value)
WipeTowerWriter2 &	set_fan (unsigned speed)
WipeTowerWriter2 &	append (const std::string &text)
const std::vector< Vec2f > &	wipe_path () const
WipeTowerWriter2 &	add_wipe_point (const Vec2f &pt)
WipeTowerWriter2 &	add_wipe_point (float x, float y)
void	spiral_flat_ironing (const Vec2f &center, float area, float step_length, float feedrate)
WipeTowerWriter2 &	extrude_arc_explicit (ArcSegment &arc, float f=0.f, bool record_length=false, LimitFlow limit_flow=LimitFlow::LimitPrintFlow)
WipeTowerWriter2 &	extrude_arc (ArcSegment &arc, float f=0.f, LimitFlow limit_flow=LimitFlow::LimitPrintFlow)
void	generate_path (Polylines &pls, float feedrate, float retract_length, float retract_speed, bool used_fillet)

Private Member Functions
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)
WipeTowerWriter2 &	operator= (const WipeTowerWriter2 &rhs)
Vec2f	rotate (Vec2f pt) const

Private Attributes
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 = false
const std::vector< WipeTower2::FilamentParameters > &	m_filpar

Detailed Description

Constructor & Destructor Documentation

WipeTowerWriter2()

Slic3r::WipeTowerWriter2::WipeTowerWriter2 ( float layer_height, float line_width, GCodeFlavor flavor, const std::vector< WipeTower2::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),
        m_gcode_flavor(flavor), m_filpar(filament_parameters)
        //m_enable_arc_fitting(enable_arc_fitting)
    {
            // ORCA: This class is only used by non 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 = false;
            // adds tag for analyzer:
            std::ostringstream str;
            str << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height) << m_layer_height << "\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::GCodeProcessor::Height, Slic3r::layer_height(), m_current_feedrate, m_current_pos, m_current_z, m_elapsed_time, 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_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(), load(), load_move_x_advanced(), load_move_x_advanced_there_and_back(), operator=(), ram(), rectangle(), rectangle(), reset_extruder(), resume_preview(), retract(), set_extruder_temp(), set_extruder_trimpot(), set_extrusion_flow(), set_fan(), set_initial_position(), set_initial_tool(), set_position(), set_tool(), set_y_shift(), set_z(), speed_override(), speed_override_backup(), speed_override_restore(), suppress_preview(), switch_filament_monitoring(), 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_point() [1/2]

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

inline

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

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

Referenced by add_wipe_point(), Slic3r::WipeTower2::finish_layer(), and Slic3r::WipeTower2::toolchange_Wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

add_wipe_point() [2/2]

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

inline

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

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

Here is the call graph for this function:

append()

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

inline

{ m_gcode += text; return *this; }

References WipeTowerWriter2(), and m_gcode.

Referenced by Slic3r::WipeTower2::finish_layer(), Slic3r::WipeTower2::prime(), Slic3r::WipeTower2::tool_change(), Slic3r::WipeTower2::toolchange_Change(), Slic3r::WipeTower2::toolchange_Load(), Slic3r::WipeTower2::toolchange_Unload(), and Slic3r::WipeTower2::toolchange_Wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

change_analyzer_line_width()

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

inline

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

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

Referenced by WipeTowerWriter2(), Slic3r::WipeTower2::toolchange_Unload(), and Slic3r::WipeTower2::toolchange_Wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

comment_with_value()

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

inline

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

References WipeTowerWriter2(), and m_gcode.

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

Here is the call graph for this function:

Here is the caller graph for this function:

cool()

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

inline

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

References WipeTowerWriter2(), extrude_explicit(), Slic3r::f(), and m_current_pos.

Here is the call graph for this function:

disable_linear_advance()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::disable_linear_advance ( )

inline

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

elapsed_time()

float Slic3r::WipeTowerWriter2::elapsed_time ( ) const

inline

{ return m_elapsed_time; }

References m_elapsed_time.

Referenced by Slic3r::WipeTower2::construct_tcr().

Here is the caller graph for this function:

extrude() [1/2]

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

inline

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

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

Here is the call graph for this function:

extrude() [2/2]

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::extrude ( float x, float y, float f = 0.f )

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, true);
  }

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

Referenced by extrude(), Slic3r::WipeTower2::finish_layer(), generate_path(), Slic3r::WipeTower2::generate_support_cone_wall(), rectangle(), Slic3r::WipeTower2::toolchange_Unload(), and Slic3r::WipeTower2::toolchange_Wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

extrude_arc()

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

inline

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

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

Referenced by generate_path().

Here is the call graph for this function:

Here is the caller graph for this function:

extrude_arc_explicit()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::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;
                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 WipeTowerWriter2(), Slic3r::Arc_Dir_CCW, Slic3r::arc_fit_size, EPSILON, Slic3r::f(), Slic3r::LimitPrintFlow, 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(), 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]

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::extrude_explicit ( const Vec2f & dest, float e, float f = 0.f, bool record_length = false, bool limit_volumetric_flow = true )

inline

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

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

Here is the call graph for this function:

extrude_explicit() [2/2]

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::extrude_explicit ( float x, float y, float e, float f = 0.f, bool record_length = false, bool limit_volumetric_flow = true )

inline

  {
    if (x == m_current_pos.x() && y == m_current_pos.y() && 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) {
      // 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));
    }
 
    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_volumetric_flow) {
                float e_speed = e / (((len == 0.f) ? std::abs(e) : len) / f * 60.f);
                f /= std::max(1.f, e_speed / m_filpar[m_current_tool].max_e_speed);
            }
      m_gcode += set_format_F(f);
        }
 
        // Append newline if at least one of X,Y,E,F was changed.
        // Otherwise, remove the "G1".
        if (! boost::ends_with(m_gcode, "G1"))
            m_gcode += "\n";
        else
            m_gcode.erase(m_gcode.end()-2, m_gcode.end());
 
        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;
    return *this;
  }

References WipeTowerWriter2(), EPSILON, Slic3r::f(), 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, pos_rotated(), rotate(), set_format_E(), set_format_F(), set_format_X(), set_format_Y(), x(), and y().

Referenced by cool(), extrude(), extrude_explicit(), load_move_x_advanced(), load_move_x_advanced_there_and_back(), ram(), Slic3r::WipeTower2::tool_change(), 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::WipeTowerWriter2::extrusions ( ) const

inline

{ return m_extrusions; }

References m_extrusions.

Referenced by Slic3r::WipeTower2::construct_tcr().

Here is the caller graph for this function:

feedrate()

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

inline

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

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

Referenced by generate_path(), Slic3r::WipeTower2::prime(), spiral_flat_ironing(), Slic3r::WipeTower2::tool_change(), and Slic3r::WipeTower2::toolchange_Change().

Here is the call graph for this function:

Here is the caller graph for this function:

flush_planner_queue()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::flush_planner_queue ( )

inline

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

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

Referenced by Slic3r::WipeTower2::prime(), set_extruder_temp(), switch_filament_monitoring(), Slic3r::WipeTower2::tool_change(), Slic3r::WipeTower2::toolchange_Change(), and Slic3r::WipeTower2::toolchange_Unload().

Here is the call graph for this function:

Here is the caller graph for this function:

gcode()

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

inline

{ return m_gcode; }

References m_gcode.

Referenced by Slic3r::WipeTower2::construct_tcr().

Here is the caller graph for this function:

generate_path()

void Slic3r::WipeTowerWriter2::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;
        };
        std::vector<Segment> segments;
        if (m_enable_arc_fitting) {
            for (auto& pl : pls)
                pl.simplify_by_fitting_arc(SCALED_WIPE_TOWER_RESOLUTION);
 
            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;
                    }
                }
            }
            for (auto& pl : pls)
                pl.simplify(SCALED_WIPE_TOWER_RESOLUTION);
 
        } else {
            for (const auto& pl : pls) {
                if (pl.points.size() < 2)
                    continue;
                for (int i = 0; i < pl.size() - 1; i++) {
                    segments.push_back({unscaled<float>(pl.points[i]), unscaled<float>(pl.points[i + 1])});
                }
            }
        }
 
        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::WipeTower2::generate_support_rib_wall().

Here is the call graph for this function:

Here is the caller graph for this function:

get_and_reset_used_filament_length()

float Slic3r::WipeTowerWriter2::get_and_reset_used_filament_length ( )

inline

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

References m_used_filament_length.

Referenced by Slic3r::WipeTower2::finish_layer(), Slic3r::WipeTower2::prime(), Slic3r::WipeTower2::tool_change(), and Slic3r::WipeTower2::toolchange_Change().

Here is the caller graph for this function:

load()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::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 WipeTowerWriter2(), Slic3r::f(), m_current_feedrate, m_gcode, set_format_E(), and set_format_F().

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

Here is the call graph for this function:

Here is the caller graph for this function:

load_move_x_advanced()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::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, false);
    }

References WipeTowerWriter2(), extrude_explicit(), x(), and y().

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

Here is the call graph for this function:

Here is the caller graph for this function:

load_move_x_advanced_there_and_back()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::load_move_x_advanced_there_and_back ( float farthest_x, float e_dist, float e_speed, float x_speed )

inline

    {
        float old_x = x();
        float time = std::abs(e_dist / e_speed); // time that the whole move must take
        float x_max_dist = std::abs(farthest_x - x());       // max x-distance that we can travel
        float x_dist = x_speed * time;                       // totel x-distance to travel during the move
        int n = int(x_dist / (2*x_max_dist) + 1.f);          // how many there and back moves should we do
        float r = 2*n*x_max_dist / x_dist;                   // actual/required dist if the move is not shortened
 
        float end_point = x() + (farthest_x > x() ? 1.f : -1.f) * x_max_dist / r;
        for (int i=0; i<n; ++i) {
            extrude_explicit(end_point, y(), e_dist/(2.f*n), x_speed * 60.f, false, false);
            extrude_explicit(old_x, y(), e_dist/(2.f*n), x_speed * 60.f, false, false);
        }
        return *this;
    }

References WipeTowerWriter2(), extrude_explicit(), x(), and y().

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

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

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

private

References WipeTowerWriter2().

Here is the call graph for this function:

pos()

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

inline

{ return m_current_pos; }

References m_current_pos.

Referenced by Slic3r::WipeTower2::construct_tcr(), Slic3r::WipeTower2::finish_layer(), set_initial_position(), set_position(), and Slic3r::WipeTower2::toolchange_Wipe().

Here is the caller graph for this function:

pos_rotated()

const Vec2f Slic3r::WipeTowerWriter2::pos_rotated ( ) const

inline

{ return this->rotate(m_current_pos); }

References m_current_pos, and rotate().

Referenced by Slic3r::WipeTower2::construct_tcr(), extrude_arc_explicit(), extrude_explicit(), and Slic3r::WipeTower2::toolchange_Change().

Here is the call graph for this function:

Here is the caller graph for this function:

ram()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::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, false);
    extrude_explicit(x2, m_current_pos.y(), e, 0.f, true, false);
    return *this;
  }

References WipeTowerWriter2(), extrude_explicit(), Slic3r::f(), and m_current_pos.

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

Here is the call graph for this function:

Here is the caller graph for this function:

rectangle() [1/2]

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::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 WipeTowerWriter2(), extrude(), Slic3r::f(), travel(), x(), and y().

Referenced by Slic3r::WipeTower2::finish_layer(), and rectangle().

Here is the call graph for this function:

Here is the caller graph for this function:

rectangle() [2/2]

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::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 WipeTowerWriter2(), 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:

reset_extruder()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::reset_extruder ( )

inline

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

References WipeTowerWriter2(), and m_gcode.

Referenced by Slic3r::WipeTower2::prime(), and Slic3r::WipeTower2::tool_change().

Here is the call graph for this function:

Here is the caller graph for this function:

resume_preview()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::resume_preview ( )

inline

{ m_preview_suppressed = false; return *this; }

References WipeTowerWriter2(), and m_preview_suppressed.

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

Here is the call graph for this function:

Here is the caller graph for this function:

retract()

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

inline

    { return load(-e, f); }

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

Referenced by generate_path(), Slic3r::WipeTower2::toolchange_Unload(), and Slic3r::WipeTower2::toolchange_Wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

rotate()

Vec2f Slic3r::WipeTowerWriter2::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(), rotated(), and set_initial_position().

Here is the call graph for this function:

Here is the caller graph for this function:

rotated()

const Vec2f Slic3r::WipeTowerWriter2::rotated ( const Vec2f & pt ) const

inline

{ return this->rotate(pt); }

References rotate().

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_extruder_temp()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::set_extruder_temp ( int temperature, bool wait = false, const std::string & comment = std::string() )

inline

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

References WipeTowerWriter2(), flush_planner_queue(), m_gcode, and wait().

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_extruder_trimpot()

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

inline

  {
        if (m_gcode_flavor == gcfKlipper)
            return *this;
        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";
    return *this;
    }

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_extrusion_flow()

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

inline

    { m_extrusion_flow = flow; return *this; }

References WipeTowerWriter2(), and m_extrusion_flow.

Referenced by Slic3r::WipeTower2::finish_layer(), Slic3r::WipeTower2::prime(), Slic3r::WipeTower2::tool_change(), and Slic3r::WipeTower2::toolchange_Wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

set_fan()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::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 WipeTowerWriter2(), m_gcode, and m_last_fan_speed.

Here is the call graph for this function:

set_format_E()

std::string Slic3r::WipeTowerWriter2::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::WipeTowerWriter2::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::WipeTowerWriter2::set_format_I ( float i )

inlineprivate

{ 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::WipeTowerWriter2::set_format_J ( float j )

inlineprivate

{ 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::WipeTowerWriter2::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::WipeTowerWriter2::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::WipeTowerWriter2::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()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::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 WipeTowerWriter2(), m_current_pos, m_internal_angle, m_start_pos, m_wipe_tower_depth, m_wipe_tower_width, pos(), and rotate().

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_initial_tool()

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

inline

{ m_current_tool = tool; return *this; }

References WipeTowerWriter2(), and m_current_tool.

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_position()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::set_position ( const Vec2f & pos )

inline

{ m_current_pos = pos; return *this; }

References WipeTowerWriter2(), m_current_pos, and pos().

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_tool()

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

inline

  {
    m_current_tool = tool;
    return *this;
  }

References WipeTowerWriter2(), and m_current_tool.

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_y_shift()

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

inline

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

References WipeTowerWriter2(), m_current_pos, and m_y_shift.

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_z()

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

inline

    { m_current_z = z; return *this; }

References WipeTowerWriter2(), and m_current_z.

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

Here is the call graph for this function:

Here is the caller graph for this function:

speed_override()

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

inline

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

References WipeTowerWriter2(), and m_gcode.

Referenced by Slic3r::WipeTower2::prime(), and Slic3r::WipeTower2::tool_change().

Here is the call graph for this function:

Here is the caller graph for this function:

speed_override_backup()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::speed_override_backup ( )

inline

    {
        // This is only supported by Prusa at this point (https://github.com/prusa3d/PrusaSlicer/issues/3114)
        if (m_gcode_flavor == gcfMarlinLegacy || m_gcode_flavor == gcfMarlinFirmware)
            m_gcode += "M220 B\n";
    return *this;
    }

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

Referenced by Slic3r::WipeTower2::prime(), and Slic3r::WipeTower2::tool_change().

Here is the call graph for this function:

Here is the caller graph for this function:

speed_override_restore()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::speed_override_restore ( )

inline

  {
        if (m_gcode_flavor == gcfMarlinLegacy || m_gcode_flavor == gcfMarlinFirmware)
            m_gcode += "M220 R\n";
    return *this;
    }

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

Referenced by Slic3r::WipeTower2::prime(), and Slic3r::WipeTower2::tool_change().

Here is the call graph for this function:

Here is the caller graph for this function:

spiral_flat_ironing()

void Slic3r::WipeTowerWriter2::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::WipeTower2::toolchange_Wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

start_pos_rotated()

const Vec2f Slic3r::WipeTowerWriter2::start_pos_rotated ( ) const

inline

{ return m_start_pos; }

References m_start_pos.

Referenced by Slic3r::WipeTower2::construct_tcr().

Here is the caller graph for this function:

suppress_preview()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::suppress_preview ( )

inline

{ m_preview_suppressed = true; return *this; }

References WipeTowerWriter2(), and m_preview_suppressed.

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

Here is the call graph for this function:

Here is the caller graph for this function:

switch_filament_monitoring()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::switch_filament_monitoring ( bool enable )

inline

                                                              {
        flush_planner_queue();
        m_gcode += enable ? "M591 R\n" : "M591 S0\n";
        return *this;
    }

References WipeTowerWriter2(), flush_planner_queue(), and m_gcode.

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

Here is the call graph for this function:

Here is the caller graph for this function:

travel() [1/2]

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

inline

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

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

Here is the call graph for this function:

travel() [2/2]

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

inline

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

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

Referenced by Slic3r::WipeTower2::finish_layer(), generate_path(), Slic3r::WipeTower2::generate_support_cone_wall(), Slic3r::WipeTower2::prime(), rectangle(), spiral_flat_ironing(), Slic3r::WipeTower2::tool_change(), Slic3r::WipeTower2::toolchange_Load(), Slic3r::WipeTower2::toolchange_Unload(), and Slic3r::WipeTower2::toolchange_Wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

wait()

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

inline

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

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

Referenced by set_extruder_temp(), and Slic3r::WipeTower2::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::WipeTowerWriter2::wipe_path ( ) const

inline

    {
        return m_wipe_path;
    }

References m_wipe_path.

Referenced by Slic3r::WipeTower2::construct_tcr().

Here is the caller graph for this function:

x()

float Slic3r::WipeTowerWriter2::x ( ) const

inline

{ return m_current_pos.x(); }

References m_current_pos.

Referenced by add_wipe_point(), extrude(), extrude_arc_explicit(), extrude_explicit(), Slic3r::WipeTower2::finish_layer(), Slic3r::WipeTower2::generate_support_cone_wall(), load_move_x_advanced(), load_move_x_advanced_there_and_back(), rectangle(), set_format_X(), Slic3r::WipeTower2::tool_change(), Slic3r::WipeTower2::toolchange_Change(), Slic3r::WipeTower2::toolchange_Load(), Slic3r::WipeTower2::toolchange_Unload(), Slic3r::WipeTower2::toolchange_Wipe(), and travel().

Here is the caller graph for this function:

y()

float Slic3r::WipeTowerWriter2::y ( ) const

inline

{ return m_current_pos.y(); }

References m_current_pos.

Referenced by add_wipe_point(), extrude(), extrude_arc_explicit(), extrude_explicit(), Slic3r::WipeTower2::finish_layer(), Slic3r::WipeTower2::generate_support_cone_wall(), load_move_x_advanced(), load_move_x_advanced_there_and_back(), Slic3r::WipeTower2::prime(), rectangle(), set_format_Y(), Slic3r::WipeTower2::tool_change(), Slic3r::WipeTower2::toolchange_Change(), Slic3r::WipeTower2::toolchange_Load(), Slic3r::WipeTower2::toolchange_Unload(), Slic3r::WipeTower2::toolchange_Wipe(), and travel().

Here is the caller graph for this function:

z_hop()

WipeTowerWriter2 & Slic3r::WipeTowerWriter2::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 WipeTowerWriter2(), 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()

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

inline

    { return z_hop(0, f); }

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

Here is the call graph for this function:

Member Data Documentation

current_temp

int Slic3r::WipeTowerWriter2::current_temp = -1

private

m_current_feedrate

float Slic3r::WipeTowerWriter2::m_current_feedrate

private

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

m_current_pos

Vec2f Slic3r::WipeTowerWriter2::m_current_pos

private

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

m_current_tool

size_t Slic3r::WipeTowerWriter2::m_current_tool

private

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

m_current_z

float Slic3r::WipeTowerWriter2::m_current_z

private

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

m_elapsed_time

float Slic3r::WipeTowerWriter2::m_elapsed_time

private

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

m_enable_arc_fitting

bool Slic3r::WipeTowerWriter2::m_enable_arc_fitting = false

private

Referenced by generate_path().

m_extrusion_flow

float Slic3r::WipeTowerWriter2::m_extrusion_flow

private

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

m_extrusions

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

private

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

m_filpar

const std::vector<WipeTower2::FilamentParameters>& Slic3r::WipeTowerWriter2::m_filpar

private

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

m_gcode

std::string Slic3r::WipeTowerWriter2::m_gcode

private

Referenced by WipeTowerWriter2(), append(), change_analyzer_line_width(), comment_with_value(), disable_linear_advance(), extrude_arc_explicit(), extrude_explicit(), feedrate(), flush_planner_queue(), gcode(), load(), reset_extruder(), set_extruder_temp(), set_extruder_trimpot(), set_fan(), speed_override(), speed_override_backup(), speed_override_restore(), switch_filament_monitoring(), wait(), and z_hop().

m_gcode_flavor

GCodeFlavor Slic3r::WipeTowerWriter2::m_gcode_flavor

private

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

m_internal_angle

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

private

Referenced by rotate(), and set_initial_position().

m_last_fan_speed

unsigned Slic3r::WipeTowerWriter2::m_last_fan_speed = 0

private

Referenced by set_fan().

m_layer_height

float Slic3r::WipeTowerWriter2::m_layer_height

private

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

m_preview_suppressed

bool Slic3r::WipeTowerWriter2::m_preview_suppressed

private

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

m_start_pos

Vec2f Slic3r::WipeTowerWriter2::m_start_pos

private

Referenced by set_initial_position(), and start_pos_rotated().

m_used_filament_length

float Slic3r::WipeTowerWriter2::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::WipeTowerWriter2::m_wipe_path

private

Referenced by add_wipe_point(), and wipe_path().

m_wipe_tower_depth

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

private

Referenced by rotate(), and set_initial_position().

m_wipe_tower_width

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

private

Referenced by rotate(), and set_initial_position().

m_y_shift

float Slic3r::WipeTowerWriter2::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/WipeTower2.cpp