Slic3r::CalibPressureAdvanceLine Class Reference

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

Inheritance diagram for Slic3r::CalibPressureAdvanceLine:

Collaboration diagram for Slic3r::CalibPressureAdvanceLine:

Public Member Functions
	CalibPressureAdvanceLine (GCode *gcodegen)
	~CalibPressureAdvanceLine ()
BoundingBoxf	print_extents (const BoundingBoxf &bed_ext) const
std::string	generate_test (double start_pa=0, double step_pa=0.002, int count=50)
void	set_speed (double fast=100.0, double slow=20.0)
const double &	line_width ()
const double &	height_layer ()
bool	is_delta () const
bool &	draw_numbers ()

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
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}

Private Member Functions
std::string	print_pa_lines (double start_x, double start_y, double start_pa, double step_pa, int num)
void	delta_modify_start (double &startx, double &starty, int count)

Private Attributes
GCode *	mp_gcodegen
double	m_nozzle_diameter
double	m_slow_speed
double	m_fast_speed
double	m_height_layer {0.2}
double	m_line_width {0.6}
double	m_thin_line_width {0.44}
double	m_number_line_width {0.48}
const double	m_space_y {3.5}
double	m_length_short {20.0}
double	m_length_long {40.0}
bool	m_draw_numbers {true}

Detailed Description

Member Enumeration Documentation

DrawDigitMode

enum class Slic3r::CalibPressureAdvance::DrawDigitMode

strongprotectedinherited

Enumerator
Left_To_Right
Bottom_To_Top

{ Left_To_Right, Bottom_To_Top };

Constructor & Destructor Documentation

CalibPressureAdvanceLine()

Slic3r::CalibPressureAdvanceLine::CalibPressureAdvanceLine

(

GCode *

gcodegen

)

    : CalibPressureAdvance(gcodegen->config()), mp_gcodegen(gcodegen), m_nozzle_diameter(gcodegen->config().nozzle_diameter.get_at(0))
{
    m_line_width        = m_nozzle_diameter < 0.51 ? m_nozzle_diameter * 1.5 : m_nozzle_diameter * 1.05;
    m_height_layer      = gcodegen->config().initial_layer_print_height;
    m_number_line_width = m_thin_line_width = m_nozzle_diameter;
};

References Slic3r::CalibPressureAdvance::CalibPressureAdvance(), Slic3r::GCode::config(), Slic3r::initial_layer_print_height(), m_height_layer, m_line_width, m_nozzle_diameter, m_number_line_width, m_thin_line_width, mp_gcodegen, and Slic3r::nozzle_diameter().

Here is the call graph for this function:

~CalibPressureAdvanceLine()

Slic3r::CalibPressureAdvanceLine::~CalibPressureAdvanceLine ( )

inline

{};

Member Function Documentation

convert_number_to_string()

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

protectedinherited

{
    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_modify_start()

void Slic3r::CalibPressureAdvanceLine::delta_modify_start ( double & startx, double & starty, int count )

private

{
    startx = -startx;
    starty = -(count * m_space_y) / 2;
}

References count, and m_space_y.

delta_scale_bed_ext()

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

inlineprotectedinherited

{ 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 )

protectedinherited

{
    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 )

protectedinherited

{
    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() )

protectedinherited

{
    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 )

protectedinherited

{
    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:

draw_numbers()

bool & Slic3r::CalibPressureAdvanceLine::draw_numbers ( )

inline

{ return m_draw_numbers; }

References m_draw_numbers.

Referenced by Slic3r::GCode::_do_export().

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

protectedinherited

{
    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 )

staticinherited

{
    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:

generate_test()

std::string Slic3r::CalibPressureAdvanceLine::generate_test	(	double	start_pa = 0,
		double	step_pa = 0.002,
		int	count = 50 )

{
    BoundingBoxf bed_ext = get_extents(mp_gcodegen->config().printable_area.values);
    if (is_delta()) {
        CalibPressureAdvanceLine::delta_scale_bed_ext(bed_ext);
    }
 
    auto        bed_sizes = mp_gcodegen->config().printable_area.values;
    const auto  w         = bed_ext.size().x();
    const auto  h         = bed_ext.size().y();
    count                 = std::min(count, int((h - 10) / m_space_y));
 
    m_length_long = 40 + std::min(w - 120.0, 0.0);
 
    auto startx = bed_ext.min.x() + (w - m_length_short * 2 - m_length_long - 20) / 2;
    auto starty = bed_ext.min.y() + (h - count * m_space_y) / 2;
 
    return print_pa_lines(startx, starty, start_pa, step_pa, count);
}

References count, Slic3r::CalibPressureAdvance::delta_scale_bed_ext(), Slic3r::get_extents(), is_delta(), m_length_long, m_length_short, m_space_y, Slic3r::BoundingBoxBase< PointType, APointsType >::min, mp_gcodegen, print_pa_lines(), and Slic3r::BoundingBoxBase< PointType, APointsType >::size().

Referenced by Slic3r::GCode::_do_export().

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

protectedinherited

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

Referenced by draw_line().

Here is the caller graph for this function:

height_layer()

const double & Slic3r::CalibPressureAdvanceLine::height_layer ( )

inline

{ return m_height_layer; };

References m_height_layer.

Referenced by Slic3r::GCode::_do_export().

Here is the caller graph for this function:

is_delta()

bool Slic3r::CalibPressureAdvanceLine::is_delta

(

)

const

{ return mp_gcodegen->config().printable_area.values.size() > 4; }

References mp_gcodegen.

Referenced by generate_test(), and print_extents().

Here is the caller graph for this function:

line_width()

const double & Slic3r::CalibPressureAdvanceLine::line_width ( )

inline

{ return m_line_width; };

References m_line_width.

Referenced by Slic3r::GCode::_do_export().

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 )

protectedinherited

{
    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

inlineprotectedinherited

{ 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:

print_extents()

BoundingBoxf Slic3r::CalibPressureAdvanceLine::print_extents

(

const BoundingBoxf &

bed_ext

)

const

{
    BoundingBoxf adjusted_bed = bed_ext;
    if (is_delta()) {
        CalibPressureAdvanceLine::delta_scale_bed_ext(adjusted_bed);
    }
    
    double bed_width     = adjusted_bed.size().x();
    // m_length_long adjusts for narrow beds – exactly as in generate_test()
    double line_long     = 40.0 + std::min(bed_width - 120.0, 0.0);
    double total_line_len = m_length_short * 2 + line_long;
    double start_x       = adjusted_bed.min.x() + (bed_width - 2 * m_length_short - line_long - 20.0) / 2.0;
    double box_width     = m_draw_numbers ? (number_spacing() * 8) : 0.0;   // 3.0 * 8 = 24 mm
 
    BoundingBoxf extent;
    extent.min.x() = start_x;
    extent.max.x() = start_x + total_line_len + m_line_width + box_width;
 
    // Y bounds are the full bed (the caller will inset them by -25)
    extent.min.y() = adjusted_bed.min.y();
    extent.max.y() = adjusted_bed.max.y();
 
    return extent;
}

References Slic3r::CalibPressureAdvance::delta_scale_bed_ext(), is_delta(), m_draw_numbers, m_length_short, m_line_width, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::CalibPressureAdvance::number_spacing(), and Slic3r::BoundingBoxBase< PointType, APointsType >::size().

Referenced by Slic3r::GCode::_do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

print_pa_lines()

std::string Slic3r::CalibPressureAdvanceLine::print_pa_lines ( double start_x, double start_y, double start_pa, double step_pa, int num )

private

{
    auto       &writer = mp_gcodegen->writer();
    const auto &config = mp_gcodegen->config();
 
    const auto filament_diameter = config.filament_diameter.get_at(0);
    const auto print_flow_ratio  = config.print_flow_ratio;
    const auto z_offset          = config.z_offset;
 
    const double e_per_mm        = CalibPressureAdvance::e_per_mm(m_line_width, m_height_layer, m_nozzle_diameter, filament_diameter,
                                                                  print_flow_ratio);
    const double thin_e_per_mm   = CalibPressureAdvance::e_per_mm(m_thin_line_width, m_height_layer, m_nozzle_diameter, filament_diameter,
                                                                  print_flow_ratio);
    const double number_e_per_mm = CalibPressureAdvance::e_per_mm(m_number_line_width, m_height_layer, m_nozzle_diameter, filament_diameter,
                                                                  print_flow_ratio);
 
    const double      fast = CalibPressureAdvance::speed_adjust(m_fast_speed);
    const double      slow = CalibPressureAdvance::speed_adjust(m_slow_speed);
    std::stringstream gcode;
    gcode << mp_gcodegen->writer().travel_to_z(m_height_layer + z_offset);
    gcode << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height) << (m_height_layer + z_offset) << "\n";
    double y_pos = start_y;
    // Purge/first perimeter - acts as an anchor to the rest of the model
    gcode << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role) << "Custom\n";
    gcode << writer.set_pressure_advance(0.0);
    auto prime_x = start_x;
    gcode << move_to(Vec2d(prime_x, y_pos + (num) * m_space_y), writer);
    gcode << writer.set_speed(slow);
    gcode << writer.extrude_to_xy(Vec2d(prime_x, y_pos), e_per_mm * m_space_y * num * 1.2);
 
    for (int i = 0; i < num; ++i) {
        gcode << writer.set_pressure_advance(start_pa + i * step_pa);
        gcode << move_to(Vec2d(start_x, y_pos + i * m_space_y), writer);
        gcode << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role) << "Custom\n";
        gcode << writer.set_speed(slow);
        gcode << writer.extrude_to_xy(Vec2d(start_x + m_length_short, y_pos + i * m_space_y), e_per_mm * m_length_short);
        gcode << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role) << "Outer wall\n";
        gcode << writer.set_speed(fast);
        gcode << writer.extrude_to_xy(Vec2d(start_x + m_length_short + m_length_long, y_pos + i * m_space_y), e_per_mm * m_length_long);
        gcode << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role) << "Custom\n";
        gcode << writer.set_speed(slow);
        gcode << writer.extrude_to_xy(Vec2d(start_x + m_length_short + m_length_long + m_length_short, y_pos + i * m_space_y),
                                      e_per_mm * m_length_short);
 
        if (i == 0) {
            // Print extra anchor line
            gcode << writer.set_pressure_advance(0.0);
            gcode << writer.extrude_to_xy(Vec2d(start_x + m_length_short + m_length_long + m_length_short, y_pos + (num) * m_space_y), e_per_mm * m_space_y * num * 1.2);
        }
    }
    gcode << writer.set_pressure_advance(0.0);
 
    if (m_draw_numbers) {
 
        // Orca: skip drawing indicator lines
        // gcode << writer.set_speed(fast);
        // gcode << move_to(Vec2d(start_x + m_length_short, y_pos + (num - 1) * m_space_y + 2), writer);
        // gcode << writer.extrude_to_xy(Vec2d(start_x + m_length_short, y_pos + (num - 1) * m_space_y + 7), thin_e_per_mm * 7);
        // gcode << move_to(Vec2d(start_x + m_length_short + m_length_long, y_pos + (num - 1) * m_space_y + 7), writer);
        // gcode << writer.extrude_to_xy(Vec2d(start_x + m_length_short + m_length_long, y_pos + (num - 1) * m_space_y + 2), thin_e_per_mm * 7);
 
        const auto     box_start_x = start_x + m_length_short + m_length_long + m_length_short + m_line_width;
        DrawBoxOptArgs default_box_opt_args(2, m_height_layer, m_line_width, fast);
        //Draw box
        default_box_opt_args.is_filled = true;
        gcode << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role) << "Bottom surface\n";
        gcode << draw_box(writer, box_start_x, start_y - m_space_y,
                          number_spacing() * 8, (num + 1) * m_space_y, default_box_opt_args);
        //Ensure numbers are shown on the next layer in gcode processor, as in reality
        gcode << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Layer_Change) << "\n";
        gcode << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Height) << (m_height_layer*2 + z_offset) << "\n";
        gcode << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role) << "Top surface\n";
        gcode << writer.travel_to_z(m_height_layer*2 + z_offset);
        for (int i = 0; i < num; i += 2) {
            gcode << draw_number(box_start_x + 3 + m_line_width, y_pos + i * m_space_y + m_space_y / 2, start_pa + i * step_pa, m_draw_digit_mode,
                                 m_number_line_width, number_e_per_mm, 3600, writer);
        }
    }
    return gcode.str();
}

References Slic3r::CalibPressureAdvance::draw_box(), Slic3r::CalibPressureAdvance::draw_number(), Slic3r::CalibPressureAdvance::e_per_mm(), Slic3r::GCodeProcessor::Height, Slic3r::DrawBoxOptArgs::is_filled, Slic3r::GCodeProcessor::Layer_Change, Slic3r::CalibPressureAdvance::m_draw_digit_mode, m_draw_numbers, m_fast_speed, m_height_layer, m_length_long, m_length_short, m_line_width, m_nozzle_diameter, m_number_line_width, m_slow_speed, m_space_y, m_thin_line_width, Slic3r::CalibPressureAdvance::move_to(), mp_gcodegen, Slic3r::CalibPressureAdvance::number_spacing(), Slic3r::print_flow_ratio(), Slic3r::GCodeProcessor::reserved_tag(), Slic3r::GCodeProcessor::Role, and Slic3r::CalibPressureAdvance::speed_adjust().

Referenced by generate_test().

Here is the call graph for this function:

Here is the caller graph for this function:

set_speed()

void Slic3r::CalibPressureAdvanceLine::set_speed ( double fast = 100.0, double slow = 20.0 )

inline

    {
        m_slow_speed = slow;
        m_fast_speed = fast;
    }

References m_fast_speed, and m_slow_speed.

Referenced by Slic3r::GCode::_do_export().

Here is the caller graph for this function:

speed_adjust()

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

inlineprotectedinherited

{ 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

inlineprotectedinherited

{ 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

protectedinherited

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}

protectedinherited

{1};

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

m_digit_segment_len

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

protectedinherited

{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}

protectedinherited

{DrawDigitMode::Left_To_Right};

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

m_draw_numbers

bool Slic3r::CalibPressureAdvanceLine::m_draw_numbers {true}

private

{true};

Referenced by draw_numbers(), print_extents(), and print_pa_lines().

m_encroachment

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

protectedinherited

{1. / 3.};

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

m_fast_speed

double Slic3r::CalibPressureAdvanceLine::m_fast_speed

private

Referenced by print_pa_lines(), and set_speed().

m_height_layer

double Slic3r::CalibPressureAdvanceLine::m_height_layer {0.2}

private

{0.2};

Referenced by CalibPressureAdvanceLine(), height_layer(), and print_pa_lines().

m_last_pos

Vec3d Slic3r::CalibPressureAdvance::m_last_pos

protectedinherited

Referenced by draw_line(), and move_to().

m_length_long

double Slic3r::CalibPressureAdvanceLine::m_length_long {40.0}

private

{20.0}, m_length_long{40.0};

Referenced by generate_test(), and print_pa_lines().

m_length_short

double Slic3r::CalibPressureAdvanceLine::m_length_short {20.0}

private

{20.0}, m_length_long{40.0};

Referenced by generate_test(), print_extents(), and print_pa_lines().

m_line_width

double Slic3r::CalibPressureAdvanceLine::m_line_width {0.6}

private

{0.6};

Referenced by CalibPressureAdvanceLine(), line_width(), print_extents(), and print_pa_lines().

m_max_number_len

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

protectedinherited

{5};

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

m_nozzle_diameter

double Slic3r::CalibPressureAdvanceLine::m_nozzle_diameter

private

Referenced by CalibPressureAdvanceLine(), and print_pa_lines().

m_number_len

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

protectedinherited

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

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

m_number_line_width

double Slic3r::CalibPressureAdvanceLine::m_number_line_width {0.48}

private

{0.48};

Referenced by CalibPressureAdvanceLine(), and print_pa_lines().

m_slow_speed

double Slic3r::CalibPressureAdvanceLine::m_slow_speed

private

Referenced by print_pa_lines(), and set_speed().

m_space_y

const double Slic3r::CalibPressureAdvanceLine::m_space_y {3.5}

private

{3.5};

Referenced by delta_modify_start(), generate_test(), and print_pa_lines().

m_thin_line_width

double Slic3r::CalibPressureAdvanceLine::m_thin_line_width {0.44}

private

{0.44};

Referenced by CalibPressureAdvanceLine(), and print_pa_lines().

mp_gcodegen

GCode* Slic3r::CalibPressureAdvanceLine::mp_gcodegen

private

Referenced by CalibPressureAdvanceLine(), generate_test(), is_delta(), and print_pa_lines().

---

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