Slic3r::CalibPressureAdvance Class Reference

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

Inheritance diagram for Slic3r::CalibPressureAdvance:

Collaboration diagram for Slic3r::CalibPressureAdvance:

Static Public Member Functions
static float	find_optimal_PA_speed (const DynamicPrintConfig &config, double line_width, double layer_height, int extruder_id=0, int filament_idx=0)

Protected Types
enum class	DrawDigitMode { Left_To_Right , Bottom_To_Top }

Protected Member Functions
	CalibPressureAdvance ()=default
	CalibPressureAdvance (const DynamicPrintConfig &config)
	CalibPressureAdvance (const FullPrintConfig &config)
	~CalibPressureAdvance ()=default
void	delta_scale_bed_ext (BoundingBoxf &bed_ext) const
std::string	move_to (Vec2d pt, GCodeWriter &writer, std::string comment=std::string(), double z=0, double layer_height=-1)
double	e_per_mm (double line_width, double layer_height, float nozzle_diameter, float filament_diameter, float print_flow_ratio) const
double	speed_adjust (int speed) const
std::string	convert_number_to_string (double num, unsigned precision=0) const
double	number_spacing () const
std::string	draw_digit (double startx, double starty, char c, CalibPressureAdvance::DrawDigitMode mode, double line_width, double e_per_mm, GCodeWriter &writer)
std::string	draw_number (double startx, double starty, double value, CalibPressureAdvance::DrawDigitMode mode, double line_width, double e_per_mm, double speed, GCodeWriter &writer)
std::string	draw_line (GCodeWriter &writer, Vec2d to_pt, double line_width, double layer_height, double speed, const std::string &comment=std::string())
std::string	draw_box (GCodeWriter &writer, double min_x, double min_y, double size_x, double size_y, DrawBoxOptArgs opt_args)
double	to_radians (double degrees) const
double	get_distance (Vec2d from, Vec2d to) const

Protected Attributes
Vec3d	m_last_pos
DynamicPrintConfig	m_config
const double	m_encroachment {1. / 3.}
DrawDigitMode	m_draw_digit_mode {DrawDigitMode::Left_To_Right}
const double	m_digit_segment_len {2}
const double	m_digit_gap_len {1}
const std::string::size_type	m_max_number_len {5}
std::string::size_type	m_number_len {m_max_number_len}

Detailed Description

Member Enumeration Documentation

DrawDigitMode

enum class Slic3r::CalibPressureAdvance::DrawDigitMode

strongprotected

Enumerator
Left_To_Right
Bottom_To_Top

{ Left_To_Right, Bottom_To_Top };

Constructor & Destructor Documentation

CalibPressureAdvance() [1/3]

Slic3r::CalibPressureAdvance::CalibPressureAdvance ( )

protecteddefault

Referenced by Slic3r::CalibPressureAdvanceLine::CalibPressureAdvanceLine(), and Slic3r::CalibPressureAdvancePattern::CalibPressureAdvancePattern().

Here is the caller graph for this function:

CalibPressureAdvance() [2/3]

Slic3r::CalibPressureAdvance::CalibPressureAdvance ( const DynamicPrintConfig & config )

inlineprotected

: m_config(config){};

References m_config.

CalibPressureAdvance() [3/3]

Slic3r::CalibPressureAdvance::CalibPressureAdvance ( const FullPrintConfig & config )

inlineprotected

{ m_config.apply(config); };

References m_config.

~CalibPressureAdvance()

Slic3r::CalibPressureAdvance::~CalibPressureAdvance ( )

protecteddefault

Member Function Documentation

convert_number_to_string()

std::string Slic3r::CalibPressureAdvance::convert_number_to_string ( double num, unsigned precision = 0 ) const

protected

{
    std::ostringstream stream;
 
    if (precision) {
        /* if number is > 1000 then there are no way we'll fit fractional part into 5 glyphs, so
         * in this case we keep full precision.
         * Otherwise we reduce precision by 1 to accomodate decimal separator */
        stream << std::setprecision(num >= 1000 ? precision : precision - 1);
    }
 
    stream << num;
 
    return stream.str();
}

Referenced by draw_number(), and Slic3r::CalibPressureAdvancePattern::max_numbering_length().

Here is the caller graph for this function:

delta_scale_bed_ext()

void Slic3r::CalibPressureAdvance::delta_scale_bed_ext ( BoundingBoxf & bed_ext ) const

inlineprotected

{ bed_ext.scale(1.0f / 1.41421f); }

References Slic3r::BoundingBoxBase< PointType, APointsType >::scale().

Referenced by Slic3r::CalibPressureAdvanceLine::generate_test(), and Slic3r::CalibPressureAdvanceLine::print_extents().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_box()

std::string Slic3r::CalibPressureAdvance::draw_box ( GCodeWriter & writer, double min_x, double min_y, double size_x, double size_y, DrawBoxOptArgs opt_args )

protected

{
    std::stringstream gcode;
 
    double       x     = min_x;
    double       y     = min_y;
    const double max_x = min_x + size_x;
    const double max_y = min_y + size_y;
 
    const double spacing = opt_args.line_width - opt_args.height * (1 - M_PI / 4);
 
    // if number of perims exceeds size of box, reduce it to max
    const int max_perimeters = std::min(
        // this is the equivalent of number of perims for concentric fill
        std::floor(size_x * std::sin(to_radians(45))) / (spacing / std::sin(to_radians(45))),
        std::floor(size_y * std::sin(to_radians(45))) / (spacing / std::sin(to_radians(45))));
 
    opt_args.num_perimeters = std::min(opt_args.num_perimeters, max_perimeters);
 
    gcode << move_to(Vec2d(min_x, min_y), writer, "Move to box start");
 
    // DrawLineOptArgs line_opt_args(*this);
    auto line_arg_height     = opt_args.height;
    auto line_arg_line_width = opt_args.line_width;
    auto line_arg_speed      = opt_args.speed;
    std::string comment = "";
 
    for (int i = 0; i < opt_args.num_perimeters; ++i) {
        if (i != 0) { // after first perimeter, step inwards to start next perimeter
            x += spacing;
            y += spacing;
            gcode << move_to(Vec2d(x, y), writer, "Step inwards to print next perimeter");
        }
 
        y += size_y - i * spacing * 2;
        comment = "Draw perimeter (up)";
        gcode << draw_line(writer, Vec2d(x, y), line_arg_line_width, line_arg_height, line_arg_speed, comment);
 
        x += size_x - i * spacing * 2;
        comment = "Draw perimeter (right)";
        gcode << draw_line(writer, Vec2d(x, y), line_arg_line_width, line_arg_height, line_arg_speed, comment);
 
        y -= size_y - i * spacing * 2;
        comment = "Draw perimeter (down)";
        gcode << draw_line(writer, Vec2d(x, y), line_arg_line_width, line_arg_height, line_arg_speed, comment);
 
        x -= size_x - i * spacing * 2;
        comment = "Draw perimeter (left)";
        gcode << draw_line(writer, Vec2d(x, y), line_arg_line_width, line_arg_height, line_arg_speed, comment);
    }
 
    if (!opt_args.is_filled) {
        return gcode.str();
    }
 
    // create box infill
    const double spacing_45 = spacing / std::sin(to_radians(45));
 
    const double bound_modifier = (spacing * (opt_args.num_perimeters - 1)) + (opt_args.line_width * (1 - m_encroachment));
    const double x_min_bound    = min_x + bound_modifier;
    const double x_max_bound    = max_x - bound_modifier;
    const double y_min_bound    = min_y + bound_modifier;
    const double y_max_bound    = max_y - bound_modifier;
    const int    x_count        = std::floor((x_max_bound - x_min_bound) / spacing_45);
    const int    y_count        = std::floor((y_max_bound - y_min_bound) / spacing_45);
 
    double x_remainder = std::fmod((x_max_bound - x_min_bound), spacing_45);
    double y_remainder = std::fmod((y_max_bound - y_min_bound), spacing_45);
 
    x = x_min_bound;
    y = y_min_bound;
 
    gcode << move_to(Vec2d(x, y), writer, "Move to fill start");
 
    for (int i = 0; i < x_count + y_count + (x_remainder + y_remainder >= spacing_45 ? 1 : 0);
         ++i) { // this isn't the most robust way, but less expensive than finding line intersections
        if (i < std::min(x_count, y_count)) {
            if (i % 2 == 0) {
                x += spacing_45;
                y = y_min_bound;
                gcode << move_to(Vec2d(x, y), writer, "Fill: Step right");
 
                y += x - x_min_bound;
                x                     = x_min_bound;
                comment = "Fill: Print up/left";
                gcode << draw_line(writer, Vec2d(x, y), line_arg_line_width, line_arg_height, line_arg_speed, comment);
            } else {
                y += spacing_45;
                x = x_min_bound;
                gcode << move_to(Vec2d(x, y), writer, "Fill: Step up");
 
                x += y - y_min_bound;
                y                     = y_min_bound;
                comment = "Fill: Print down/right";
                gcode << draw_line(writer, Vec2d(x, y), line_arg_line_width, line_arg_height, line_arg_speed, comment);
            }
        } else if (i < std::max(x_count, y_count)) {
            if (x_count > y_count) {
                // box is wider than tall
                if (i % 2 == 0) {
                    x += spacing_45;
                    y = y_min_bound;
                    gcode << move_to(Vec2d(x, y), writer, "Fill: Step right");
 
                    x -= y_max_bound - y_min_bound;
                    y                     = y_max_bound;
                    comment = "Fill: Print up/left";
                    gcode << draw_line(writer, Vec2d(x, y), line_arg_line_width, line_arg_height, line_arg_speed, comment);
                } else {
                    if (i == y_count) {
                        x += spacing_45 - y_remainder;
                        y_remainder = 0;
                    } else {
                        x += spacing_45;
                    }
                    y = y_max_bound;
                    gcode << move_to(Vec2d(x, y), writer, "Fill: Step right");
 
                    x += y_max_bound - y_min_bound;
                    y                     = y_min_bound;
                    comment = "Fill: Print down/right";
                    gcode << draw_line(writer, Vec2d(x, y), line_arg_line_width, line_arg_height, line_arg_speed, comment);
                }
            } else {
                // box is taller than wide
                if (i % 2 == 0) {
                    x = x_max_bound;
                    if (i == x_count) {
                        y += spacing_45 - x_remainder;
                        x_remainder = 0;
                    } else {
                        y += spacing_45;
                    }
                    gcode << move_to(Vec2d(x, y), writer, "Fill: Step up");
 
                    x = x_min_bound;
                    y += x_max_bound - x_min_bound;
                    comment = "Fill: Print up/left";
                    gcode << draw_line(writer, Vec2d(x, y), line_arg_line_width, line_arg_height, line_arg_speed, comment);
                } else {
                    x = x_min_bound;
                    y += spacing_45;
                    gcode << move_to(Vec2d(x, y), writer, "Fill: Step up");
 
                    x = x_max_bound;
                    y -= x_max_bound - x_min_bound;
                    comment = "Fill: Print down/right";
                    gcode << draw_line(writer, Vec2d(x, y), line_arg_line_width, line_arg_height, line_arg_speed, comment);
                }
            }
        } else {
            if (i % 2 == 0) {
                x = x_max_bound;
                if (i == x_count) {
                    y += spacing_45 - x_remainder;
                } else {
                    y += spacing_45;
                }
                gcode << move_to(Vec2d(x, y), writer, "Fill: Step up");
 
                x -= y_max_bound - y;
                y                     = y_max_bound;
                comment = "Fill: Print up/left";
                gcode << draw_line(writer, Vec2d(x, y), line_arg_line_width, line_arg_height, line_arg_speed, comment);
            } else {
                if (i == y_count) {
                    x += spacing_45 - y_remainder;
                } else {
                    x += spacing_45;
                }
                y = y_max_bound;
                gcode << move_to(Vec2d(x, y), writer, "Fill: Step right");
 
                y -= x_max_bound - x;
                x                     = x_max_bound;
                comment = "Fill: Print down/right";
                gcode << draw_line(writer, Vec2d(x, y), line_arg_line_width, line_arg_height, line_arg_speed, comment);
            }
        }
    }
 
    return gcode.str();
}

References draw_line(), Slic3r::DrawBoxOptArgs::height, Slic3r::DrawBoxOptArgs::is_filled, Slic3r::DrawBoxOptArgs::line_width, m_encroachment, M_PI, move_to(), Slic3r::DrawBoxOptArgs::num_perimeters, Slic3r::DrawBoxOptArgs::speed, and to_radians().

Referenced by Slic3r::CalibPressureAdvancePattern::generate_custom_gcodes(), and Slic3r::CalibPressureAdvanceLine::print_pa_lines().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_digit()

std::string Slic3r::CalibPressureAdvance::draw_digit ( double startx, double starty, char c, CalibPressureAdvance::DrawDigitMode mode, double line_width, double e_per_mm, GCodeWriter & writer )

protected

{
    const double len = m_digit_segment_len;
    const double gap = line_width / 2.0;
 
    const auto dE     = e_per_mm * len;
    const auto two_dE = dE * 2;
 
    Vec2d p0, p1, p2, p3, p4, p5;
    Vec2d p0_5, p4_5;
    Vec2d gap_p0_toward_p3, gap_p2_toward_p3;
    Vec2d dot_direction;
 
    if (mode == CalibPressureAdvance::DrawDigitMode::Bottom_To_Top) {
        //  1-------2-------5
        //  |       |       |
        //  |       |       |
        //  0-------3-------4
        p0   = Vec2d(startx, starty);
        p0_5 = Vec2d(startx, starty + len / 2);
        p1   = Vec2d(startx, starty + len);
        p2   = Vec2d(startx + len, starty + len);
        p3   = Vec2d(startx + len, starty);
        p4   = Vec2d(startx + len * 2, starty);
        p4_5 = Vec2d(startx + len * 2, starty + len / 2);
        p5   = Vec2d(startx + len * 2, starty + len);
 
        gap_p0_toward_p3 = p0 + Vec2d(gap, 0);
        gap_p2_toward_p3 = p2 + Vec2d(0, gap);
 
        dot_direction = Vec2d(-len / 2, 0);
    } else {
        //  0-------1
        //  |       |
        //  3-------2
        //  |       |
        //  4-------5
        p0   = Vec2d(startx, starty);
        p0_5 = Vec2d(startx + len / 2, starty);
        p1   = Vec2d(startx + len, starty);
        p2   = Vec2d(startx + len, starty - len);
        p3   = Vec2d(startx, starty - len);
        p4   = Vec2d(startx, starty - len * 2);
        p4_5 = Vec2d(startx + len / 2, starty - len * 2);
        p5   = Vec2d(startx + len, starty - len * 2);
 
        gap_p0_toward_p3 = p0 - Vec2d(0, gap);
        gap_p2_toward_p3 = p2 - Vec2d(gap, 0);
 
        dot_direction = Vec2d(0, len / 2);
    }
 
    std::stringstream gcode;
 
    switch (c) {
    case '0':
        gcode << move_to(p0, writer, "Glyph: 0");
        gcode << writer.extrude_to_xy(p1, dE);
        gcode << writer.extrude_to_xy(p5, two_dE);
        gcode << writer.extrude_to_xy(p4, dE);
        gcode << writer.extrude_to_xy(gap_p0_toward_p3, two_dE);
        break;
    case '1':
        gcode << move_to(p0_5, writer, "Glyph: 1");
        gcode << writer.extrude_to_xy(p4_5, two_dE);
        break;
    case '2':
        gcode << move_to(p0, writer, "Glyph: 2");
        gcode << writer.extrude_to_xy(p1, dE);
        gcode << writer.extrude_to_xy(p2, dE);
        gcode << writer.extrude_to_xy(p3, dE);
        gcode << writer.extrude_to_xy(p4, dE);
        gcode << writer.extrude_to_xy(p5, dE);
        break;
    case '3':
        gcode << move_to(p0, writer, "Glyph: 3");
        gcode << writer.extrude_to_xy(p1, dE);
        gcode << writer.extrude_to_xy(p5, two_dE);
        gcode << writer.extrude_to_xy(p4, dE);
        gcode << move_to(gap_p2_toward_p3, writer);
        gcode << writer.extrude_to_xy(p3, dE);
        break;
    case '4':
        gcode << move_to(p0, writer, "Glyph: 4");
        gcode << writer.extrude_to_xy(p3, dE);
        gcode << writer.extrude_to_xy(p2, dE);
        gcode << move_to(p1, writer);
        gcode << writer.extrude_to_xy(p5, two_dE);
        break;
    case '5':
        gcode << move_to(p1, writer, "Glyph: 5");
        gcode << writer.extrude_to_xy(p0, dE);
        gcode << writer.extrude_to_xy(p3, dE);
        gcode << writer.extrude_to_xy(p2, dE);
        gcode << writer.extrude_to_xy(p5, dE);
        gcode << writer.extrude_to_xy(p4, dE);
        break;
    case '6':
        gcode << move_to(p1, writer, "Glyph: 6");
        gcode << writer.extrude_to_xy(p0, dE);
        gcode << writer.extrude_to_xy(p4, two_dE);
        gcode << writer.extrude_to_xy(p5, dE);
        gcode << writer.extrude_to_xy(p2, dE);
        gcode << writer.extrude_to_xy(p3, dE);
        break;
    case '7':
        gcode << move_to(p0, writer, "Glyph: 7");
        gcode << writer.extrude_to_xy(p1, dE);
        gcode << writer.extrude_to_xy(p5, two_dE);
        break;
    case '8':
        gcode << move_to(p2, writer, "Glyph: 8");
        gcode << writer.extrude_to_xy(p3, dE);
        gcode << writer.extrude_to_xy(p4, dE);
        gcode << writer.extrude_to_xy(p5, dE);
        gcode << writer.extrude_to_xy(p1, two_dE);
        gcode << writer.extrude_to_xy(p0, dE);
        gcode << writer.extrude_to_xy(p3, dE);
        break;
    case '9':
        gcode << move_to(p5, writer, "Glyph: 9");
        gcode << writer.extrude_to_xy(p1, two_dE);
        gcode << writer.extrude_to_xy(p0, dE);
        gcode << writer.extrude_to_xy(p3, dE);
        gcode << writer.extrude_to_xy(p2, dE);
        break;
    case '.':
        gcode << move_to(p4_5, writer, "Glyph: .");
        gcode << writer.extrude_to_xy(p4_5 + dot_direction, dE);
        break;
    default: break;
    }
 
    return gcode.str();
}

References Bottom_To_Top, e_per_mm(), Slic3r::GCodeWriter::extrude_to_xy(), m_digit_segment_len, and move_to().

Referenced by draw_number().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_line()

std::string Slic3r::CalibPressureAdvance::draw_line ( GCodeWriter & writer, Vec2d to_pt, double line_width, double layer_height, double speed, const std::string & comment = std::string() )

protected

{
    const double e_per_mm = CalibPressureAdvance::e_per_mm(line_width, layer_height,
                                                           m_config.option<ConfigOptionFloats>("nozzle_diameter")->get_at(0),
                                                           m_config.option<ConfigOptionFloats>("filament_diameter")->get_at(0),
                                                           m_config.option<ConfigOptionFloatsNullable>("filament_flow_ratio")->get_at(0));
 
    const double length = get_distance(Vec2d(m_last_pos.x(), m_last_pos.y()), to_pt);
    auto         dE     = e_per_mm * length;
 
    std::stringstream gcode;
 
    gcode << writer.set_speed(speed);
    gcode << writer.extrude_to_xy(to_pt, dE, comment);
 
    m_last_pos = Vec3d(to_pt.x(), to_pt.y(), 0);
 
    return gcode.str();
}

References e_per_mm(), Slic3r::GCodeWriter::extrude_to_xy(), get_distance(), Slic3r::layer_height(), Slic3r::length(), m_config, m_last_pos, and Slic3r::GCodeWriter::set_speed().

Referenced by draw_box(), and Slic3r::CalibPressureAdvancePattern::generate_custom_gcodes().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_number()

std::string Slic3r::CalibPressureAdvance::draw_number ( double startx, double starty, double value, CalibPressureAdvance::DrawDigitMode mode, double line_width, double e_per_mm, double speed, GCodeWriter & writer )

protected

{
    auto              sNumber = convert_number_to_string(value, m_number_len);
    std::stringstream gcode;
    gcode << writer.set_speed(speed);
 
    for (std::string::size_type i = 0; i < sNumber.length(); ++i) {
        if (i >= m_number_len) {
            break;
        }
        switch (mode) {
        case DrawDigitMode::Bottom_To_Top:
            gcode << draw_digit(startx, starty + i * number_spacing(), sNumber[i], mode, line_width, e_per_mm, writer);
            break;
        default: gcode << draw_digit(startx + i * number_spacing(), starty, sNumber[i], mode, line_width, e_per_mm, writer);
        }
    }
 
    return gcode.str();
}

References Bottom_To_Top, convert_number_to_string(), draw_digit(), e_per_mm(), m_number_len, number_spacing(), and Slic3r::GCodeWriter::set_speed().

Referenced by Slic3r::CalibPressureAdvancePattern::generate_custom_gcodes(), and Slic3r::CalibPressureAdvanceLine::print_pa_lines().

Here is the call graph for this function:

Here is the caller graph for this function:

e_per_mm()

double Slic3r::CalibPressureAdvance::e_per_mm ( double line_width, double layer_height, float nozzle_diameter, float filament_diameter, float print_flow_ratio ) const

protected

{
    const Flow   line_flow     = Flow(line_width, layer_height, nozzle_diameter);
    const double filament_area = M_PI * std::pow(filament_diameter / 2, 2);
 
    return line_flow.mm3_per_mm() * print_flow_ratio / filament_area ;
}

References Slic3r::layer_height(), M_PI, Slic3r::Flow::mm3_per_mm(), Slic3r::nozzle_diameter(), and Slic3r::print_flow_ratio().

Referenced by draw_digit(), draw_line(), draw_number(), Slic3r::CalibPressureAdvancePattern::generate_custom_gcodes(), and Slic3r::CalibPressureAdvanceLine::print_pa_lines().

Here is the call graph for this function:

Here is the caller graph for this function:

find_optimal_PA_speed()

float Slic3r::CalibPressureAdvance::find_optimal_PA_speed ( const DynamicPrintConfig & config, double line_width, double layer_height, int extruder_id = 0, int filament_idx = 0 )

static

{
    const double general_suggested_min_speed   = 100.0;
    // Read defensively — CLI callers may hand us a config missing optional keys.
    auto vector_at = [&config](const char *key, int idx) -> double {
        if (const auto *o = config.option<ConfigOptionFloats>(key)) return o->get_at(idx);
        const ConfigOptionDef *d = config.def() ? config.def()->get(key) : nullptr;
        return (d && d->default_value) ? d->get_default_value<ConfigOptionFloats>()->get_at(idx) : 0.0;
    };
    auto nullable_at = [&config](const char *key, int idx) -> double {
        if (const auto *o = config.option<ConfigOptionFloatsNullable>(key)) return o->get_at(idx);
        const ConfigOptionDef *d = config.def() ? config.def()->get(key) : nullptr;
        return (d && d->default_value) ? d->get_default_value<ConfigOptionFloatsNullable>()->get_at(idx) : 0.0;
    };
    double       filament_max_volumetric_speed = vector_at("filament_max_volumetric_speed", filament_idx);
    // todo multi_extruders:
    const float  nozzle_diameter               = vector_at("nozzle_diameter", extruder_id);
    if (line_width <= 0.) line_width = Flow::auto_extrusion_width(frPerimeter, nozzle_diameter);
    Flow         pattern_line = Flow(line_width, layer_height, nozzle_diameter);
    auto         pa_speed     = std::min(std::max(general_suggested_min_speed, nullable_at("outer_wall_speed", extruder_id)),
                                         filament_max_volumetric_speed / pattern_line.mm3_per_mm());
 
    return std::floor(pa_speed);
}

References Slic3r::Flow::auto_extrusion_width(), Slic3r::DynamicPrintConfig::def(), Slic3r::ConfigOptionDef::default_value, Slic3r::frPerimeter, Slic3r::ConfigDef::get(), Slic3r::ConfigOptionDef::get_default_value(), Slic3r::layer_height(), Slic3r::Flow::mm3_per_mm(), Slic3r::nozzle_diameter(), and Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::GCode::_do_export(), Slic3r::GUI::CalibUtils::calib_pa_pattern(), and Slic3r::GUI::CalibUtils::set_for_auto_pa_model_and_config().

Here is the call graph for this function:

Here is the caller graph for this function:

get_distance()

double Slic3r::CalibPressureAdvance::get_distance ( Vec2d from, Vec2d to ) const

protected

{
    return std::hypot((to.x() - from.x()), (to.y() - from.y()));
}

Referenced by draw_line().

Here is the caller graph for this function:

move_to()

std::string Slic3r::CalibPressureAdvance::move_to ( Vec2d pt, GCodeWriter & writer, std::string comment = std::string(), double z = 0, double layer_height = -1 )

protected

{
    std::stringstream gcode;
 
    gcode << writer.retract(); // retract before z move or move
    if(z > EPSILON && layer_height >= 0){
        gcode << writer.travel_to_z(z, "Z-hop"); // Perform z hop
        gcode << writer.travel_to_xy(pt, comment); // Travel with z move
        gcode << writer.travel_to_z(layer_height, "undo Z-hop"); // Undo z hop
    }else {
        gcode << writer.travel_to_xy(pt, comment);
    }
    gcode << writer.unretract(); // unretract after z move is complete
 
    m_last_pos = Vec3d(pt.x(), pt.y(), 0);
 
    return gcode.str();
}

References EPSILON, Slic3r::layer_height(), m_last_pos, Slic3r::GCodeWriter::retract(), Slic3r::GCodeWriter::travel_to_xy(), Slic3r::GCodeWriter::travel_to_z(), and Slic3r::GCodeWriter::unretract().

Referenced by draw_box(), draw_digit(), Slic3r::CalibPressureAdvancePattern::generate_custom_gcodes(), and Slic3r::CalibPressureAdvanceLine::print_pa_lines().

Here is the call graph for this function:

Here is the caller graph for this function:

number_spacing()

double Slic3r::CalibPressureAdvance::number_spacing ( ) const

inlineprotected

{ return m_digit_segment_len + m_digit_gap_len; };

References m_digit_gap_len, and m_digit_segment_len.

Referenced by draw_number(), Slic3r::CalibPressureAdvanceLine::print_extents(), and Slic3r::CalibPressureAdvanceLine::print_pa_lines().

Here is the caller graph for this function:

speed_adjust()

double Slic3r::CalibPressureAdvance::speed_adjust ( int speed ) const

inlineprotected

{ return speed * 60; };

Referenced by Slic3r::CalibPressureAdvancePattern::generate_custom_gcodes(), and Slic3r::CalibPressureAdvanceLine::print_pa_lines().

Here is the caller graph for this function:

to_radians()

double Slic3r::CalibPressureAdvance::to_radians ( double degrees ) const

inlineprotected

{ return degrees * M_PI / 180; };

References M_PI.

Referenced by Slic3r::CalibPressureAdvancePattern::_refresh_starting_point(), draw_box(), Slic3r::CalibPressureAdvancePattern::frame_size_y(), Slic3r::CalibPressureAdvancePattern::generate_custom_gcodes(), Slic3r::CalibPressureAdvancePattern::line_spacing_angle(), Slic3r::CalibPressureAdvancePattern::object_size_x(), and Slic3r::CalibPressureAdvancePattern::object_size_y().

Here is the caller graph for this function:

Member Data Documentation

m_config

DynamicPrintConfig Slic3r::CalibPressureAdvance::m_config

protected

Referenced by CalibPressureAdvance(), CalibPressureAdvance(), Slic3r::CalibPressureAdvancePattern::_refresh_writer(), Slic3r::CalibPressureAdvancePattern::accel_perimeter(), draw_line(), Slic3r::CalibPressureAdvancePattern::flow_val(), Slic3r::CalibPressureAdvancePattern::generate_custom_gcodes(), Slic3r::CalibPressureAdvancePattern::height_first_layer(), Slic3r::CalibPressureAdvancePattern::height_layer(), Slic3r::CalibPressureAdvancePattern::height_z_offset(), Slic3r::CalibPressureAdvancePattern::line_width(), Slic3r::CalibPressureAdvancePattern::line_width_first_layer(), Slic3r::CalibPressureAdvancePattern::refresh_setup(), Slic3r::CalibPressureAdvancePattern::speed_first_layer(), Slic3r::CalibPressureAdvancePattern::speed_perimeter(), and Slic3r::CalibPressureAdvancePattern::wall_count().

m_digit_gap_len

const double Slic3r::CalibPressureAdvance::m_digit_gap_len {1}

protected

{1};

Referenced by Slic3r::CalibPressureAdvancePattern::max_numbering_height(), and number_spacing().

m_digit_segment_len

const double Slic3r::CalibPressureAdvance::m_digit_segment_len {2}

protected

{2};

Referenced by draw_digit(), Slic3r::CalibPressureAdvancePattern::glyph_length_x(), Slic3r::CalibPressureAdvancePattern::max_numbering_height(), and number_spacing().

m_draw_digit_mode

DrawDigitMode Slic3r::CalibPressureAdvance::m_draw_digit_mode {DrawDigitMode::Left_To_Right}

protected

{DrawDigitMode::Left_To_Right};

Referenced by Slic3r::CalibPressureAdvancePattern::CalibPressureAdvancePattern(), Slic3r::CalibPressureAdvancePattern::generate_custom_gcodes(), and Slic3r::CalibPressureAdvanceLine::print_pa_lines().

m_encroachment

const double Slic3r::CalibPressureAdvance::m_encroachment {1. / 3.}

protected

{1. / 3.};

Referenced by draw_box(), and Slic3r::CalibPressureAdvancePattern::generate_custom_gcodes().

m_last_pos

Vec3d Slic3r::CalibPressureAdvance::m_last_pos

protected

Referenced by draw_line(), and move_to().

m_max_number_len

const std::string::size_type Slic3r::CalibPressureAdvance::m_max_number_len {5}

protected

{5};

Referenced by Slic3r::CalibPressureAdvancePattern::max_numbering_length().

m_number_len

std::string::size_type Slic3r::CalibPressureAdvance::m_number_len {m_max_number_len}

protected

{m_max_number_len}; /* Current length of number labels */

Referenced by draw_number(), and Slic3r::CalibPressureAdvancePattern::generate_custom_gcodes().

---

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

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