Slic3r::WipeTowerWriter Class Reference

Collaboration diagram for Slic3r::WipeTowerWriter:

Public Member Functions
	WipeTowerWriter (float layer_height, float line_width, GCodeFlavor flavor, const std::vector< WipeTower::FilamentParameters > &filament_parameters)
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_position (const Vec2f &pos)
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, bool limit_volumetric_flow=true)
WipeTowerWriter &	extrude_explicit (const Vec2f &dest, float e, float f=0.f, bool record_length=false, bool limit_volumetric_flow=true)
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)
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 (const WipeTower::box_coordinates &box, 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)

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)
WipeTowerWriter &	operator= (const WipeTowerWriter &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
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  )

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_filpar(filament_parameters)
        {
            // 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) << gcode_extrusion_role_to_string(GCodeExtrusionRole::WipeTower) << "\n";
            m_gcode += str.str();
            change_analyzer_line_width(line_width);
    }

References change_analyzer_line_width(), Slic3r::gcode_extrusion_role_to_string(), Slic3r::GCodeProcessor::Height, m_gcode, m_layer_height, Slic3r::GCodeProcessor::reserved_tag(), Slic3r::GCodeProcessor::Role, and Slic3r::WipeTower.

Here is the call graph for this function:

Member Function Documentation

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 m_wipe_path, and rotate().

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

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 add_wipe_point(), x(), and y().

Here is the call graph for this function:

append()

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

inline

{ m_gcode += text; return *this; }

References m_gcode.

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

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) << line_width << "\n";
        m_gcode += str.str();
        return *this;
    }

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

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

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 comment, and m_gcode.

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

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, false);
    extrude_explicit(x2, m_current_pos.y(), e2, false, false);
    return *this;
  }

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

Here is the call graph for this function:

disable_linear_advance()

WipeTowerWriter & Slic3r::WipeTowerWriter::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 Slic3r::gcfKlipper, Slic3r::gcfRepRapFirmware, Slic3r::gcfRepRapSprinter, m_current_tool, m_gcode, and m_gcode_flavor.

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

Here is the caller graph for this function:

elapsed_time()

float Slic3r::WipeTowerWriter::elapsed_time ( ) const

inline

{ return m_elapsed_time; }

References m_elapsed_time.

Referenced by 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

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

References 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  )

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 extrude_explicit(), Slic3r::f(), m_current_pos, m_extrusion_flow, x(), and y().

Referenced by extrude(), Slic3r::WipeTower::finish_layer(), rectangle(), Slic3r::WipeTower::toolchange_Unload(), and Slic3r::WipeTower::toolchange_Wipe().

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, bool  limit_volumetric_flow = true  )

inline

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

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

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, 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) {
#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));
    }
 
    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 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(), 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

{ return m_extrusions; }

References m_extrusions.

Referenced by 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 Slic3r::f(), m_current_feedrate, m_gcode, and set_format_F().

Referenced by Slic3r::WipeTower::prime(), Slic3r::WipeTower::tool_change(), 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 += "G4 S0\n"; 
    return *this;
  }

References m_gcode.

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

Here is the caller graph for this function:

gcode()

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

inline

{ return m_gcode; }

References m_gcode.

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

Here is the caller graph for this function:

get_and_reset_used_filament_length()

float Slic3r::WipeTowerWriter::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::WipeTower::finish_layer(), Slic3r::WipeTower::prime(), Slic3r::WipeTower::tool_change(), and Slic3r::WipeTower::toolchange_Change().

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

References extrude_explicit(), 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

pos()

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

inline

{ return m_current_pos; }

References m_current_pos.

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

Here is the caller graph for this function:

pos_rotated()

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

inline

{ return this->rotate(m_current_pos); }

References m_current_pos, and rotate().

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

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

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

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

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 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()

WipeTowerWriter & Slic3r::WipeTowerWriter::reset_extruder ( )

inline

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

References m_gcode.

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

Here is the caller graph for this function:

resume_preview()

WipeTowerWriter & Slic3r::WipeTowerWriter::resume_preview ( )

inline

{ m_preview_suppressed = false; return *this; }

References m_preview_suppressed.

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

Here is the caller graph for this function:

retract()

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

inline

    { return load(-e, f); }

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

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

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(), cos(), m_internal_angle, M_PI, m_wipe_tower_depth, m_wipe_tower_width, m_y_shift, and sin().

Referenced by add_wipe_point(), 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_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 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

  {
        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 Slic3r::gcfKlipper, Slic3r::gcfRepRapFirmware, Slic3r::gcfRepRapSprinter, m_gcode, and m_gcode_flavor.

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

Here is the caller graph for this function:

set_extrusion_flow()

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

inline

    { m_extrusion_flow = flow; return *this; }

References m_extrusion_flow.

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

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 m_gcode, and m_last_fan_speed.

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_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(), floor(), and m_current_feedrate.

Referenced by 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_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_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_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 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_layer(), Slic3r::WipeTower::prime(), and Slic3r::WipeTower::tool_change().

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

{ m_current_tool = tool; return *this; }

References m_current_tool.

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

Here is the caller graph for this function:

set_position()

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

inline

{ m_current_pos = pos; return *this; }

References m_current_pos, and pos().

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

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 m_current_tool.

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

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 m_current_pos, and m_y_shift.

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

Here is the caller graph for this function:

set_z()

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

inline

    { m_current_z = z; return *this; }

References m_current_z.

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

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 m_gcode.

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

Here is the caller graph for this function:

speed_override_backup()

WipeTowerWriter & Slic3r::WipeTowerWriter::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 Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, m_gcode, and m_gcode_flavor.

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

Here is the caller graph for this function:

speed_override_restore()

WipeTowerWriter & Slic3r::WipeTowerWriter::speed_override_restore ( )

inline

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

References Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, m_gcode, and m_gcode_flavor.

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

Here is the caller graph for this function:

start_pos_rotated()

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

inline

{ return m_start_pos; }

References m_start_pos.

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

Here is the caller graph for this function:

suppress_preview()

WipeTowerWriter & Slic3r::WipeTowerWriter::suppress_preview ( )

inline

{ m_preview_suppressed = true; return *this; }

References m_preview_suppressed.

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

Here is the caller graph for this function:

travel() [1/2]

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

inline

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

References 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

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

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

Referenced by Slic3r::WipeTower::finish_layer(), Slic3r::WipeTower::prime(), rectangle(), Slic3r::WipeTower::tool_change(), Slic3r::WipeTower::toolchange_Load(), Slic3r::WipeTower::toolchange_Unload(), and Slic3r::WipeTower::toolchange_Wipe().

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 += "G4 S" + Slic3r::float_to_string_decimal_point(time, 3) + "\n";
    return *this;
    }

References Slic3r::float_to_string_decimal_point(), and m_gcode.

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 Slic3r::WipeTower::construct_tcr().

Here is the caller graph for this function:

x()

float Slic3r::WipeTowerWriter::x ( ) const

inline

{ return m_current_pos.x(); }

References m_current_pos.

Referenced by add_wipe_point(), extrude(), extrude_explicit(), Slic3r::WipeTower::finish_layer(), load_move_x_advanced(), rectangle(), set_format_X(), Slic3r::WipeTower::tool_change(), Slic3r::WipeTower::toolchange_Load(), Slic3r::WipeTower::toolchange_Unload(), Slic3r::WipeTower::toolchange_Wipe(), and travel().

Here is the caller graph for this function:

y()

float Slic3r::WipeTowerWriter::y ( ) const

inline

{ return m_current_pos.y(); }

References m_current_pos.

Referenced by add_wipe_point(), extrude(), extrude_explicit(), Slic3r::WipeTower::finish_layer(), load_move_x_advanced(), Slic3r::WipeTower::prime(), rectangle(), set_format_Y(), Slic3r::WipeTower::tool_change(), Slic3r::WipeTower::toolchange_Load(), Slic3r::WipeTower::toolchange_Unload(), Slic3r::WipeTower::toolchange_Wipe(), and travel().

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 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

    { return z_hop(0, f); }

References 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_current_feedrate

float Slic3r::WipeTowerWriter::m_current_feedrate

private

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

m_current_pos

Vec2f Slic3r::WipeTowerWriter::m_current_pos

private

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

m_current_tool

size_t Slic3r::WipeTowerWriter::m_current_tool

private

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

m_current_z

float Slic3r::WipeTowerWriter::m_current_z

private

Referenced by set_z(), and z_hop().

m_elapsed_time

float Slic3r::WipeTowerWriter::m_elapsed_time

private

Referenced by elapsed_time(), and extrude_explicit().

m_extrusion_flow

float Slic3r::WipeTowerWriter::m_extrusion_flow

private

Referenced by extrude(), and set_extrusion_flow().

m_extrusions

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

private

Referenced by extrude_explicit(), and extrusions().

m_filpar

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

private

Referenced by extrude_explicit().

m_gcode

std::string Slic3r::WipeTowerWriter::m_gcode

private

Referenced by WipeTowerWriter(), append(), change_analyzer_line_width(), comment_with_value(), disable_linear_advance(), 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(), wait(), and z_hop().

m_gcode_flavor

GCodeFlavor Slic3r::WipeTowerWriter::m_gcode_flavor

private

Referenced by disable_linear_advance(), set_extruder_trimpot(), speed_override_backup(), and speed_override_restore().

m_internal_angle

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

private

Referenced by rotate(), and set_initial_position().

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(), and extrude_explicit().

m_preview_suppressed

bool Slic3r::WipeTowerWriter::m_preview_suppressed

private

Referenced by 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_used_filament_length

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

private

Referenced by 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:

• src/libslic3r/GCode/WipeTower.cpp