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

Inheritance diagram for Slic3r::CalibPressureAdvancePattern:

Collaboration diagram for Slic3r::CalibPressureAdvancePattern:

Public Member Functions
	CalibPressureAdvancePattern (const Calib_Params &params, const DynamicPrintConfig &config, bool is_bbl_machine, const ModelObject &object, const Vec3d &origin)
double	handle_xy_size () const
double	handle_spacing () const
Vec3d	handle_pos_offset () const
double	print_size_x () const
double	print_size_y () const
double	max_layer_z () const
double	flow_val () const
CustomGCode::Info	generate_custom_gcodes (const DynamicPrintConfig &config, bool is_bbl_machine, const ModelObject &object, const Vec3d &origin)
void	set_start_offset (const Vec3d &offset)
Vec3d	get_start_offset ()

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
double	speed_first_layer () const
double	speed_perimeter () const
double	accel_perimeter () const
double	line_width_first_layer () const
double	line_width () const
int	wall_count () const
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
void	refresh_setup (const DynamicPrintConfig &config, bool is_bbl_machine, const ModelObject &object, const Vec3d &origin)
void	_refresh_starting_point (const ModelObject &object)
void	_refresh_writer (bool is_bbl_machine, const ModelObject &object, const Vec3d &origin)
double	height_first_layer () const
double	height_z_offset () const
double	height_layer () const
const int	get_num_patterns () const
double	line_spacing () const
double	line_spacing_first_layer () const
double	line_spacing_angle () const
double	object_size_x () const
double	object_size_y () const
double	frame_size_y () const
double	glyph_start_x (int pattern_i=0) const
double	glyph_length_x () const
double	glyph_tab_max_x () const
double	max_numbering_height () const
size_t	max_numbering_length () const
double	pattern_shift () const

Private Attributes
const Calib_Params &	m_params
std::shared_ptr< GCodeWriter >	m_writer {std::make_shared<GCodeWriter>()}
Vec3d	m_starting_point
bool	m_is_start_point_fixed = false
const double	m_handle_xy_size {5}
const double	m_handle_spacing {1.2}
const int	m_num_layers {4}
const double	m_wall_side_length {30.0}
const int	m_corner_angle {90}
const int	m_pattern_spacing {2}
const double	m_glyph_padding_horizontal {1}
const double	m_glyph_padding_vertical {1}

Friends
struct	DrawBoxOptArgs

Detailed Description

Member Enumeration Documentation

◆ DrawDigitMode

enum class Slic3r::CalibPressureAdvance::DrawDigitMode

strongprotectedinherited

Enumerator
Left_To_Right
Bottom_To_Top

213{ Left_To_Right, Bottom_To_Top };

Constructor & Destructor Documentation

◆ CalibPressureAdvancePattern()

Slic3r::CalibPressureAdvancePattern::CalibPressureAdvancePattern	(	const Calib_Params &	params,
		const DynamicPrintConfig &	config,
		bool	is_bbl_machine,
		const ModelObject &	object,
		const Vec3d &	origin )

    : m_params(params),CalibPressureAdvance(config)
{
    this->m_draw_digit_mode = DrawDigitMode::Bottom_To_Top;
 
    refresh_setup(config, is_bbl_machine, object, origin);
}

References Slic3r::CalibPressureAdvance::CalibPressureAdvance(), Slic3r::CalibPressureAdvance::Bottom_To_Top, Slic3r::CalibPressureAdvance::m_draw_digit_mode, m_params, and refresh_setup().

Here is the call graph for this function:

Member Function Documentation

◆ _refresh_starting_point()

void Slic3r::CalibPressureAdvancePattern::_refresh_starting_point ( const ModelObject & object )

private

{
    if (m_is_start_point_fixed)
        return;
 
    BoundingBoxf3 bbox = object.instance_bounding_box(*object.instances.front(), false);
 
    m_starting_point = Vec3d(bbox.min.x(), bbox.max.y(), 0);
    m_starting_point.x() -= m_handle_spacing;
    m_starting_point.y() -= std::sin(to_radians(m_corner_angle) / 2) * m_wall_side_length + (bbox.max.y() - bbox.min.y()) / 2;
}

References m_corner_angle, m_handle_spacing, m_is_start_point_fixed, m_starting_point, m_wall_side_length, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, and Slic3r::CalibPressureAdvance::to_radians().

Referenced by refresh_setup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _refresh_writer()

void Slic3r::CalibPressureAdvancePattern::_refresh_writer	(	bool	is_bbl_machine,
		const ModelObject &	object,
		const Vec3d &	origin )

private

{
    PrintConfig print_config;
    print_config.apply(m_config, true);
 
    // ORCA-Belt: the pattern is drawn in logical bed coordinates directly on
    // the build surface — on a belt printer that means the belt plane, which
    // needs the machine kinematics (axis remap + frame shear/scale) with the
    // coordinates interpreted as world points (see set_world_coordinates).
    if (print_config.belt_printer.value) {
        auto belt_writer = std::make_shared<GCodeWriter>();
        install_belt_kinematics(*belt_writer, print_config, /*world_coordinates=*/true);
        const int rx = int(print_config.gcode_remap_x.value);
        const int ry = int(print_config.gcode_remap_y.value);
        const int rz = int(print_config.gcode_remap_z.value);
        if (rx != 0 || ry != 1 || rz != 2) {
            belt_writer->set_axis_remap(rx, ry, rz);
            BoundingBoxf bbox_bed(print_config.printable_area.values);
            belt_writer->set_build_volume_max(Vec3d(bbox_bed.max.x(), bbox_bed.max.y(),
                                                    print_config.printable_height.value));
        }
        m_writer = std::move(belt_writer);
    } else if (m_writer && dynamic_cast<const BeltKinematics *>(&m_writer->kinematics()) != nullptr) {
        // Previously configured for a belt printer; drop back to a plain writer.
        m_writer = std::make_shared<GCodeWriter>();
    }
 
    m_writer->apply_print_config(print_config);
    m_writer->set_xy_offset(origin(0), origin(1));
    m_writer->set_is_bbl_machine(is_bbl_machine);
 
    const unsigned int extruder_id = object.volumes.front()->extruder_id();
    m_writer->set_extruders({extruder_id});
    m_writer->set_extruder(extruder_id);
}

References Slic3r::install_belt_kinematics(), Slic3r::CalibPressureAdvance::m_config, m_writer, and Slic3r::BoundingBoxBase< PointType, APointsType >::max.

Referenced by refresh_setup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ accel_perimeter()

double Slic3r::CalibPressureAdvancePattern::accel_perimeter ( ) const

inlineprotected

334{ return m_config.get_abs_value_at("outer_wall_acceleration", m_params.extruder_id); }

References Slic3r::CalibPressureAdvance::m_config, and m_params.

Referenced by generate_custom_gcodes(), and max_numbering_length().

Here is the caller graph for this function:

◆ 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_scale_bed_ext()

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

inlineprotectedinherited

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

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

◆ flow_val()

double Slic3r::CalibPressureAdvancePattern::flow_val ( ) const

{
    double flow_mult = m_config.option<ConfigOptionFloats>("filament_flow_ratio")->get_at(0);
    double nozzle_diameter = m_config.option<ConfigOptionFloats>("nozzle_diameter")->get_at(0);
    double line_width = m_config.get_abs_value("line_width", nozzle_diameter);
    if (line_width <= 0.) line_width = Flow::auto_extrusion_width(frPerimeter, nozzle_diameter);
    double layer_height = m_config.get_abs_value("layer_height");
    double speed = speed_perimeter();
    Flow pattern_line = Flow(line_width, layer_height, nozzle_diameter);
 
    return speed * pattern_line.mm3_per_mm() * flow_mult;
};

References Slic3r::Flow::auto_extrusion_width(), Slic3r::frPerimeter, Slic3r::layer_height(), line_width(), Slic3r::CalibPressureAdvance::m_config, Slic3r::Flow::mm3_per_mm(), Slic3r::nozzle_diameter(), and speed_perimeter().

Referenced by generate_custom_gcodes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ frame_size_y()

double Slic3r::CalibPressureAdvancePattern::frame_size_y ( ) const

inlineprivate

361{ return std::sin(to_radians(double(m_corner_angle) / 2)) * m_wall_side_length * 2; };

References m_corner_angle, m_wall_side_length, and Slic3r::CalibPressureAdvance::to_radians().

Referenced by generate_custom_gcodes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_custom_gcodes()

CustomGCode::Info Slic3r::CalibPressureAdvancePattern::generate_custom_gcodes	(	const DynamicPrintConfig &	config,
		bool	is_bbl_machine,
		const ModelObject &	object,
		const Vec3d &	origin )

{
    std::stringstream gcode;
    gcode << "; start pressure advance pattern for layer\n";
 
        refresh_setup(config, is_bbl_machine, object, origin);
 
    gcode << move_to(Vec2d(m_starting_point.x(), m_starting_point.y()), *m_writer, "Move to start XY position");
    gcode << m_writer->travel_to_z(height_first_layer() + height_z_offset(), "Move to start Z position");
    gcode << m_writer->set_pressure_advance(m_params.start);
 
    const DrawBoxOptArgs default_box_opt_args(wall_count(), height_first_layer(), line_width_first_layer(),
                                              speed_adjust(speed_first_layer()));
 
    // create anchoring frame
    //pattern uses outer wall speed/width
    gcode << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role) << "Outer wall\n";
    gcode << draw_box(*m_writer, m_starting_point.x(), m_starting_point.y(), print_size_x(), frame_size_y(), default_box_opt_args);
 
    // create tab for numbers
    DrawBoxOptArgs draw_box_opt_args = default_box_opt_args;
    draw_box_opt_args.is_filled      = true;
    draw_box_opt_args.num_perimeters = wall_count();
    //draw box as bottom surface, so numbers are clearly visible on top
    gcode << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role) << "Bottom surface\n";
    gcode << draw_box(*m_writer, m_starting_point.x(), m_starting_point.y() + frame_size_y() + line_spacing_first_layer(),
                      print_size_x(),
                      max_numbering_height() + line_spacing_first_layer() + m_glyph_padding_vertical * 2, draw_box_opt_args);
 
    std::vector<CustomGCode::Item> gcode_items;
    const int                      num_patterns = get_num_patterns(); // "cache" for use in loops
 
    const double zhop_config_value = m_config.option<ConfigOptionFloats>("z_hop")->get_at(0);
    const auto accel = accel_perimeter();
 
    // Draw pressure advance pattern
    // pattern uses outer wall speed, label it as such
    gcode << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role) << "Outer wall\n";
    for (int i = 0; i < m_num_layers; ++i) {
        const double layer_height = height_first_layer() + height_z_offset() + (i * height_layer());
        const double zhop_height = layer_height + zhop_config_value;
 
        if (i > 0) {
            gcode << "; end pressure advance pattern for layer\n";
            CustomGCode::Item item;
            item.print_z = height_first_layer() + (i - 1) * height_layer();
            item.type    = CustomGCode::Type::Custom;
            item.extra   = gcode.str();
            gcode_items.push_back(item);
 
            gcode = std::stringstream(); // reset for next layer contents
            gcode << "; start pressure advance pattern for layer\n";
 
            gcode << m_writer->travel_to_z(layer_height, "Move to layer height");
            gcode << m_writer->reset_e();
        }
 
        // line numbering
        if (i == 1) {
            m_number_len = max_numbering_length();
 
            gcode << m_writer->set_pressure_advance(m_params.start);
 
            double number_e_per_mm = e_per_mm(line_width(), height_layer(),
                                              m_config.option<ConfigOptionFloats>("nozzle_diameter")->get_at(0),
                                              m_config.option<ConfigOptionFloats>("filament_diameter")->get_at(0),
                                              m_config.option<ConfigOptionFloats>("filament_flow_ratio")->get_at(0));
 
            // glyph on every other line
            gcode << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role) << "Outer wall\n";
            for (int j = 0; j < num_patterns; j += 2) {
                gcode << draw_number(glyph_start_x(j), m_starting_point.y() + frame_size_y() + m_glyph_padding_vertical + line_width(),
                                     m_params.start + (j * m_params.step), m_draw_digit_mode, line_width(), number_e_per_mm,
                                     speed_first_layer(), *m_writer);
            }
 
            // flow value
            int line_num = num_patterns + 2;
            gcode << draw_number(glyph_start_x(line_num), m_starting_point.y() + frame_size_y() + m_glyph_padding_vertical + line_width(),
                                 flow_val(), m_draw_digit_mode, line_width(), number_e_per_mm,
                                 speed_first_layer(), *m_writer);
 
            // acceleration
            line_num = num_patterns + 4;
            gcode << draw_number(glyph_start_x(line_num), m_starting_point.y() + frame_size_y() + m_glyph_padding_vertical + line_width(),
                                 accel, m_draw_digit_mode, line_width(), number_e_per_mm,
                                 speed_first_layer(), *m_writer);
        }
 
 
        double to_x        = m_starting_point.x() + pattern_shift();
        double to_y        = m_starting_point.y();
        double side_length = m_wall_side_length;
 
        // shrink first layer to fit inside frame
        if (i == 0) {
            double shrink = (line_spacing_first_layer() * (wall_count() - 1) + (line_width_first_layer() * (1 - m_encroachment))) /
                            std::sin(to_radians(m_corner_angle) / 2);
            side_length = m_wall_side_length - shrink;
            to_x += shrink * std::sin(to_radians(90) - to_radians(m_corner_angle) / 2);
            to_y += line_spacing_first_layer() * (wall_count() - 1) + (line_width_first_layer() * (1 - m_encroachment));
        } else {
            /* Draw a line at slightly slower accel and speed in order to trick gcode writer to force update acceleration and speed.
             * We do this since several tests may be generated by their own gcode writers which are
             * not aware about their neighbours updating acceleration/speed */
            gcode << m_writer->set_print_acceleration(std::max<int>(1, accel - 1));
            gcode << move_to(Vec2d(m_starting_point.x(), m_starting_point.y()), *m_writer, "Move to starting point", zhop_height, layer_height);
            gcode << draw_line(*m_writer, Vec2d(m_starting_point.x(), m_starting_point.y() + frame_size_y()), line_width(), height_layer(), speed_adjust(std::max<int>(1, speed_perimeter() - 1)), "Accel/flow trick line");
            gcode << m_writer->set_print_acceleration(accel);
        }
 
        double initial_x = to_x;
        double initial_y = to_y;
 
        gcode << move_to(Vec2d(to_x, to_y), *m_writer, "Move to pattern start",zhop_height,layer_height);
 
        for (int j = 0; j < num_patterns; ++j) {
            // increment pressure advance
            gcode << m_writer->set_pressure_advance(m_params.start + (j * m_params.step));
            gcode << ";" << GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Role) << "Outer wall\n";
            for (int k = 0; k < wall_count(); ++k) {
                to_x += std::cos(to_radians(m_corner_angle) / 2) * side_length;
                to_y += std::sin(to_radians(m_corner_angle) / 2) * side_length;
 
                auto draw_line_arg_height = i == 0 ? height_first_layer() : height_layer();
                auto draw_line_arg_line_width = line_width(); // don't use line_width_first_layer so results are consistent across all layers
                auto draw_line_arg_speed   = i == 0 ? speed_adjust(speed_first_layer()) : speed_adjust(speed_perimeter());
                auto draw_line_arg_comment = "Print pattern wall";
                gcode << draw_line(*m_writer, Vec2d(to_x, to_y), draw_line_arg_line_width, draw_line_arg_height, draw_line_arg_speed, draw_line_arg_comment);
 
                to_x -= std::cos(to_radians(m_corner_angle) / 2) * side_length;
                to_y += std::sin(to_radians(m_corner_angle) / 2) * side_length;
 
                gcode << draw_line(*m_writer, Vec2d(to_x, to_y), draw_line_arg_line_width, draw_line_arg_height, draw_line_arg_speed, draw_line_arg_comment);
 
                to_y = initial_y;
                if (k != wall_count() - 1) {
                    // perimeters not done yet. move to next perimeter
                    to_x += line_spacing_angle();
                    gcode << move_to(Vec2d(to_x, to_y), *m_writer, "Move to start next pattern wall", zhop_height, layer_height); // Call move to command with XY as well as z hop and layer height to invoke and undo z lift
                } else if (j != num_patterns - 1) {
                    // patterns not done yet. move to next pattern
                    to_x += m_pattern_spacing + line_width();
                    gcode << move_to(Vec2d(to_x, to_y), *m_writer, "Move to next pattern", zhop_height, layer_height); // Call move to command with XY as well as z hop and layer height to invoke and undo z lift
                } else if (i != m_num_layers - 1) {
                    // layers not done yet. move back to start
                    to_x = initial_x;
                    gcode << move_to(Vec2d(to_x, to_y), *m_writer, "Move back to start position", zhop_height, layer_height); // Call move to command with XY as well as z hop and layer height to invoke and undo z lift
                    gcode << m_writer->reset_e(); // reset extruder before printing placeholder cube to avoid over extrusion
                } else {
                    // everything done
                }
            }
        }
    }
 
    gcode << m_writer->reset_e();
    gcode << m_writer->set_pressure_advance(m_params.start);
    gcode << "; end pressure advance pattern for layer\n";
 
    CustomGCode::Item item;
    item.print_z = max_layer_z();
    item.type    = CustomGCode::Type::Custom;
    item.extra   = gcode.str();
    gcode_items.push_back(item);
 
    CustomGCode::Info info;
    info.mode   = CustomGCode::Mode::SingleExtruder;
    info.gcodes = gcode_items;
 
    return info;
}

Referenced by Slic3r::GUI::CalibUtils::calib_pa_pattern().

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:

◆ get_num_patterns()

const int Slic3r::CalibPressureAdvancePattern::get_num_patterns ( ) const

inlineprivate

347{ return std::ceil((m_params.end - m_params.start) / m_params.step + 1); }

References m_params.

Referenced by generate_custom_gcodes(), glyph_tab_max_x(), max_numbering_length(), and object_size_x().

Here is the caller graph for this function:

◆ get_start_offset()

Vec3d Slic3r::CalibPressureAdvancePattern::get_start_offset ( )

{
    return m_starting_point;
}

References m_starting_point.

◆ glyph_length_x()

double Slic3r::CalibPressureAdvancePattern::glyph_length_x ( ) const

private

{
    // half of line_width sticks out on each side
    return line_width() + (2 * m_digit_segment_len);
}

References line_width(), and Slic3r::CalibPressureAdvance::m_digit_segment_len.

Referenced by glyph_start_x(), and glyph_tab_max_x().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ glyph_start_x()

double Slic3r::CalibPressureAdvancePattern::glyph_start_x ( int pattern_i = 0 ) const

private

{
    // note that pattern_i is zero-based!
    // align glyph's start with first perimeter of specified pattern
    double x =
        // starting offset
        m_starting_point.x() + pattern_shift() +
 
        // width of pattern extrusions
        pattern_i * (wall_count() - 1) * line_spacing_angle() + // center to center distance of extrusions
        pattern_i * line_width() +                              // endcaps. center to end on either side = 1 line width
 
        // space between each pattern
        pattern_i * m_pattern_spacing;
 
    // align to middle of pattern walls
    x += wall_count() * line_spacing_angle() / 2;
 
    // shift so glyph is centered on pattern
    // m_digit_segment_len = half of X length of glyph
    x -= (glyph_length_x() / 2);
 
    return x;
}

References glyph_length_x(), line_spacing_angle(), line_width(), m_pattern_spacing, m_starting_point, pattern_shift(), and wall_count().

Referenced by generate_custom_gcodes(), and glyph_tab_max_x().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ glyph_tab_max_x()

double Slic3r::CalibPressureAdvancePattern::glyph_tab_max_x ( ) const

private

{
    // only every other glyph is shown, starting with 1
    int num     = get_num_patterns();
    int max_num = (num % 2 == 0) ? num - 1 : num;
 
    // padding at end should be same as padding at start
    double padding = glyph_start_x(0) - m_starting_point.x();
 
    return glyph_start_x(max_num - 1) + // glyph_start_x is zero-based
           (glyph_length_x() - line_width() / 2) + padding;
}

References get_num_patterns(), glyph_length_x(), glyph_start_x(), line_width(), and m_starting_point.

Here is the call graph for this function:

◆ handle_pos_offset()

Vec3d Slic3r::CalibPressureAdvancePattern::handle_pos_offset ( ) const

{
    return Vec3d{0 - print_size_x() / 2 + handle_xy_size() / 2 + handle_spacing(),
                 0 - max_numbering_height() / 2 - m_glyph_padding_vertical,
                 max_layer_z() / 2};
}

References handle_spacing(), handle_xy_size(), m_glyph_padding_vertical, max_layer_z(), max_numbering_height(), and print_size_x().

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_spacing()

double Slic3r::CalibPressureAdvancePattern::handle_spacing ( ) const

inline

318{ return m_handle_spacing; };

References m_handle_spacing.

Referenced by handle_pos_offset().

Here is the caller graph for this function:

◆ handle_xy_size()

double Slic3r::CalibPressureAdvancePattern::handle_xy_size ( ) const

inline

317{ return m_handle_xy_size; };

Slic3r::CalibPressureAdvancePattern::m_handle_xy_size

const double m_handle_xy_size

Definition calib.hpp:380

References m_handle_xy_size.

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), and handle_pos_offset().

Here is the caller graph for this function:

◆ height_first_layer()

double Slic3r::CalibPressureAdvancePattern::height_first_layer ( ) const

inlineprivate

344{ return m_config.option<ConfigOptionFloat>("initial_layer_print_height")->value; };

Slic3r::ConfigOptionFloat

zaa_minimize_perimeter_height ConfigOptionFloat

Definition PrintConfig.hpp:1954

References Slic3r::CalibPressureAdvance::m_config.

Referenced by generate_custom_gcodes(), line_spacing_first_layer(), and max_layer_z().

Here is the caller graph for this function:

◆ height_layer()

double Slic3r::CalibPressureAdvancePattern::height_layer ( ) const

inlineprivate

346{ return m_config.option<ConfigOptionFloat>("layer_height")->value; };

References Slic3r::CalibPressureAdvance::m_config.

Referenced by generate_custom_gcodes(), line_spacing(), and max_layer_z().

Here is the caller graph for this function:

◆ height_z_offset()

double Slic3r::CalibPressureAdvancePattern::height_z_offset ( ) const

inlineprivate

345{ return m_config.option<ConfigOptionFloat>("z_offset")->value; };

References Slic3r::CalibPressureAdvance::m_config.

Referenced by generate_custom_gcodes().

Here is the caller graph for this function:

◆ line_spacing()

double Slic3r::CalibPressureAdvancePattern::line_spacing ( ) const

inlineprivate

355{ return line_width() - height_layer() * (1 - M_PI / 4); };

References height_layer(), line_width(), and M_PI.

Referenced by line_spacing_angle().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ line_spacing_angle()

double Slic3r::CalibPressureAdvancePattern::line_spacing_angle ( ) const

inlineprivate

357{ return line_spacing() / std::sin(to_radians(m_corner_angle) / 2); };

Slic3r::CalibPressureAdvancePattern::line_spacing

double line_spacing() const

Definition calib.hpp:355

References line_spacing(), m_corner_angle, and Slic3r::CalibPressureAdvance::to_radians().

Referenced by generate_custom_gcodes(), glyph_start_x(), and object_size_x().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ line_spacing_first_layer()

double Slic3r::CalibPressureAdvancePattern::line_spacing_first_layer ( ) const

inlineprivate

356{ return line_width_first_layer() - height_first_layer() * (1 - M_PI / 4); };

References height_first_layer(), line_width_first_layer(), and M_PI.

Referenced by generate_custom_gcodes(), object_size_x(), and pattern_shift().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ line_width()

double Slic3r::CalibPressureAdvancePattern::line_width ( ) const

protected

{
    // TODO: FIXME: find out current filament/extruder?
    const double nozzle_diameter = m_config.opt_float("nozzle_diameter", 0);
    const double width           = m_config.get_abs_value("line_width", nozzle_diameter);
    if (width <= 0.)
        return Flow::auto_extrusion_width(frExternalPerimeter, nozzle_diameter);
    return width;
};

References Slic3r::Flow::auto_extrusion_width(), Slic3r::frExternalPerimeter, Slic3r::CalibPressureAdvance::m_config, and Slic3r::nozzle_diameter().

Referenced by flow_val(), generate_custom_gcodes(), glyph_length_x(), glyph_start_x(), glyph_tab_max_x(), line_spacing(), and object_size_x().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ line_width_first_layer()

double Slic3r::CalibPressureAdvancePattern::line_width_first_layer ( ) const

protected

{
    // TODO: FIXME: find out current filament/extruder?
    const double nozzle_diameter = m_config.opt_float("nozzle_diameter", m_params.extruder_id);
    const double width           = m_config.get_abs_value("initial_layer_line_width", nozzle_diameter);
    if (width <= 0.)
        return Flow::auto_extrusion_width(frExternalPerimeter, nozzle_diameter);
    return width;
};

References Slic3r::Flow::auto_extrusion_width(), Slic3r::frExternalPerimeter, Slic3r::CalibPressureAdvance::m_config, m_params, and Slic3r::nozzle_diameter().

Referenced by generate_custom_gcodes(), line_spacing_first_layer(), object_size_y(), and pattern_shift().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ max_layer_z()

double Slic3r::CalibPressureAdvancePattern::max_layer_z ( ) const

inline

322{ return height_first_layer() + ((m_num_layers - 1) * height_layer()); };

References height_first_layer(), height_layer(), and m_num_layers.

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), generate_custom_gcodes(), and handle_pos_offset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ max_numbering_height()

double Slic3r::CalibPressureAdvancePattern::max_numbering_height ( ) const

private

{
    std::string::size_type num_characters = max_numbering_length();
    return (num_characters * m_digit_segment_len) + ((num_characters - 1) * m_digit_gap_len);
}

References Slic3r::CalibPressureAdvance::m_digit_gap_len, Slic3r::CalibPressureAdvance::m_digit_segment_len, and max_numbering_length().

Referenced by generate_custom_gcodes(), handle_pos_offset(), and object_size_y().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ max_numbering_length()

size_t Slic3r::CalibPressureAdvancePattern::max_numbering_length ( ) const

private

{
    std::string::size_type most_characters = 0;
    const int              num_patterns    = get_num_patterns();
 
    // note: only every other number is printed
    for (std::string::size_type i = 0; i < num_patterns; i += 2) {
        std::string sNumber = convert_number_to_string(m_params.start + (i * m_params.step));
 
        if (sNumber.length() > most_characters) {
            most_characters = sNumber.length();
        }
    }
 
    std::string sAccel = convert_number_to_string(accel_perimeter());
    most_characters = std::max(most_characters, sAccel.length());
 
    /* don't actually check flow value: we'll print as many fractional digits as fits */
 
    return std::min(most_characters, m_max_number_len);
}

References accel_perimeter(), Slic3r::CalibPressureAdvance::convert_number_to_string(), get_num_patterns(), Slic3r::CalibPressureAdvance::m_max_number_len, and m_params.

Referenced by generate_custom_gcodes(), and max_numbering_height().

Here is the call graph for this function:

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

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

◆ object_size_x()

double Slic3r::CalibPressureAdvancePattern::object_size_x ( ) const

private

{
    return get_num_patterns() * ((wall_count() - 1) * line_spacing_angle()) +
           (get_num_patterns() - 1) * (m_pattern_spacing + line_width()) + std::cos(to_radians(m_corner_angle) / 2) * m_wall_side_length +
           line_spacing_first_layer() * wall_count();
}

References get_num_patterns(), line_spacing_angle(), line_spacing_first_layer(), line_width(), m_corner_angle, m_pattern_spacing, m_wall_side_length, Slic3r::CalibPressureAdvance::to_radians(), and wall_count().

Referenced by print_size_x().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ object_size_y()

double Slic3r::CalibPressureAdvancePattern::object_size_y ( ) const

private

{
    return 2 * (std::sin(to_radians(m_corner_angle) / 2) * m_wall_side_length) + max_numbering_height() + m_glyph_padding_vertical * 2 +
           line_width_first_layer();
}

References line_width_first_layer(), m_corner_angle, m_glyph_padding_vertical, m_wall_side_length, max_numbering_height(), and Slic3r::CalibPressureAdvance::to_radians().

Referenced by print_size_y().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pattern_shift()

double Slic3r::CalibPressureAdvancePattern::pattern_shift ( ) const

private

{
    return (wall_count() - 1) * line_spacing_first_layer() + line_width_first_layer() + m_glyph_padding_horizontal;
}

References line_spacing_first_layer(), line_width_first_layer(), m_glyph_padding_horizontal, and wall_count().

Referenced by generate_custom_gcodes(), glyph_start_x(), and print_size_x().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_size_x()

double Slic3r::CalibPressureAdvancePattern::print_size_x ( ) const

inline

320{ return object_size_x() + pattern_shift(); };

Slic3r::CalibPressureAdvancePattern::object_size_x

double object_size_x() const

Definition calib.cpp:912

References object_size_x(), and pattern_shift().

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::GUI::CalibUtils::calib_pa_pattern(), generate_custom_gcodes(), and handle_pos_offset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_size_y()

double Slic3r::CalibPressureAdvancePattern::print_size_y ( ) const

inline

321{ return object_size_y(); };

Slic3r::CalibPressureAdvancePattern::object_size_y

double object_size_y() const

Definition calib.cpp:919

References object_size_y().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ refresh_setup()

void Slic3r::CalibPressureAdvancePattern::refresh_setup	(	const DynamicPrintConfig &	config,
		bool	is_bbl_machine,
		const ModelObject &	object,
		const Vec3d &	origin )

private

{
    m_config = config;
    m_config.apply(object.config.get(), true);
    m_config.apply(object.volumes.front()->config.get(), true);
 
    _refresh_starting_point(object);
    _refresh_writer(is_bbl_machine, object, origin);
}

References _refresh_starting_point(), _refresh_writer(), and Slic3r::CalibPressureAdvance::m_config.

Referenced by CalibPressureAdvancePattern(), and generate_custom_gcodes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_start_offset()

void Slic3r::CalibPressureAdvancePattern::set_start_offset ( const Vec3d & offset )

{
    m_starting_point = offset;
    m_is_start_point_fixed = true;
}

References m_is_start_point_fixed, m_starting_point, and Slic3r::offset().

Referenced by Slic3r::GUI::CalibUtils::calib_pa_pattern().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ speed_adjust()

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

inlineprotectedinherited

219{ return speed * 60; };

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

Here is the caller graph for this function:

◆ speed_first_layer()

double Slic3r::CalibPressureAdvancePattern::speed_first_layer ( ) const

inlineprotected

332{ return m_config.get_abs_value_at("initial_layer_speed", m_params.extruder_id); };

References Slic3r::CalibPressureAdvance::m_config, and m_params.

Referenced by generate_custom_gcodes().

Here is the caller graph for this function:

◆ speed_perimeter()

double Slic3r::CalibPressureAdvancePattern::speed_perimeter ( ) const

inlineprotected

333{ return m_config.get_abs_value_at("outer_wall_speed", m_params.extruder_id); };

References Slic3r::CalibPressureAdvance::m_config, and m_params.

Referenced by flow_val(), and generate_custom_gcodes().

Here is the caller graph for this function:

◆ to_radians()

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

inlineprotectedinherited

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

◆ wall_count()

int Slic3r::CalibPressureAdvancePattern::wall_count ( ) const

inlineprotected

337{ return m_config.option<ConfigOptionInt>("wall_loops")->value; };

References Slic3r::CalibPressureAdvance::m_config.

Referenced by generate_custom_gcodes(), glyph_start_x(), object_size_x(), and pattern_shift().

Here is the caller graph for this function:

◆ DrawBoxOptArgs

friend struct DrawBoxOptArgs

friend

References DrawBoxOptArgs.

Referenced by DrawBoxOptArgs, and generate_custom_gcodes().

Member Data Documentation

◆ m_config

DynamicPrintConfig Slic3r::CalibPressureAdvance::m_config

protectedinherited

◆ m_corner_angle

const int Slic3r::CalibPressureAdvancePattern::m_corner_angle {90}

private

385{90};

Referenced by _refresh_starting_point(), frame_size_y(), generate_custom_gcodes(), line_spacing_angle(), object_size_x(), and object_size_y().

◆ m_digit_gap_len

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

protectedinherited

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

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

250{DrawDigitMode::Left_To_Right};

Slic3r::CalibPressureAdvance::DrawDigitMode::Left_To_Right

@ Left_To_Right

Definition calib.hpp:213

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

protectedinherited

249{1. / 3.};

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

◆ m_glyph_padding_horizontal

const double Slic3r::CalibPressureAdvancePattern::m_glyph_padding_horizontal {1}

private

388{1};

Referenced by pattern_shift().

◆ m_glyph_padding_vertical

const double Slic3r::CalibPressureAdvancePattern::m_glyph_padding_vertical {1}

private

389{1};

Referenced by generate_custom_gcodes(), handle_pos_offset(), and object_size_y().

◆ m_handle_spacing

const double Slic3r::CalibPressureAdvancePattern::m_handle_spacing {1.2}

private

381{1.2};

Referenced by _refresh_starting_point(), and handle_spacing().

◆ m_handle_xy_size

const double Slic3r::CalibPressureAdvancePattern::m_handle_xy_size {5}

private

380{5};

Referenced by handle_xy_size().

◆ m_is_start_point_fixed

bool Slic3r::CalibPressureAdvancePattern::m_is_start_point_fixed = false

private

Referenced by _refresh_starting_point(), and set_start_offset().

◆ m_last_pos

Vec3d Slic3r::CalibPressureAdvance::m_last_pos

protectedinherited

Referenced by draw_line(), and move_to().

◆ m_max_number_len

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

protectedinherited

253{5};

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

◆ m_num_layers

const int Slic3r::CalibPressureAdvancePattern::m_num_layers {4}

private

382{4};

Referenced by generate_custom_gcodes(), and max_layer_z().

◆ m_number_len

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

protectedinherited

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

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

◆ m_params

const Calib_Params& Slic3r::CalibPressureAdvancePattern::m_params

private

Referenced by CalibPressureAdvancePattern(), accel_perimeter(), generate_custom_gcodes(), get_num_patterns(), line_width_first_layer(), max_numbering_length(), speed_first_layer(), and speed_perimeter().

◆ m_pattern_spacing

const int Slic3r::CalibPressureAdvancePattern::m_pattern_spacing {2}

private

386{2};

Referenced by generate_custom_gcodes(), glyph_start_x(), and object_size_x().

◆ m_starting_point

Vec3d Slic3r::CalibPressureAdvancePattern::m_starting_point

private

Referenced by _refresh_starting_point(), generate_custom_gcodes(), get_start_offset(), glyph_start_x(), glyph_tab_max_x(), and set_start_offset().

◆ m_wall_side_length

const double Slic3r::CalibPressureAdvancePattern::m_wall_side_length {30.0}

private

384{30.0};

Referenced by _refresh_starting_point(), frame_size_y(), generate_custom_gcodes(), object_size_x(), and object_size_y().

◆ m_writer

std::shared_ptr<GCodeWriter> Slic3r::CalibPressureAdvancePattern::m_writer {std::make_shared<GCodeWriter>()}

private

376{std::make_shared<GCodeWriter>()};

Referenced by _refresh_writer(), and 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

	OrcaSlicer latest OrcaSlicer

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ DrawDigitMode

Constructor & Destructor Documentation

◆ CalibPressureAdvancePattern()

Member Function Documentation

◆ _refresh_starting_point()

◆ _refresh_writer()

◆ accel_perimeter()

◆ convert_number_to_string()

◆ delta_scale_bed_ext()

◆ draw_box()

◆ draw_digit()

◆ draw_line()

◆ draw_number()

◆ e_per_mm()

◆ find_optimal_PA_speed()

◆ flow_val()

◆ frame_size_y()

◆ generate_custom_gcodes()

◆ get_distance()

◆ get_num_patterns()

◆ get_start_offset()

◆ glyph_length_x()

◆ glyph_start_x()

◆ glyph_tab_max_x()

◆ handle_pos_offset()

◆ handle_spacing()

◆ handle_xy_size()

◆ height_first_layer()

◆ height_layer()

◆ height_z_offset()

◆ line_spacing()

◆ line_spacing_angle()

◆ line_spacing_first_layer()

◆ line_width()

◆ line_width_first_layer()

◆ max_layer_z()

◆ max_numbering_height()

◆ max_numbering_length()

◆ move_to()

◆ number_spacing()

◆ object_size_x()

◆ object_size_y()

◆ pattern_shift()

◆ print_size_x()

◆ print_size_y()

◆ refresh_setup()

◆ set_start_offset()

◆ speed_adjust()

◆ speed_first_layer()

◆ speed_perimeter()

◆ to_radians()

◆ wall_count()

Friends And Related Symbol Documentation

◆ DrawBoxOptArgs

Member Data Documentation

◆ m_config

◆ m_corner_angle

◆ m_digit_gap_len

◆ m_digit_segment_len

◆ m_draw_digit_mode

◆ m_encroachment

◆ m_glyph_padding_horizontal

◆ m_glyph_padding_vertical

◆ m_handle_spacing

◆ m_handle_xy_size

◆ m_is_start_point_fixed

◆ m_last_pos

◆ m_max_number_len

◆ m_num_layers

◆ m_number_len