Slic3r::GCodeReader::GCodeLine Class Reference

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

Collaboration diagram for Slic3r::GCodeReader::GCodeLine:

Public Member Functions
	GCodeLine ()
void	reset ()
const std::string &	raw () const
const std::string_view	cmd () const
const std::string_view	comment () const
std::string_view	axis_pos (char axis) const
void	clear ()
bool	has (Axis axis) const
float	value (Axis axis) const
double	precise_value (Axis axis) const
bool	has (char axis) const
bool	has_value (char axis, float &value) const
float	new_X (const GCodeReader &reader) const
float	new_Y (const GCodeReader &reader) const
float	new_Z (const GCodeReader &reader) const
float	new_E (const GCodeReader &reader) const
float	new_F (const GCodeReader &reader) const
float	dist_X (const GCodeReader &reader) const
float	dist_Y (const GCodeReader &reader) const
float	dist_Z (const GCodeReader &reader) const
float	dist_E (const GCodeReader &reader) const
float	dist_XY (const GCodeReader &reader) const
bool	cmd_is (const char *cmd_test) const
bool	extruding (const GCodeReader &reader) const
bool	retracting (const GCodeReader &reader) const
bool	travel () const
void	set (const Axis axis, const float new_value, const int decimal_digits=3)
bool	has_x () const
bool	has_y () const
bool	has_z () const
bool	has_e () const
bool	has_f () const
bool	has_i () const
bool	has_j () const
bool	has_p () const
bool	has_unknown_axis () const
float	x () const
float	y () const
float	z () const
float	e () const
float	f () const
float	i () const
float	j () const
float	p () const

Static Public Member Functions
static bool	has_value (std::string_view axis_pos, float &value)
static bool	cmd_is (const std::string &gcode_line, const char *cmd_test)
static bool	cmd_starts_with (const std::string &gcode_line, const char *cmd_test)
static std::string	extract_cmd (const std::string &gcode_line)

Private Attributes
std::string	m_raw
double	m_axis [NUM_AXES]
uint32_t	m_mask

Friends
class	GCodeReader

Detailed Description

Constructor & Destructor Documentation

GCodeLine()

Slic3r::GCodeReader::GCodeLine::GCodeLine ( )

inline

{ reset(); }

References reset().

Referenced by extract_cmd().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

axis_pos()

std::string_view Slic3r::GCodeReader::GCodeLine::axis_pos

(

char

axis

)

const

{
    const std::string &s = this->raw();
    const char *c = GCodeReader::axis_pos(this->raw().c_str(), axis);
    return c ? std::string_view{ c, s.size() - (c - s.data()) } : std::string_view();
}

References Slic3r::GCodeReader::axis_pos(), and raw().

Referenced by has_value(), and Slic3r::GCodeProcessor::process_G2_G3().

Here is the call graph for this function:

Here is the caller graph for this function:

clear()

void Slic3r::GCodeReader::GCodeLine::clear ( )

inline

{ m_raw.clear(); }

References m_raw.

Referenced by Slic3r::SpiralVase::process_layer().

Here is the caller graph for this function:

cmd()

const std::string_view Slic3r::GCodeReader::GCodeLine::cmd ( ) const

inline

                                          { 
            const char *cmd = GCodeReader::skip_whitespaces(m_raw.c_str());
            return std::string_view(cmd, GCodeReader::skip_word(cmd) - cmd);
        }

References cmd(), m_raw, Slic3r::GCodeReader::skip_whitespaces(), and Slic3r::GCodeReader::skip_word().

Referenced by Slic3r::FanMover::_process_gcode_line(), cmd(), cmd_is(), Slic3r::custom_gcode_motion_state_changes(), extract_cmd(), Slic3r::GCodeProcessor::process_G28(), Slic3r::GCodeProcessor::process_gcode_line(), and Slic3r::GCodeProcessor::process_T().

Here is the call graph for this function:

Here is the caller graph for this function:

cmd_is() [1/2]

bool Slic3r::GCodeReader::GCodeLine::cmd_is ( const char * cmd_test ) const

inline

{ return cmd_is(m_raw, cmd_test); }

References cmd_is(), and m_raw.

Referenced by cmd_is(), Slic3r::anonymous_namespace{GCode.cpp}::emitted_xy_after_gcode(), extruding(), Slic3r::SpiralVase::process_layer(), retracting(), Slic3r::GCodeProcessor::run_post_process(), travel(), and Slic3r::ExportLines::update().

Here is the call graph for this function:

Here is the caller graph for this function:

cmd_is() [2/2]

bool Slic3r::GCodeReader::GCodeLine::cmd_is ( const std::string & gcode_line, const char * cmd_test )

inlinestatic

                                                                              {
            const char *cmd = GCodeReader::skip_whitespaces(gcode_line.c_str());
            size_t len = strlen(cmd_test); 
            return strncmp(cmd, cmd_test, len) == 0 && GCodeReader::is_end_of_word(cmd[len]);
        }

References cmd(), Slic3r::GCodeReader::is_end_of_word(), and Slic3r::GCodeReader::skip_whitespaces().

Here is the call graph for this function:

cmd_starts_with()

bool Slic3r::GCodeReader::GCodeLine::cmd_starts_with ( const std::string & gcode_line, const char * cmd_test )

inlinestatic

                                                                                       {
            return strncmp(GCodeReader::skip_whitespaces(gcode_line.c_str()), cmd_test, strlen(cmd_test)) == 0;
        }

References Slic3r::GCodeReader::skip_whitespaces().

Referenced by Slic3r::GCodeProcessor::run_post_process().

Here is the call graph for this function:

Here is the caller graph for this function:

comment()

const std::string_view Slic3r::GCodeReader::GCodeLine::comment ( ) const

inline

            { size_t pos = m_raw.find(';'); return (pos == std::string::npos) ? std::string_view() : std::string_view(m_raw).substr(pos + 1); }

References m_raw.

dist_E()

float Slic3r::GCodeReader::GCodeLine::dist_E ( const GCodeReader & reader ) const

inline

{ return this->has(E) ? (this->e() - reader.e()) : 0; }

References Slic3r::E, Slic3r::GCodeReader::e(), e(), GCodeReader, and has().

Referenced by Slic3r::FanMover::_process_gcode_line(), extruding(), and retracting().

Here is the call graph for this function:

Here is the caller graph for this function:

dist_X()

float Slic3r::GCodeReader::GCodeLine::dist_X ( const GCodeReader & reader ) const

inline

{ return this->has(X) ? (this->x() - reader.x()) : 0; }

References GCodeReader, has(), Slic3r::X, x(), and Slic3r::GCodeReader::x().

Referenced by Slic3r::FanMover::_process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

dist_XY()

float Slic3r::GCodeReader::GCodeLine::dist_XY ( const GCodeReader & reader ) const

inline

                                                       {
            float x = this->has(X) ? (this->x() - reader.x()) : 0;
            float y = this->has(Y) ? (this->y() - reader.y()) : 0;
            return sqrt(x*x + y*y);
        }

References GCodeReader, has(), Slic3r::X, x(), Slic3r::GCodeReader::x(), Slic3r::Y, y(), and Slic3r::GCodeReader::y().

Referenced by Slic3r::SpiralVase::process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

dist_Y()

float Slic3r::GCodeReader::GCodeLine::dist_Y ( const GCodeReader & reader ) const

inline

{ return this->has(Y) ? (this->y() - reader.y()) : 0; }

References GCodeReader, has(), Slic3r::Y, y(), and Slic3r::GCodeReader::y().

Referenced by Slic3r::FanMover::_process_gcode_line().

Here is the call graph for this function:

Here is the caller graph for this function:

dist_Z()

float Slic3r::GCodeReader::GCodeLine::dist_Z ( const GCodeReader & reader ) const

inline

{ return this->has(Z) ? (this->z() - reader.z()) : 0; }

References GCodeReader, has(), Slic3r::Z, z(), and Slic3r::GCodeReader::z().

Referenced by Slic3r::FanMover::_process_gcode_line(), and Slic3r::SpiralVase::process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

e()

float Slic3r::GCodeReader::GCodeLine::e ( ) const

inline

{ return float(m_axis[E]); }

References Slic3r::E, and m_axis.

Referenced by Slic3r::FanMover::_process_gcode_line(), dist_E(), new_E(), Slic3r::GCodeProcessor::process_G1(), Slic3r::GCodeProcessor::process_G92(), Slic3r::SpiralVase::process_layer(), Slic3r::GCodeProcessor::process_M201(), Slic3r::GCodeProcessor::process_M203(), Slic3r::GCodeProcessor::process_M205(), and Slic3r::GCodeProcessor::process_M566().

Here is the caller graph for this function:

extract_cmd()

std::string Slic3r::GCodeReader::GCodeLine::extract_cmd ( const std::string & gcode_line )

inlinestatic

                                                                  {
            GCodeLine temp;
            temp.m_raw = gcode_line;
            const std::string_view cmd = temp.cmd();
            return { cmd.begin(), cmd.end() };
        }

References GCodeLine(), cmd(), and m_raw.

Referenced by Slic3r::ExportLines::insert_lines(), and Slic3r::GCodeProcessor::run_post_process().

Here is the call graph for this function:

Here is the caller graph for this function:

extruding()

bool Slic3r::GCodeReader::GCodeLine::extruding ( const GCodeReader & reader ) const

inline

{ return (this->cmd_is("G1") || this->cmd_is("G2") || this->cmd_is("G3")) && this->dist_E(reader) > 0; }

References cmd_is(), dist_E(), and GCodeReader.

Referenced by Slic3r::SpiralVase::process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

f()

float Slic3r::GCodeReader::GCodeLine::f ( ) const

inline

{ return float(m_axis[F]); }

References Slic3r::F, and m_axis.

Referenced by Slic3r::FanMover::_process_gcode_line(), new_F(), Slic3r::GCodeProcessor::process_G1(), Slic3r::GCodeProcessor::process_G2_G3(), and Slic3r::GCodeProcessor::process_VG1().

Here is the caller graph for this function:

has() [1/2]

bool Slic3r::GCodeReader::GCodeLine::has ( Axis axis ) const

inline

{ return (m_mask & (1 << int(axis))) != 0; }

References m_mask.

Referenced by Slic3r::FanMover::_process_gcode_line(), dist_E(), dist_X(), dist_XY(), dist_Y(), dist_Z(), Slic3r::GCodeProcessor::extract_absolute_position_on_axis(), has_e(), has_f(), has_i(), has_j(), has_p(), has_unknown_axis(), has_x(), has_y(), has_z(), new_E(), new_F(), new_X(), new_Y(), new_Z(), Slic3r::GCodeReader::parse_line_internal(), Slic3r::GCodeProcessor::process_G1(), Slic3r::GCodeProcessor::process_G2_G3(), Slic3r::SpiralVase::process_layer(), Slic3r::GCodeProcessor::process_M106(), Slic3r::GCodeProcessor::process_M132(), Slic3r::GCodeProcessor::process_M402(), Slic3r::GCodeProcessor::process_M702(), set(), travel(), Slic3r::GCodeReader::update_coordinates(), and Slic3r::GCodeProcessor::update_position_known_from_move().

Here is the caller graph for this function:

has() [2/2]

bool Slic3r::GCodeReader::GCodeLine::has

(

char

axis

)

const

{
    const char *c = m_raw.c_str();
    // Skip the whitespaces.
    c = skip_whitespaces(c);
    // Skip the command.
    c = skip_word(c);
    // Up to the end of line or comment.
    while (! is_end_of_gcode_line(*c)) {
        // Skip whitespaces.
        c = skip_whitespaces(c);
        if (is_end_of_gcode_line(*c))
            break;
        // Check the name of the axis.
        if (*c == axis)
            return true;
        // Skip the rest of the word.
        c = skip_word(c);
    }
    return false;
}

References Slic3r::GCodeReader::is_end_of_gcode_line(), m_raw, Slic3r::GCodeReader::skip_whitespaces(), and Slic3r::GCodeReader::skip_word().

Here is the call graph for this function:

has_e()

bool Slic3r::GCodeReader::GCodeLine::has_e ( ) const

inline

{ return this->has(E); }

References Slic3r::E, and has().

Referenced by Slic3r::GCodeProcessor::process_G1(), Slic3r::GCodeProcessor::process_G2_G3(), Slic3r::GCodeProcessor::process_G92(), Slic3r::GCodeProcessor::process_M201(), Slic3r::GCodeProcessor::process_M203(), Slic3r::GCodeProcessor::process_M205(), and Slic3r::GCodeProcessor::process_M566().

Here is the call graph for this function:

Here is the caller graph for this function:

has_f()

bool Slic3r::GCodeReader::GCodeLine::has_f ( ) const

inline

{ return this->has(F); }

References Slic3r::F, and has().

Referenced by Slic3r::FanMover::_process_gcode_line(), Slic3r::GCodeProcessor::process_G1(), Slic3r::GCodeProcessor::process_G2_G3(), and Slic3r::GCodeProcessor::process_VG1().

Here is the call graph for this function:

Here is the caller graph for this function:

has_i()

bool Slic3r::GCodeReader::GCodeLine::has_i ( ) const

inline

{ return this->has(I); }

References has(), and Slic3r::I.

Here is the call graph for this function:

has_j()

bool Slic3r::GCodeReader::GCodeLine::has_j ( ) const

inline

{ return this->has(J); }

References has(), and Slic3r::J.

Here is the call graph for this function:

has_p()

bool Slic3r::GCodeReader::GCodeLine::has_p ( ) const

inline

{ return this->has(P); }

References has(), and Slic3r::P.

Here is the call graph for this function:

has_unknown_axis()

bool Slic3r::GCodeReader::GCodeLine::has_unknown_axis ( ) const

inline

{ return this->has(UNKNOWN_AXIS); }

References has(), and Slic3r::UNKNOWN_AXIS.

Referenced by Slic3r::GCodeProcessor::process_G92().

Here is the call graph for this function:

Here is the caller graph for this function:

has_value() [1/2]

bool Slic3r::GCodeReader::GCodeLine::has_value	(	char	axis,
		float &	value ) const

{
    assert(is_decimal_separator_point());
    const char *c = m_raw.c_str();
    // Skip the whitespaces.
    c = skip_whitespaces(c);
    // Skip the command.
    c = skip_word(c);
    // Up to the end of line or comment.
    while (! is_end_of_gcode_line(*c)) {
        // Skip whitespaces.
        c = skip_whitespaces(c);
        if (is_end_of_gcode_line(*c))
            break;
        // Check the name of the axis.
        if (*c == axis) {
            // Try to parse the numeric value.
            char   *pend = nullptr;
            double  v = strtod(++ c, &pend);
            if (pend != nullptr && is_end_of_word(*pend)) {
                // The axis value has been parsed correctly.
                value = float(v);
                return true;
            }
        }
        // Skip the rest of the word.
        c = skip_word(c);
    }
    return false;
}

References Slic3r::is_decimal_separator_point(), Slic3r::GCodeReader::is_end_of_gcode_line(), Slic3r::GCodeReader::is_end_of_word(), m_raw, Slic3r::GCodeReader::skip_whitespaces(), Slic3r::GCodeReader::skip_word(), and value().

Referenced by Slic3r::anonymous_namespace{ElegooGCodeProcessorHelper.cpp}::get_clamped_param(), Slic3r::GCodeProcessor::process_elegoo_M6211(), Slic3r::GCodeProcessor::process_G2_G3(), Slic3r::GCodeProcessor::process_G4(), Slic3r::GCodeProcessor::process_M1020(), Slic3r::GCodeProcessor::process_M104(), Slic3r::GCodeProcessor::process_M106(), Slic3r::GCodeProcessor::process_M109(), Slic3r::GCodeProcessor::process_M140(), Slic3r::GCodeProcessor::process_M190(), Slic3r::GCodeProcessor::process_M191(), Slic3r::GCodeProcessor::process_M204(), Slic3r::GCodeProcessor::process_M205(), Slic3r::GCodeProcessor::process_M221(), Slic3r::GCodeProcessor::process_M400(), Slic3r::GCodeProcessor::process_M402(), Slic3r::GCodeProcessor::process_M572(), Slic3r::GCodeProcessor::process_M622(), Slic3r::GCodeProcessor::process_M900(), Slic3r::GCodeProcessor::process_SYNC(), Slic3r::GCodeProcessor::process_T(), and Slic3r::GCodeProcessor::run_post_process().

Here is the call graph for this function:

Here is the caller graph for this function:

has_value() [2/2]

bool Slic3r::GCodeReader::GCodeLine::has_value ( std::string_view axis_pos, float & value )

static

{
    if (const char *c = axis_pos.data(); c) {
        // Try to parse the numeric value.
        double v = 0.;
        const char *end = axis_pos.data() + axis_pos.size();
        auto [pend, ec] = fast_float::from_chars(++ c, end, v);
        if (pend != c && is_end_of_word(*pend)) {
            // The axis value has been parsed correctly.
            value = float(v);
            return true;
        }
    }
    return false;
}

References axis_pos(), Slic3r::GCodeReader::is_end_of_word(), and value().

Here is the call graph for this function:

has_x()

bool Slic3r::GCodeReader::GCodeLine::has_x ( ) const

inline

{ return this->has(X); }

References has(), and Slic3r::X.

Referenced by Slic3r::anonymous_namespace{GCode.cpp}::emitted_xy_after_gcode(), Slic3r::GCodeProcessor::process_G1(), Slic3r::GCodeProcessor::process_G92(), Slic3r::SpiralVase::process_layer(), Slic3r::GCodeProcessor::process_M201(), Slic3r::GCodeProcessor::process_M203(), Slic3r::GCodeProcessor::process_M205(), and Slic3r::GCodeProcessor::process_M566().

Here is the call graph for this function:

Here is the caller graph for this function:

has_y()

bool Slic3r::GCodeReader::GCodeLine::has_y ( ) const

inline

{ return this->has(Y); }

References has(), and Slic3r::Y.

Referenced by Slic3r::anonymous_namespace{GCode.cpp}::emitted_xy_after_gcode(), Slic3r::GCodeProcessor::process_G1(), Slic3r::GCodeProcessor::process_G92(), Slic3r::SpiralVase::process_layer(), Slic3r::GCodeProcessor::process_M201(), Slic3r::GCodeProcessor::process_M203(), Slic3r::GCodeProcessor::process_M205(), and Slic3r::GCodeProcessor::process_M566().

Here is the call graph for this function:

Here is the caller graph for this function:

has_z()

bool Slic3r::GCodeReader::GCodeLine::has_z ( ) const

inline

{ return this->has(Z); }

References has(), and Slic3r::Z.

Referenced by Slic3r::anonymous_namespace{GCode.cpp}::emitted_xy_after_gcode(), Slic3r::GCodeProcessor::process_G1(), Slic3r::GCodeProcessor::process_G92(), Slic3r::SpiralVase::process_layer(), Slic3r::GCodeProcessor::process_M201(), Slic3r::GCodeProcessor::process_M203(), Slic3r::GCodeProcessor::process_M205(), and Slic3r::GCodeProcessor::process_M566().

Here is the call graph for this function:

Here is the caller graph for this function:

i()

float Slic3r::GCodeReader::GCodeLine::i ( ) const

inline

{ return float(m_axis[I]); }

References Slic3r::I, and m_axis.

j()

float Slic3r::GCodeReader::GCodeLine::j ( ) const

inline

{ return float(m_axis[J]); }

References Slic3r::J, and m_axis.

new_E()

float Slic3r::GCodeReader::GCodeLine::new_E ( const GCodeReader & reader ) const

inline

{ return this->has(E) ? this->e() : reader.e(); }

References Slic3r::E, Slic3r::GCodeReader::e(), e(), GCodeReader, and has().

Here is the call graph for this function:

new_F()

float Slic3r::GCodeReader::GCodeLine::new_F ( const GCodeReader & reader ) const

inline

{ return this->has(F) ? this->f() : reader.f(); }

References Slic3r::F, Slic3r::GCodeReader::f(), f(), GCodeReader, and has().

Here is the call graph for this function:

new_X()

float Slic3r::GCodeReader::GCodeLine::new_X ( const GCodeReader & reader ) const

inline

{ return this->has(X) ? this->x() : reader.x(); }

References GCodeReader, has(), Slic3r::X, x(), and Slic3r::GCodeReader::x().

Here is the call graph for this function:

new_Y()

float Slic3r::GCodeReader::GCodeLine::new_Y ( const GCodeReader & reader ) const

inline

{ return this->has(Y) ? this->y() : reader.y(); }

References GCodeReader, has(), Slic3r::Y, y(), and Slic3r::GCodeReader::y().

Here is the call graph for this function:

new_Z()

float Slic3r::GCodeReader::GCodeLine::new_Z ( const GCodeReader & reader ) const

inline

{ return this->has(Z) ? this->z() : reader.z(); }

References GCodeReader, has(), Slic3r::Z, z(), and Slic3r::GCodeReader::z().

Referenced by Slic3r::SpiralVase::process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

p()

float Slic3r::GCodeReader::GCodeLine::p ( ) const

inline

{ return float(m_axis[P]); }

References m_axis, and Slic3r::P.

Referenced by Slic3r::GCodeProcessor::process_M106().

Here is the caller graph for this function:

precise_value()

double Slic3r::GCodeReader::GCodeLine::precise_value ( Axis axis ) const

inline

{ return m_axis[axis]; }

References m_axis.

Referenced by Slic3r::GCodeProcessor::extract_absolute_position_on_axis(), and Slic3r::GCodeProcessor::process_G1().

Here is the caller graph for this function:

raw()

const std::string & Slic3r::GCodeReader::GCodeLine::raw ( ) const

inline

{ return m_raw; }

References m_raw.

Referenced by Slic3r::FanMover::_process_gcode_line(), axis_pos(), Slic3r::GCodeProcessor::contains_reserved_tag(), Slic3r::GCodeProcessor::contains_reserved_tags(), Slic3r::custom_gcode_motion_state_changes(), Slic3r::g28_homed_axes(), Slic3r::GCodeProcessor::process_gcode_line(), Slic3r::SpiralVase::process_layer(), Slic3r::GCodeProcessor::process_M1020(), Slic3r::GCodeProcessor::process_M108(), Slic3r::GCodeProcessor::process_M135(), Slic3r::GCodeProcessor::process_SET_PRESSURE_ADVANCE(), Slic3r::GCodeProcessor::process_SET_VELOCITY_LIMIT(), and Slic3r::GCodeProcessor::run_post_process().

Here is the caller graph for this function:

reset()

void Slic3r::GCodeReader::GCodeLine::reset ( )

inline

{ m_mask = 0; memset(m_axis, 0, sizeof(m_axis)); m_raw.clear(); }

References m_axis, m_mask, and m_raw.

Referenced by GCodeLine(), Slic3r::GCodeReader::parse_buffer(), and Slic3r::GCodeReader::parse_file_internal().

Here is the caller graph for this function:

retracting()

bool Slic3r::GCodeReader::GCodeLine::retracting ( const GCodeReader & reader ) const

inline

{ return (this->cmd_is("G1") || this->cmd_is("G2") || this->cmd_is("G3")) && this->dist_E(reader) < 0; }

References cmd_is(), dist_E(), and GCodeReader.

Referenced by Slic3r::SpiralVase::process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

set()

void Slic3r::GCodeReader::GCodeLine::set	(	const Axis	axis,
		const float	new_value,
		const int	decimal_digits = 3 )

{
    std::ostringstream ss;
    ss << std::fixed << std::setprecision(decimal_digits) << new_value;
 
    char match[3] = " X";
    if (int(axis) < 3)
        match[1] += int(axis);
    else if (axis == F)
        match[1] = 'F';
    //BBS： handle I and J axis
    else if (axis == I)
        match[1] = 'I';
    else if (axis == J)
        match[1] = 'J';
    else {
        assert(axis == E);
        match[1] = 'E';
    }
 
    if (this->has(axis)) {
        size_t pos = m_raw.find(match)+2;
        size_t end = m_raw.find(' ', pos+1);
        m_raw = m_raw.replace(pos, end-pos, ss.str());
    } else {
        size_t pos = m_raw.find(' ');
        if (pos == std::string::npos)
            m_raw += std::string(match) + ss.str();
        else
            m_raw = m_raw.replace(pos, 0, std::string(match) + ss.str());
    }
    m_axis[axis] = new_value;
    m_mask |= 1 << int(axis);
}

References Slic3r::E, Slic3r::F, has(), Slic3r::I, Slic3r::J, m_axis, m_mask, and m_raw.

Referenced by Slic3r::GCodeProcessor::process_G10(), Slic3r::GCodeProcessor::process_G11(), and Slic3r::SpiralVase::process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

travel()

bool Slic3r::GCodeReader::GCodeLine::travel ( ) const

inline

{ return (this->cmd_is("G1") || this->cmd_is("G2") || this->cmd_is("G3")) && ! this->has(E); }

References cmd_is(), Slic3r::E, and has().

Here is the call graph for this function:

value()

float Slic3r::GCodeReader::GCodeLine::value ( Axis axis ) const

inline

{ return float(m_axis[axis]); }

References m_axis.

Referenced by has_value(), has_value(), and Slic3r::GCodeReader::update_coordinates().

Here is the caller graph for this function:

x()

float Slic3r::GCodeReader::GCodeLine::x ( ) const

inline

{ return float(m_axis[X]); }

References m_axis, and Slic3r::X.

Referenced by dist_X(), dist_XY(), Slic3r::anonymous_namespace{GCode.cpp}::emitted_xy_after_gcode(), new_X(), Slic3r::GCodeProcessor::process_G1(), Slic3r::GCodeProcessor::process_G92(), Slic3r::SpiralVase::process_layer(), Slic3r::GCodeProcessor::process_M201(), Slic3r::GCodeProcessor::process_M203(), Slic3r::GCodeProcessor::process_M205(), and Slic3r::GCodeProcessor::process_M566().

Here is the caller graph for this function:

y()

float Slic3r::GCodeReader::GCodeLine::y ( ) const

inline

{ return float(m_axis[Y]); }

References m_axis, and Slic3r::Y.

Referenced by dist_XY(), dist_Y(), Slic3r::anonymous_namespace{GCode.cpp}::emitted_xy_after_gcode(), new_Y(), Slic3r::GCodeProcessor::process_G1(), Slic3r::GCodeProcessor::process_G92(), Slic3r::SpiralVase::process_layer(), Slic3r::GCodeProcessor::process_M201(), Slic3r::GCodeProcessor::process_M203(), Slic3r::GCodeProcessor::process_M205(), and Slic3r::GCodeProcessor::process_M566().

Here is the caller graph for this function:

z()

float Slic3r::GCodeReader::GCodeLine::z ( ) const

inline

{ return float(m_axis[Z]); }

References m_axis, and Slic3r::Z.

Referenced by dist_Z(), new_Z(), Slic3r::GCodeProcessor::process_G1(), Slic3r::GCodeProcessor::process_G92(), Slic3r::GCodeProcessor::process_M201(), Slic3r::GCodeProcessor::process_M203(), Slic3r::GCodeProcessor::process_M205(), and Slic3r::GCodeProcessor::process_M566().

Here is the caller graph for this function:

Friends And Related Symbol Documentation

GCodeReader

friend class GCodeReader

friend

References GCodeReader.

Referenced by dist_E(), dist_X(), dist_XY(), dist_Y(), dist_Z(), extruding(), GCodeReader, new_E(), new_F(), new_X(), new_Y(), new_Z(), and retracting().

Member Data Documentation

m_axis

double Slic3r::GCodeReader::GCodeLine::m_axis[NUM_AXES]

private

Referenced by e(), f(), i(), j(), p(), Slic3r::GCodeReader::parse_line_internal(), precise_value(), reset(), set(), value(), x(), y(), and z().

m_mask

uint32_t Slic3r::GCodeReader::GCodeLine::m_mask

private

Referenced by has(), Slic3r::GCodeReader::parse_line_internal(), reset(), and set().

m_raw

std::string Slic3r::GCodeReader::GCodeLine::m_raw

private

Referenced by clear(), cmd(), cmd_is(), comment(), extract_cmd(), has(), has_value(), Slic3r::GCodeReader::parse_line_internal(), raw(), reset(), and set().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCodeReader.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCodeReader.cpp