Slic3r::GCodeFormatter Class Reference

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

Inheritance diagram for Slic3r::GCodeFormatter:

Collaboration diagram for Slic3r::GCodeFormatter:

Public Member Functions
	GCodeFormatter (bool high_precision)
	GCodeFormatter (const GCodeFormatter &)=delete
GCodeFormatter &	operator= (const GCodeFormatter &)=delete
void	emit_axis (const char axis, const double v, size_t digits)
void	emit_xy (const Vec2d &point)
void	emit_xyz (const Vec3d &point)
void	emit_z (const double z)
void	emit_e (double v)
void	emit_f (double speed)
void	emit_ij (const Vec2d &point)
void	emit_string (const std::string &s)
void	emit_comment (bool allow_comments, const std::string &comment)
std::string	string ()
void	append_to (std::string &out)

Static Public Member Functions
static constexpr int	xyz_digits (bool high_precision)
static constexpr int	e_digits (bool high_precision)
static double	quantize (double v, size_t ndigits)
static double	quantize_xyz (double v, bool high_precision)
static double	quantize_e (double v, bool high_precision)

Static Public Attributes
static constexpr const int	F_EXPORT_DIGITS = 3
static constexpr const std::array< double, 10 >	pow_10 { 1., 10., 100., 1000., 10000., 100000., 1000000., 10000000., 100000000., 1000000000. }
static constexpr const std::array< double, 10 >	pow_10_inv { 1. / 1., 1. / 10., 1. / 100., 1. / 1000., 1. / 10000., 1. / 100000., 1. / 1000000., 1. / 10000000., 1. / 100000000., 1. / 1000000000. }

Protected Attributes
const bool	m_high_precision
char	buf [buflen]
char *	buf_end
std::to_chars_result	ptr_err

Static Protected Attributes
static constexpr const size_t	buflen = 256

Detailed Description

Constructor & Destructor Documentation

GCodeFormatter() [1/2]

Slic3r::GCodeFormatter::GCodeFormatter ( bool high_precision )

inlineexplicit

                                                 : m_high_precision(high_precision) {
        this->buf_end = buf + buflen;
        this->ptr_err.ptr = this->buf;
    }

References buf, buf_end, buflen, m_high_precision, and ptr_err.

Referenced by GCodeFormatter(), Slic3r::GCodeG1Formatter::GCodeG1Formatter(), Slic3r::GCodeG2G3Formatter::GCodeG2G3Formatter(), and operator=().

Here is the caller graph for this function:

GCodeFormatter() [2/2]

Slic3r::GCodeFormatter::GCodeFormatter ( const GCodeFormatter & )

delete

References GCodeFormatter().

Here is the call graph for this function:

Member Function Documentation

append_to()

void Slic3r::GCodeFormatter::append_to ( std::string & out )

inline

                                   {
        *ptr_err.ptr ++ = '\n';
        out.append(this->buf, ptr_err.ptr - buf);
    }

References buf, and ptr_err.

Referenced by Slic3r::GCodeWriter::extrude_arc_to_xy(), Slic3r::GCodeWriter::extrude_to_xy(), Slic3r::GCodeWriter::extrude_to_xyz(), Slic3r::GCodeWriter::set_speed(), and string().

Here is the caller graph for this function:

e_digits()

constexpr int Slic3r::GCodeFormatter::e_digits ( bool high_precision )

inlinestaticconstexpr

{ return high_precision ? 6 : 5; }

Referenced by Slic3r::FanMover::_print_in_middle_G1(), Slic3r::FanMover::_put_in_middle_G1(), emit_e(), Slic3r::SpiralVase::process_layer(), and quantize_e().

Here is the caller graph for this function:

emit_axis()

void Slic3r::GCodeFormatter::emit_axis	(	const char	axis,
		const double	v,
		size_t	digits )

                                                                             {
    assert(digits <= 9);
    static constexpr const std::array<int, 10> pow_10{1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};
    *ptr_err.ptr++ = ' '; *ptr_err.ptr++ = axis;
 
    char *base_ptr = this->ptr_err.ptr;
    auto  v_int    = int64_t(std::round(v * pow_10[digits]));
    // Older stdlib on macOS doesn't support std::from_chars at all, so it is used boost::spirit::karma::generate instead of it.
    // That is a little bit slower than std::to_chars but not much.
#ifdef __APPLE__
    boost::spirit::karma::generate(this->ptr_err.ptr, boost::spirit::karma::int_generator<int64_t>(), v_int);
#else
    // this->buf_end minus 1 because we need space for adding the extra decimal point.
    this->ptr_err = std::to_chars(this->ptr_err.ptr, this->buf_end - 1, v_int);
#endif
    size_t writen_digits = (this->ptr_err.ptr - base_ptr) - (v_int < 0 ? 1 : 0);
    if (writen_digits < digits) {
        // Number is smaller than 10^digits, so that we will pad it with zeros.
        size_t remaining_digits = digits - writen_digits;
        // Move all newly inserted chars by remaining_digits to allocate space for padding with zeros.
        for (char *from_ptr = this->ptr_err.ptr - 1, *to_ptr = from_ptr + remaining_digits; from_ptr >= this->ptr_err.ptr - writen_digits; --to_ptr, --from_ptr)
            *to_ptr = *from_ptr;
 
        memset(this->ptr_err.ptr - writen_digits, '0', remaining_digits);
        this->ptr_err.ptr += remaining_digits;
    }
 
    // Move all newly inserted chars by one to allocate space for a decimal point.
    for (char *to_ptr = this->ptr_err.ptr, *from_ptr = to_ptr - 1; from_ptr >= this->ptr_err.ptr - digits; --to_ptr, --from_ptr)
        *to_ptr = *from_ptr;
 
    *(this->ptr_err.ptr - digits) = '.';
    for (size_t i = 0; i < digits; ++i) {
        if (*this->ptr_err.ptr != '0')
            break;
        this->ptr_err.ptr--;
    }
    if (*this->ptr_err.ptr == '.')
        this->ptr_err.ptr--;
    if ((this->ptr_err.ptr + 1) == base_ptr || *this->ptr_err.ptr == '-')
        *(++this->ptr_err.ptr) = '0';
    this->ptr_err.ptr++;
 
#if 0 // #ifndef NDEBUG
    {
        // Verify that the optimized formatter produces the same result as the standard sprintf().
        double v1 = atof(std::string(base_ptr, this->ptr_err.ptr).c_str());
        char buf[2048];
        sprintf(buf, "%.*lf", int(digits), v);
        double v2 = atof(buf);
        // Numbers may differ when rounding at exactly or very close to 0.5 due to numerical issues when scaling the double to an integer.
        // Thus the complex assert.
//        assert(v1 == v2);
        assert(std::abs(v1 - v) * pow_10[digits] < 0.50001);
        assert(std::abs(v2 - v) * pow_10[digits] < 0.50001);
    }
#endif // NDEBUG
}

References buf, pow_10, and ptr_err.

Referenced by emit_e(), emit_f(), emit_ij(), emit_xy(), emit_xyz(), emit_z(), and Slic3r::PressureEqualizer::push_line_to_output().

Here is the caller graph for this function:

emit_comment()

void Slic3r::GCodeFormatter::emit_comment ( bool allow_comments, const std::string & comment )

inline

                                                                     {
        if (allow_comments && ! comment.empty()) {
            *ptr_err.ptr ++ = ' '; *ptr_err.ptr ++ = ';'; *ptr_err.ptr ++ = ' ';
            this->emit_string(comment);
        }
    }

References emit_string(), and ptr_err.

Referenced by Slic3r::GCodeWriter::_retract(), Slic3r::GCodeWriter::_spiral_travel_to_z(), Slic3r::GCodeWriter::_travel_to_z(), Slic3r::GCodeWriter::extrude_arc_to_xy(), Slic3r::GCodeWriter::extrude_to_xy(), Slic3r::GCodeWriter::extrude_to_xyz(), Slic3r::GCodeWriter::set_speed(), Slic3r::GCodeWriter::travel_to_xy(), Slic3r::GCodeWriter::travel_to_xyz(), and Slic3r::GCodeWriter::unretract().

Here is the call graph for this function:

Here is the caller graph for this function:

emit_e()

void Slic3r::GCodeFormatter::emit_e ( double v )

inline

                          {
        this->emit_axis('E', v, e_digits(m_high_precision));
    }

References e_digits(), emit_axis(), and m_high_precision.

Referenced by Slic3r::GCodeWriter::_retract(), Slic3r::GCodeWriter::extrude_arc_to_xy(), Slic3r::GCodeWriter::extrude_to_xy(), Slic3r::GCodeWriter::extrude_to_xyz(), Slic3r::PressureEqualizer::push_line_to_output(), and Slic3r::GCodeWriter::unretract().

Here is the call graph for this function:

Here is the caller graph for this function:

emit_f()

void Slic3r::GCodeFormatter::emit_f ( double speed )

inline

                              {
        this->emit_axis('F', speed, F_EXPORT_DIGITS);
    }

References emit_axis(), and F_EXPORT_DIGITS.

Referenced by Slic3r::GCodeWriter::_retract(), Slic3r::GCodeWriter::_spiral_travel_to_z(), Slic3r::GCodeWriter::_travel_to_z(), Slic3r::PressureEqualizer::push_line_to_output(), Slic3r::GCodeWriter::set_speed(), Slic3r::GCodeWriter::travel_to_xy(), Slic3r::GCodeWriter::travel_to_xyz(), and Slic3r::GCodeWriter::unretract().

Here is the call graph for this function:

Here is the caller graph for this function:

emit_ij()

void Slic3r::GCodeFormatter::emit_ij ( const Vec2d & point )

inline

                                     {
        this->emit_axis('I', point.x(), xyz_digits(m_high_precision));
        this->emit_axis('J', point.y(), xyz_digits(m_high_precision));
    }

References emit_axis(), m_high_precision, and xyz_digits().

Referenced by Slic3r::GCodeWriter::_spiral_travel_to_z(), and Slic3r::GCodeWriter::extrude_arc_to_xy().

Here is the call graph for this function:

Here is the caller graph for this function:

emit_string()

void Slic3r::GCodeFormatter::emit_string ( const std::string & s )

inline

                                         {
        strncpy(ptr_err.ptr, s.c_str(), s.size());
        ptr_err.ptr += s.size();
    }

References ptr_err.

Referenced by Slic3r::GCodeWriter::_spiral_travel_to_z(), emit_comment(), Slic3r::PressureEqualizer::push_line_to_output(), and Slic3r::GCodeWriter::set_speed().

Here is the caller graph for this function:

emit_xy()

void Slic3r::GCodeFormatter::emit_xy ( const Vec2d & point )

inline

                                     {
        this->emit_axis('X', point.x(), xyz_digits(m_high_precision));
        this->emit_axis('Y', point.y(), xyz_digits(m_high_precision));
    }

References emit_axis(), m_high_precision, and xyz_digits().

Referenced by Slic3r::GCodeWriter::extrude_arc_to_xy(), Slic3r::GCodeWriter::extrude_to_xy(), Slic3r::GCodeWriter::extrude_to_xyz(), Slic3r::GCodeWriter::travel_to_xy(), and Slic3r::GCodeWriter::travel_to_xyz().

Here is the call graph for this function:

Here is the caller graph for this function:

emit_xyz()

void Slic3r::GCodeFormatter::emit_xyz ( const Vec3d & point )

inline

                                      {
        this->emit_axis('X', point.x(), xyz_digits(m_high_precision));
        this->emit_axis('Y', point.y(), xyz_digits(m_high_precision));
        this->emit_z(point.z());
    }

References emit_axis(), emit_z(), m_high_precision, and xyz_digits().

Referenced by Slic3r::GCodeWriter::_spiral_travel_to_z(), Slic3r::GCodeWriter::_travel_to_z(), Slic3r::GCodeWriter::extrude_to_xy(), Slic3r::GCodeWriter::extrude_to_xyz(), Slic3r::GCodeWriter::travel_to_xy(), and Slic3r::GCodeWriter::travel_to_xyz().

Here is the call graph for this function:

Here is the caller graph for this function:

emit_z()

void Slic3r::GCodeFormatter::emit_z ( const double z )

inline

                                {
        this->emit_axis('Z', z, xyz_digits(m_high_precision));
    }

References emit_axis(), m_high_precision, and xyz_digits().

Referenced by Slic3r::GCodeWriter::_spiral_travel_to_z(), Slic3r::GCodeWriter::_travel_to_z(), and emit_xyz().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

GCodeFormatter & Slic3r::GCodeFormatter::operator= ( const GCodeFormatter & )

delete

References GCodeFormatter().

Here is the call graph for this function:

quantize()

double Slic3r::GCodeFormatter::quantize ( double v, size_t ndigits )

inlinestatic

{ return std::round(v * pow_10[ndigits]) * pow_10_inv[ndigits]; }

References pow_10, and pow_10_inv.

Referenced by quantize_e(), and quantize_xyz().

Here is the caller graph for this function:

quantize_e()

double Slic3r::GCodeFormatter::quantize_e ( double v, bool high_precision )

inlinestatic

{ return quantize(v, e_digits(high_precision)); }

References e_digits(), and quantize().

Referenced by Slic3r::Extruder::E_to_emit().

Here is the call graph for this function:

Here is the caller graph for this function:

quantize_xyz()

double Slic3r::GCodeFormatter::quantize_xyz ( double v, bool high_precision )

inlinestatic

{ return quantize(v, xyz_digits(high_precision)); }

References quantize(), and xyz_digits().

Referenced by Slic3r::GCode::_extrude(), Slic3r::GCodeWriter::extrude_to_xyz(), Slic3r::GCode::point_to_gcode_quantized(), and Slic3r::GCode::point_to_gcode_quantized().

Here is the call graph for this function:

Here is the caller graph for this function:

string()

std::string Slic3r::GCodeFormatter::string ( )

inline

                       {
        std::string out;
        this->append_to(out);
        return out;
    }

References append_to().

Referenced by Slic3r::GCodeWriter::_retract(), Slic3r::GCodeWriter::_spiral_travel_to_z(), Slic3r::GCodeWriter::_travel_to_z(), Slic3r::PressureEqualizer::push_to_output(), Slic3r::GCodeWriter::travel_to_xy(), Slic3r::GCodeWriter::travel_to_xyz(), and Slic3r::GCodeWriter::unretract().

Here is the call graph for this function:

Here is the caller graph for this function:

xyz_digits()

constexpr int Slic3r::GCodeFormatter::xyz_digits ( bool high_precision )

inlinestaticconstexpr

{ return high_precision ? 4 : 3; }

Referenced by Slic3r::FanMover::_print_in_middle_G1(), Slic3r::FanMover::_put_in_middle_G1(), emit_ij(), emit_xy(), emit_xyz(), emit_z(), Slic3r::SpiralVase::process_layer(), Slic3r::PressureEqualizer::push_line_to_output(), and quantize_xyz().

Here is the caller graph for this function:

Member Data Documentation

buf

char Slic3r::GCodeFormatter::buf[buflen]

protected

Referenced by GCodeFormatter(), Slic3r::GCodeG1Formatter::GCodeG1Formatter(), Slic3r::GCodeG2G3Formatter::GCodeG2G3Formatter(), append_to(), and emit_axis().

buf_end

char* Slic3r::GCodeFormatter::buf_end

protected

Referenced by GCodeFormatter(), Slic3r::GCodeG1Formatter::GCodeG1Formatter(), and Slic3r::GCodeG2G3Formatter::GCodeG2G3Formatter().

buflen

const size_t Slic3r::GCodeFormatter::buflen = 256

staticconstexprprotected

Referenced by GCodeFormatter(), Slic3r::GCodeG1Formatter::GCodeG1Formatter(), and Slic3r::GCodeG2G3Formatter::GCodeG2G3Formatter().

F_EXPORT_DIGITS

const int Slic3r::GCodeFormatter::F_EXPORT_DIGITS = 3

staticconstexpr

Referenced by emit_f().

m_high_precision

const bool Slic3r::GCodeFormatter::m_high_precision

protected

Referenced by GCodeFormatter(), emit_e(), emit_ij(), emit_xy(), emit_xyz(), and emit_z().

pow_10

const std::array<double, 10> Slic3r::GCodeFormatter::pow_10 { 1., 10., 100., 1000., 10000., 100000., 1000000., 10000000., 100000000., 1000000000. }

staticconstexpr

{ 1., 10., 100., 1000., 10000., 100000., 1000000., 10000000., 100000000., 1000000000. };

Referenced by emit_axis(), and quantize().

pow_10_inv

const std::array<double, 10> Slic3r::GCodeFormatter::pow_10_inv { 1. / 1., 1. / 10., 1. / 100., 1. / 1000., 1. / 10000., 1. / 100000., 1. / 1000000., 1. / 10000000., 1. / 100000000., 1. / 1000000000. }

staticconstexpr

{ 1. / 1., 1. / 10., 1. / 100., 1. / 1000., 1. / 10000., 1. / 100000., 1. / 1000000., 1. / 10000000., 1. / 100000000., 1. / 1000000000. };

Referenced by quantize().

ptr_err

std::to_chars_result Slic3r::GCodeFormatter::ptr_err

protected

Referenced by GCodeFormatter(), Slic3r::GCodeG1Formatter::GCodeG1Formatter(), Slic3r::GCodeG2G3Formatter::GCodeG2G3Formatter(), append_to(), emit_axis(), emit_comment(), and emit_string().

---

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

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