Slic3r::GCodeFormatter Class Reference

#include <src/libslic3r/GCodeWriter.hpp>

Inheritance diagram for Slic3r::GCodeFormatter:

Collaboration diagram for Slic3r::GCodeFormatter:

Public Member Functions
	GCodeFormatter ()
	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 (const std::string &axis, double v)
void	emit_f (double speed)
void	emit_string (const std::string &s)
void	emit_comment (bool allow_comments, const std::string &comment)
std::string	string ()

Static Public Member Functions
static double	quantize (double v, size_t ndigits)
static double	quantize_xyzf (double v)
static double	quantize_e (double v)

Static Public Attributes
static constexpr const int	XYZF_EXPORT_DIGITS = 3
static constexpr const int	E_EXPORT_DIGITS = 5
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
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 ( )

inline

                     {
        this->buf_end = buf + buflen;
        this->ptr_err.ptr = this->buf;
    }

References buf, buf_end, buflen, and ptr_err.

GCodeFormatter() [2/2]

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

delete

Member Function Documentation

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_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 comment, emit_string(), and ptr_err.

Referenced by Slic3r::GCodeWriter::_retract(), Slic3r::GCodeWriter::_travel_to_z(), Slic3r::GCodeWriter::extrude_to_xy(), 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 ( const std::string &  axis, double  v  )

inline

                                                 {
        if (! axis.empty()) {
            // not gcfNoExtrusion
            this->emit_axis(axis[0], v, E_EXPORT_DIGITS);
        }
    }

References E_EXPORT_DIGITS, and emit_axis().

Referenced by Slic3r::GCodeWriter::_retract(), Slic3r::GCodeWriter::extrude_to_xy(), 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, XYZF_EXPORT_DIGITS);
    }

References emit_axis(), and XYZF_EXPORT_DIGITS.

Referenced by Slic3r::GCodeWriter::_retract(), 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_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 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(), XYZF_EXPORT_DIGITS);
        this->emit_axis('Y', point.y(), XYZF_EXPORT_DIGITS);
    }

References emit_axis(), and XYZF_EXPORT_DIGITS.

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

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(), XYZF_EXPORT_DIGITS);
        this->emit_axis('Y', point.y(), XYZF_EXPORT_DIGITS);
        this->emit_z(point.z());
    }

References emit_axis(), emit_z(), and XYZF_EXPORT_DIGITS.

Referenced by 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, XYZF_EXPORT_DIGITS);
    }

References emit_axis(), and XYZF_EXPORT_DIGITS.

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

quantize()

static 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_xyzf().

Here is the caller graph for this function:

quantize_e()

static double Slic3r::GCodeFormatter::quantize_e ( double  v )

inlinestatic

{ return quantize(v, E_EXPORT_DIGITS); }

References E_EXPORT_DIGITS, and quantize().

Referenced by Slic3r::Extruder::extrude(), Slic3r::Extruder::retract_to_go(), and Slic3r::Wipe::wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

quantize_xyzf()

static double Slic3r::GCodeFormatter::quantize_xyzf ( double  v )

inlinestatic

{ return quantize(v, XYZF_EXPORT_DIGITS); }

References quantize(), and XYZF_EXPORT_DIGITS.

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

                       {
        *ptr_err.ptr ++ = '\n';
        return std::string(this->buf, ptr_err.ptr - buf);
    }

References buf, and ptr_err.

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

Here is the caller graph for this function:

Member Data Documentation

buf

char Slic3r::GCodeFormatter::buf[buflen]

protected

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

buf_end

char* Slic3r::GCodeFormatter::buf_end

protected

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

buflen

constexpr const size_t Slic3r::GCodeFormatter::buflen = 256

staticconstexprprotected

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

E_EXPORT_DIGITS

constexpr const int Slic3r::GCodeFormatter::E_EXPORT_DIGITS = 5

staticconstexpr

Referenced by emit_e(), Slic3r::PressureEqualizer::push_line_to_output(), and quantize_e().

pow_10

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

staticconstexpr

Referenced by emit_axis(), and quantize().

pow_10_inv

constexpr 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

Referenced by quantize().

ptr_err

std::to_chars_result Slic3r::GCodeFormatter::ptr_err

protected

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

XYZF_EXPORT_DIGITS

constexpr const int Slic3r::GCodeFormatter::XYZF_EXPORT_DIGITS = 3

staticconstexpr

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

---

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

• src/libslic3r/GCodeWriter.hpp
• src/libslic3r/GCodeWriter.cpp