Slic3r::GCodeG1Formatter Class Reference

#include <src/libslic3r/GCodeWriter.hpp>

Inheritance diagram for Slic3r::GCodeG1Formatter:

Collaboration diagram for Slic3r::GCodeG1Formatter:

Public Member Functions
	GCodeG1Formatter ()
	GCodeG1Formatter (const GCodeG1Formatter &)=delete
GCodeG1Formatter &	operator= (const GCodeG1Formatter &)=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

GCodeG1Formatter() [1/2]

Slic3r::GCodeG1Formatter::GCodeG1Formatter ( )

inline

                       {
        this->buf[0] = 'G';
        this->buf[1] = '1';
        this->buf_end = buf + buflen;
        this->ptr_err.ptr = this->buf + 2;
    }

References Slic3r::GCodeFormatter::buf, Slic3r::GCodeFormatter::buf_end, Slic3r::GCodeFormatter::buflen, and Slic3r::GCodeFormatter::ptr_err.

GCodeG1Formatter() [2/2]

Slic3r::GCodeG1Formatter::GCodeG1Formatter ( const GCodeG1Formatter &  )

delete

Member Function Documentation

emit_axis()

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

inherited

                                                                             {
    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 Slic3r::GCodeFormatter::buf, Slic3r::GCodeFormatter::pow_10, and Slic3r::GCodeFormatter::ptr_err.

Referenced by Slic3r::GCodeFormatter::emit_e(), Slic3r::GCodeFormatter::emit_f(), Slic3r::GCodeFormatter::emit_xy(), Slic3r::GCodeFormatter::emit_xyz(), Slic3r::GCodeFormatter::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  )

inlineinherited

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

References comment, Slic3r::GCodeFormatter::emit_string(), and Slic3r::GCodeFormatter::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  )

inlineinherited

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

References Slic3r::GCodeFormatter::E_EXPORT_DIGITS, and Slic3r::GCodeFormatter::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 )

inlineinherited

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

References Slic3r::GCodeFormatter::emit_axis(), and Slic3r::GCodeFormatter::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 )

inlineinherited

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

References Slic3r::GCodeFormatter::ptr_err.

Referenced by Slic3r::GCodeFormatter::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 )

inlineinherited

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

References Slic3r::GCodeFormatter::emit_axis(), and Slic3r::GCodeFormatter::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 )

inlineinherited

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

References Slic3r::GCodeFormatter::emit_axis(), Slic3r::GCodeFormatter::emit_z(), and Slic3r::GCodeFormatter::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 )

inlineinherited

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

References Slic3r::GCodeFormatter::emit_axis(), and Slic3r::GCodeFormatter::XYZF_EXPORT_DIGITS.

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

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

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

delete

quantize()

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

inlinestaticinherited

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

References Slic3r::GCodeFormatter::pow_10, and Slic3r::GCodeFormatter::pow_10_inv.

Referenced by Slic3r::GCodeFormatter::quantize_e(), and Slic3r::GCodeFormatter::quantize_xyzf().

Here is the caller graph for this function:

quantize_e()

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

inlinestaticinherited

{ return quantize(v, E_EXPORT_DIGITS); }

References Slic3r::GCodeFormatter::E_EXPORT_DIGITS, and Slic3r::GCodeFormatter::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 )

inlinestaticinherited

{ return quantize(v, XYZF_EXPORT_DIGITS); }

References Slic3r::GCodeFormatter::quantize(), and Slic3r::GCodeFormatter::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 ( )

inlineinherited

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

References Slic3r::GCodeFormatter::buf, and Slic3r::GCodeFormatter::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]

protectedinherited

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

buf_end

char* Slic3r::GCodeFormatter::buf_end

protectedinherited

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

buflen

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

staticconstexprprotectedinherited

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

E_EXPORT_DIGITS

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

staticconstexprinherited

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

pow_10

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

staticconstexprinherited

Referenced by Slic3r::GCodeFormatter::emit_axis(), and Slic3r::GCodeFormatter::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.}

staticconstexprinherited

Referenced by Slic3r::GCodeFormatter::quantize().

ptr_err

std::to_chars_result Slic3r::GCodeFormatter::ptr_err

protectedinherited

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

XYZF_EXPORT_DIGITS

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

staticconstexprinherited

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

---

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

• src/libslic3r/GCodeWriter.hpp