Slic3r::GCodeWriter Class Reference

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

Collaboration diagram for Slic3r::GCodeWriter:

Public Types
using	FirstLayerPointTest = std::function<bool(const Vec3d &point_logical)>

Public Member Functions
	GCodeWriter ()
Extruder *	filament (size_t extruder_id)
const Extruder *	filament (size_t extruder_id) const
Extruder *	filament ()
const Extruder *	filament () const
void	apply_print_config (const PrintConfig &print_config)
void	set_extruders (std::vector< unsigned int > extruder_ids)
const std::vector< Extruder > &	extruders () const
std::vector< unsigned int >	extruder_ids () const
std::string	preamble ()
std::string	postamble () const
std::string	set_temperature (unsigned int temperature, bool wait=false, int tool=-1) const
std::string	set_bed_temperature (int temperature, bool wait=false)
std::string	set_chamber_temperature (int temperature, bool wait=false)
std::string	set_print_acceleration (unsigned int acceleration)
std::string	set_travel_acceleration (unsigned int acceleration)
std::string	set_jerk_xy (double jerk)
std::string	set_accel_and_jerk (unsigned int acceleration, double jerk)
std::string	set_junction_deviation (double junction_deviation)
std::string	set_pressure_advance (double pa, int tool=-1) const
std::string	set_input_shaping (char axis, float damp, float freq, std::string type) const
std::string	reset_e (bool force=false)
std::string	update_progress (unsigned int num, unsigned int tot, bool allow_100=false) const
std::string	enable_power_loss_recovery (PowerLossRecoveryMode mode)
bool	need_toolchange (unsigned int filament_id) const
std::string	set_extruder (unsigned int filament_id)
void	init_extruder (unsigned int filament_id)
double	get_extruder_retracted_length (const int filament_id)
std::string	toolchange_prefix () const
std::string	toolchange (unsigned int filament_id, int nozzle_id)
std::string	set_speed (double F, const std::string &comment=std::string(), const std::string &cooling_marker=std::string())
double	get_current_speed () const
std::string	travel_to_xy (const Vec2d &point, const std::string &comment=std::string())
std::string	travel_to_xyz (const Vec3d &point, const std::string &comment=std::string(), bool force_z=false)
std::pair< double, double >	planned_travel_z (const Vec3d &point, bool force_z=false) const
std::string	travel_to_z (double z, const std::string &comment=std::string(), bool force=false)
bool	will_move_z (double z) const
std::string	extrude_to_xy (const Vec2d &point, double dE, const std::string &comment=std::string(), bool force_no_extrusion=false)
std::string	extrude_arc_to_xy (const Vec2d &point, const Vec2d &center_offset, double dE, const bool is_ccw, const std::string &comment=std::string(), bool force_no_extrusion=false)
void	extrude_arc_as_polyline (std::string &out, const Vec2d &point, const Vec2d &center_offset, double dE, const bool is_ccw, const std::string &comment=std::string(), bool force_no_extrusion=false)
std::string	extrude_to_xyz (const Vec3d &point, double dE, const std::string &comment=std::string(), bool force_no_extrusion=false)
void	set_speed (std::string &out, double F, const std::string &comment=std::string(), const std::string &cooling_marker=std::string())
void	extrude_to_xy (std::string &out, const Vec2d &point, double dE, const std::string &comment=std::string(), bool force_no_extrusion=false)
void	extrude_arc_to_xy (std::string &out, const Vec2d &point, const Vec2d &center_offset, double dE, const bool is_ccw, const std::string &comment=std::string(), bool force_no_extrusion=false)
void	extrude_to_xyz (std::string &out, const Vec3d &point, double dE, const std::string &comment=std::string(), bool force_no_extrusion=false)
std::string	retract (bool before_wipe=false, double retract_length=0)
std::string	retract_for_toolchange (bool before_wipe=false, double retract_length=0)
std::string	unretract (float extra_retract=0.f)
std::string	eager_lift (const LiftType type)
std::string	lazy_lift (LiftType lift_type=LiftType::NormalLift, bool spiral_vase=false)
std::string	unlift ()
const Vec3d &	get_position () const
Vec3d &	get_position ()
void	set_position (const Vec3d &in)
double	get_zhop () const
void	set_xy_offset (double x, double y)
Vec2f	get_xy_offset ()
std::string	set_fan (unsigned int speed) const
void	set_object_start_str (std::string start_string)
bool	is_object_start_str_empty ()
void	set_object_end_str (std::string end_string)
bool	is_object_end_str_empty ()
void	add_object_start_labels (std::string &gcode)
void	add_object_end_labels (std::string &gcode)
void	add_object_change_labels (std::string &gcode)
void	set_current_position_clear (bool clear)
bool	is_current_position_clear () const
void	set_is_bbl_machine (bool bval)
const bool	is_bbl_printers () const
void	set_is_first_layer (bool bval)
GCodeFlavor	get_gcode_flavor () const
void	invalidate_acceleration ()
void	invalidate_jerk ()
void	set_axis_remap (int rx, int ry, int rz)
void	set_build_volume_max (const Vec3d &max)
bool	has_axis_remap () const
void	set_kinematics (std::unique_ptr< MachineKinematics > kinematics)
const MachineKinematics &	kinematics () const
void	set_first_layer_point_test (FirstLayerPointTest test)
void	set_force_normal_lift (bool force)
bool	high_precision () const
bool	force_standard_precision (bool force)

Static Public Member Functions
static std::string	set_temperature (unsigned int temperature, GCodeFlavor flavor, bool wait=false, int tool=-1, std::string comment=std::string())
static void	append_klipper_accel_to_decel (std::string &gcode, unsigned int acceleration, double accel_to_decel_factor)
static std::string	set_fan (const GCodeFlavor gcode_flavor, unsigned int speed, unsigned int part_cooling_fan_min_pwm=0)
static std::string	set_additional_fan (unsigned int speed)
static std::string	set_exhaust_fan (int speed)
static bool	supports_separate_travel_acceleration (GCodeFlavor flavor)

Public Attributes
GCodeConfig	config
bool	multiple_extruders

Static Public Attributes
static bool	full_gcode_comment = true

Protected Member Functions
std::string	_travel_to_z (double z, const std::string &comment)
bool	point_on_first_layer (const Vec3d &point_logical) const
bool	must_skip_lift_now () const
bool	uses_pointwise_travel_speed () const
Vec3d	apply_axis_remap (const Vec3d &pos) const

Protected Attributes
Vec3d	m_pos = Vec3d::Zero()
double	m_x_offset { 0 }
double	m_y_offset { 0 }
double	m_lifted
double	m_to_lift
LiftType	m_to_lift_type
bool	m_is_first_layer = true
bool	m_is_current_pos_clear = false
double	m_current_speed
FirstLayerPointTest	m_first_layer_point_test
bool	m_force_normal_lift = false
bool	m_force_standard_precision = false
std::unique_ptr< MachineKinematics >	m_kinematics
int	m_remap_x = 0
int	m_remap_y = 1
int	m_remap_z = 2
Vec3d	m_build_vol_max = Vec3d::Zero()
size_t	m_cached_extruder_idx

Private Types
enum class	Acceleration { Travel , Print }

Private Member Functions
std::string	_spiral_travel_to_z (double z, const Vec2d &ij_offset, const std::string &comment)
const Polygon *	active_printable_area () const
bool	spiral_lift_fits_printable_area (const Vec2d &center, double radius) const
std::string	_retract (double length, double restart_extra, const std::string &comment)
std::string	set_acceleration_internal (Acceleration type, unsigned int acceleration)

Private Attributes
std::vector< Extruder >	m_filament_extruders
bool	m_single_extruder_multi_material
std::vector< Extruder * >	m_curr_filament_extruder
int	m_curr_extruder_id
unsigned int	m_last_acceleration
unsigned int	m_last_travel_acceleration
std::vector< unsigned int >	m_max_travel_acceleration
std::vector< unsigned int >	m_max_acceleration
std::vector< double >	m_max_jerk_x
std::vector< double >	m_max_jerk_y
double	m_last_jerk
std::vector< double >	m_max_jerk_z
std::vector< double >	m_max_jerk_e
std::vector< double >	m_max_junction_deviation
int	m_last_bed_temperature
bool	m_last_bed_temperature_reached
double	m_resolution = 0.01
Polygon	m_bed_printable_area
std::vector< Polygon >	m_extruder_printable_areas
std::string	m_gcode_label_objects_start
std::string	m_gcode_label_objects_end
bool	m_is_bbl_printers = false

Detailed Description

Member Typedef Documentation

FirstLayerPointTest

using Slic3r::GCodeWriter::FirstLayerPointTest = std::function<bool(const Vec3d &point_logical)>

Member Enumeration Documentation

Acceleration

enum class Slic3r::GCodeWriter::Acceleration

strongprivate

Enumerator
Travel
Print

                            {
        Travel,
        Print
    };

Constructor & Destructor Documentation

GCodeWriter()

Slic3r::GCodeWriter::GCodeWriter ( )

inline

                  :
        multiple_extruders(false),
        m_lifted(0),
        m_to_lift(0),
        m_to_lift_type(LiftType::NormalLift),
        m_is_first_layer(true), m_current_speed(3600),
        m_kinematics(std::make_unique<CartesianKinematics>()),
        m_cached_extruder_idx(0),
        m_curr_filament_extruder(MAXIMUM_EXTRUDER_NUMBER, nullptr),
        m_curr_extruder_id (-1),
        m_single_extruder_multi_material(false),
        m_last_acceleration(0), m_max_acceleration(0),m_last_travel_acceleration(0), m_max_travel_acceleration(0),
        m_last_jerk(0), m_max_jerk_x(0), m_max_jerk_y(0),
        m_last_bed_temperature(0), m_last_bed_temperature_reached(true)
        {}

References m_cached_extruder_idx, m_curr_extruder_id, m_curr_filament_extruder, m_current_speed, m_is_first_layer, m_kinematics, m_last_acceleration, m_last_bed_temperature, m_last_bed_temperature_reached, m_last_jerk, m_last_travel_acceleration, m_lifted, m_max_acceleration, m_max_jerk_x, m_max_jerk_y, m_max_travel_acceleration, m_single_extruder_multi_material, m_to_lift, m_to_lift_type, Slic3r::make_unique(), MAXIMUM_EXTRUDER_NUMBER, multiple_extruders, and Slic3r::NormalLift.

Here is the call graph for this function:

Member Function Documentation

_retract()

std::string Slic3r::GCodeWriter::_retract ( double length, double restart_extra, const std::string & comment )

private

{
    /*  If firmware retraction is enabled, we use a fake value of 1
    since we ignore the actual configured retract_length which
    might be 0, in which case the retraction logic gets skipped. */
    if (this->config.use_firmware_retraction)
        length = 1;
 
    std::string gcode;
    if (double dE = filament()->retract(length, restart_extra);  !is_zero(dE)) {
        if (this->config.use_firmware_retraction) {
            gcode = FLAVOR_IS(gcfMachinekit) ? "G22 ; retract\n" : "G10 ; retract\n";
        }
        else {
            // BBS
            const bool high_precision = this->high_precision();
            GCodeG1Formatter w(high_precision);
            w.emit_e(filament()->E_to_emit(high_precision));
            w.emit_f(filament()->retract_speed() * 60.);
            // BBS
            w.emit_comment(GCodeWriter::full_gcode_comment, comment);
            gcode = w.string();
        }
    }
 
    if (FLAVOR_IS(gcfMakerWare))
        gcode += "M103 ; extruder off\n";
 
    return gcode;
}

References config, Slic3r::GCodeFormatter::emit_comment(), Slic3r::GCodeFormatter::emit_e(), Slic3r::GCodeFormatter::emit_f(), filament(), FLAVOR_IS, full_gcode_comment, Slic3r::gcfMachinekit, Slic3r::gcfMakerWare, high_precision(), Slic3r::is_zero(), Slic3r::length(), retract(), and Slic3r::GCodeFormatter::string().

Referenced by retract(), and retract_for_toolchange().

Here is the call graph for this function:

Here is the caller graph for this function:

_spiral_travel_to_z()

std::string Slic3r::GCodeWriter::_spiral_travel_to_z ( double z, const Vec2d & ij_offset, const std::string & comment )

private

{
    // A circular XY arc / spiral lift cannot be correctly axis-remapped by
    // transforming only its endpoint: the arc plane (G17/XY) and the I-J center
    // would change under the remap. When an axis remap is active, fall back to a
    // plain linear lift instead of emitting a possibly-wrong spiral/arc. This
    // single guard covers every spiral call site (lazy/eager lift and travel_to_xyz).
    if (has_axis_remap())
        return _travel_to_z(z, comment);
 
    std::string output;
    double speed = this->config.travel_speed_z.get_at(m_cached_extruder_idx);
 
    if (speed == 0.) {
        speed = m_is_first_layer ? this->config.get_abs_value_at("initial_layer_travel_speed", m_cached_extruder_idx)
                                 : this->config.travel_speed.get_at(m_cached_extruder_idx);
    }
 
    if (this->config.enable_arc_fitting.value == ArcFittingMode::Disabled) { // Orca: if arc fitting is disabled, approximate the arc with small linear segments
        const double z_start = m_pos(2); // starting Z height
 
        const double px = m_pos(0) - m_x_offset;        // take plate offset into consideration
        const double py = m_pos(1) - m_y_offset;        // take plate offset into consideration
        const double cx = px + ij_offset(0);            // center x
        const double cy = py + ij_offset(1);            // center y
        const double radius = ij_offset.norm();         // radius
 
        // Number of linear segments approximating the circle, chosen so that a chord never deviates
        // from the true arc by more than the slicing resolution. A resolution of 0 means "no
        // simplification", which has no finite segment count, so it takes the upper bound.
        constexpr size_t min_segments = 8;              // keep a small spiral visibly round
        constexpr size_t max_segments = 128;            // bound the emitted G-code
        const int segments = int(m_resolution > 0. ?
            std::clamp(Geometry::ArcWelder::arc_discretization_steps(radius, 2. * M_PI, m_resolution), min_segments, max_segments) :
            max_segments);
 
        const double a0 = std::atan2(py - cy, px - cx); // start angle
 
        auto emit_point = [this, &output](const Vec3d &point) {
            GCodeG1Formatter w(config.high_precision_gcode.value);
            w.emit_xyz(point);
            output += w.string();
        };
 
        output.reserve(size_t(segments) * 40);          // ~40 characters per emitted G1 line
 
        // set feedrate
        GCodeG1Formatter w(config.high_precision_gcode.value);
        w.emit_f(speed * 60.0);
        w.emit_comment(GCodeWriter::full_gcode_comment, comment);
        output += w.string();
 
        // approximate the arc with small linear segments (without the last point which is added later to ensure exactness)
        for (int i = 1; i < segments; ++i) {
            const double t = double(i) / segments;      // parametric position along arc
            const double a = a0 + 2. * M_PI * t;        // CCW arc param, full circle
            emit_point(Vec3d(cx + radius * std::cos(a), // point on circle
                             cy + radius * std::sin(a),
                             z_start + (z - z_start) * t)); // interpolated Z height
        }
 
        emit_point(Vec3d(px, py, z));                   // final point to ensure exactness
    } else { // Orca: if arc fitting is enabled emit a G2/G3 command for the spiral lift
        output = std::string("G17") + (full_gcode_comment ? " ; XY plane for arc\n" : "\n");
 
        GCodeG2G3Formatter w(true, config.high_precision_gcode.value);
        w.emit_z(z);
        w.emit_ij(ij_offset);
        w.emit_string(" P1 ");
        w.emit_f(speed * 60.0);
        w.emit_comment(GCodeWriter::full_gcode_comment, comment);
 
        output += w.string();
    }
 
    m_pos(2) = z;
    return output;
}

References _travel_to_z(), Slic3r::Geometry::ArcWelder::arc_discretization_steps(), config, Slic3r::Disabled, Slic3r::GCodeFormatter::emit_comment(), Slic3r::GCodeFormatter::emit_f(), Slic3r::GCodeFormatter::emit_ij(), Slic3r::GCodeFormatter::emit_string(), Slic3r::GCodeFormatter::emit_xyz(), Slic3r::GCodeFormatter::emit_z(), full_gcode_comment, has_axis_remap(), m_cached_extruder_idx, m_is_first_layer, M_PI, m_pos, m_resolution, m_x_offset, m_y_offset, and Slic3r::GCodeFormatter::string().

Referenced by eager_lift(), and travel_to_xyz().

Here is the call graph for this function:

Here is the caller graph for this function:

_travel_to_z()

std::string Slic3r::GCodeWriter::_travel_to_z ( double z, const std::string & comment )

protected

{
    m_pos(2) = z;
 
    double speed = this->config.travel_speed_z.get_at(m_cached_extruder_idx);
    if (speed == 0.) {
        speed = this->point_on_first_layer(Vec3d(m_pos.x() - m_x_offset, m_pos.y() - m_y_offset, z))
                    ? this->config.get_abs_value_at("initial_layer_travel_speed", m_cached_extruder_idx)
                    : this->config.travel_speed.get_at(m_cached_extruder_idx);
    }
 
    GCodeG1Formatter w(config.high_precision_gcode.value);
    if (has_axis_remap()) {
        // Remap may couple Z with other axes; emit full XYZ.
        Vec3d machine = apply_axis_remap(Vec3d(m_pos.x() - m_x_offset, m_pos.y() - m_y_offset, z));
        w.emit_xyz(machine);
    } else {
        w.emit_z(z);
    }
    w.emit_f(speed * 60.0);
    //BBS
    w.emit_comment(GCodeWriter::full_gcode_comment, comment);
    return w.string();
}

References apply_axis_remap(), config, Slic3r::GCodeFormatter::emit_comment(), Slic3r::GCodeFormatter::emit_f(), Slic3r::GCodeFormatter::emit_xyz(), Slic3r::GCodeFormatter::emit_z(), full_gcode_comment, has_axis_remap(), m_cached_extruder_idx, m_pos, m_x_offset, m_y_offset, point_on_first_layer(), and Slic3r::GCodeFormatter::string().

Referenced by _spiral_travel_to_z(), eager_lift(), lazy_lift(), travel_to_xyz(), travel_to_z(), and unlift().

Here is the call graph for this function:

Here is the caller graph for this function:

active_printable_area()

const Polygon * Slic3r::GCodeWriter::active_printable_area ( ) const

private

{
    if (const Extruder *e = this->filament()) {
        size_t id = e->extruder_id();
        if (id < m_extruder_printable_areas.size() && m_extruder_printable_areas[id].points.size() >= 3)
            return &m_extruder_printable_areas[id];
    }
    if (m_bed_printable_area.points.size() >= 3)
        return &m_bed_printable_area;
    return nullptr;
}

References filament(), m_bed_printable_area, and m_extruder_printable_areas.

Referenced by spiral_lift_fits_printable_area().

Here is the call graph for this function:

Here is the caller graph for this function:

add_object_change_labels()

void Slic3r::GCodeWriter::add_object_change_labels

(

std::string &

gcode

)

{
    add_object_end_labels(gcode);
    add_object_start_labels(gcode);
}

References add_object_end_labels(), and add_object_start_labels().

Here is the call graph for this function:

add_object_end_labels()

void Slic3r::GCodeWriter::add_object_end_labels

(

std::string &

gcode

)

{
    if (!m_gcode_label_objects_end.empty()) {
        gcode += m_gcode_label_objects_end;
        m_gcode_label_objects_end = "";
 
        // Orca: reset E so that e value remain correct after skipping the object
        // ref to: https://github.com/OrcaSlicer/OrcaSlicer/pull/205/commits/7f1fe0bd544077626080aa1a9a0576aa735da1a4#r1083470162
        if (!this->config.use_relative_e_distances)
            gcode += reset_e(true);
    }
}

References config, m_gcode_label_objects_end, and reset_e().

Referenced by add_object_change_labels(), and Slic3r::WipeTowerIntegration::append_tcr().

Here is the call graph for this function:

Here is the caller graph for this function:

add_object_start_labels()

void Slic3r::GCodeWriter::add_object_start_labels

(

std::string &

gcode

)

{
    if (!m_gcode_label_objects_start.empty()) {
        gcode += m_gcode_label_objects_start;
        m_gcode_label_objects_start = "";
    }
}

References m_gcode_label_objects_start.

Referenced by add_object_change_labels().

Here is the caller graph for this function:

append_klipper_accel_to_decel()

void Slic3r::GCodeWriter::append_klipper_accel_to_decel ( std::string & gcode, unsigned int acceleration, double accel_to_decel_factor )

static

{
    gcode += " ACCEL_TO_DECEL=";
    gcode += float_to_string_decimal_point(acceleration * accel_to_decel_factor / 100);
    gcode += " MINIMUM_CRUISE_RATIO=";
    gcode += float_to_string_decimal_point(1. - accel_to_decel_factor / 100);
}

References Slic3r::float_to_string_decimal_point().

Referenced by set_accel_and_jerk(), Slic3r::WipeTowerWriter::set_acceleration_impl(), and set_acceleration_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_axis_remap()

Vec3d Slic3r::GCodeWriter::apply_axis_remap ( const Vec3d & pos ) const

protected

{
    return m_kinematics->to_machine(pos);
}

References m_kinematics.

Referenced by _travel_to_z(), extrude_to_xy(), extrude_to_xyz(), travel_to_xy(), and travel_to_xyz().

Here is the caller graph for this function:

apply_print_config()

void Slic3r::GCodeWriter::apply_print_config

(

const PrintConfig &

print_config

)

{
    this->config.apply(print_config, true);
 
    // Some machine limits are stride-2 (normal, silent) pairs, here we extract the value that will be used,
    // which is always normal mode at the moment
    // TODO: support silent? Any printer actually have that?
    auto get_machine_limits = [](const std::string key, const ConfigOptionFloats& opt) -> std::vector<double> {
        unsigned int stride = 1;
        unsigned int offset = 0;
        if (printer_options_with_variant_2.count(key) > 0) {
            stride = 2;
            // offset = <TODO: current print mode>;
        }
 
        std::vector<double> results;
        results.reserve(opt.values.size() / stride);
 
        for (unsigned int i = offset; i < opt.values.size(); i += stride) {
            results.emplace_back(opt.values[i]);
        }
 
        return results;
    };
    auto rounded = [](std::vector<double>&& vec) -> std::vector<double>&&{
        std::transform(vec.cbegin(), vec.cend(), vec.begin(), [](const double v) { return std::round(v); });
        return std::move(vec);
    };
    auto to_uint = [](const std::vector<double>& vec) {
        std::vector<unsigned int> r;
        std::transform(vec.begin(), vec.end(), std::back_inserter(r), [](const double v) { return static_cast<unsigned int>(v); });
        return r;
    };
#define LIMITS(OPT) get_machine_limits(#OPT, print_config.OPT)
#define LIMITS_UINT(OPT) to_uint(rounded(LIMITS(OPT)))
 
    m_single_extruder_multi_material = print_config.single_extruder_multi_material.value;
    bool use_mach_limits = print_config.gcode_flavor.value == gcfMarlinLegacy || print_config.gcode_flavor.value == gcfMarlinFirmware ||
                           print_config.gcode_flavor.value == gcfKlipper || print_config.gcode_flavor.value == gcfRepRapFirmware;
    if (use_mach_limits) {
        // For Klipper, SET_VELOCITY_LIMIT ACCEL= applies to all moves, so the effective cap
        // is the minimum of the extruding limit and the per-axis X/Y limits.
        // This ensures user-configured Motion Ability limits are honoured (#12244).
        auto extruding_limit = LIMITS_UINT(machine_max_acceleration_extruding);
        if (print_config.gcode_flavor.value == gcfKlipper) {
            auto x_limit = LIMITS_UINT(machine_max_acceleration_x);
            auto y_limit = LIMITS_UINT(machine_max_acceleration_y);
 
            for (size_t i = 0; i < extruding_limit.size(); i++) {
                if (x_limit[i] > 0) extruding_limit[i] = std::min(extruding_limit[i], x_limit[i]);
                if (y_limit[i] > 0) extruding_limit[i] = std::min(extruding_limit[i], y_limit[i]);
            }
        }
        m_max_acceleration = std::move(extruding_limit);
    } else {
        m_max_acceleration.clear();
    }
    if (use_mach_limits && supports_separate_travel_acceleration(print_config.gcode_flavor.value)) {
        m_max_travel_acceleration = LIMITS_UINT(machine_max_acceleration_travel);
    } else {
        m_max_travel_acceleration.clear();
    }
    if (use_mach_limits) {
        m_max_jerk_x             = rounded(LIMITS(machine_max_jerk_x));
        m_max_jerk_y             = rounded(LIMITS(machine_max_jerk_y));
        m_max_junction_deviation = LIMITS(machine_max_junction_deviation);
    } else {
        m_max_jerk_x.clear();
        m_max_jerk_y.clear();
        m_max_junction_deviation.clear();
    }
    m_max_jerk_z = LIMITS(machine_max_jerk_z);
    m_max_jerk_e = LIMITS(machine_max_jerk_e);
    m_resolution = print_config.resolution.value;
#undef LIMITS
#undef LIMITS_UINT
    // Orca: capture the printable area(s) so a spiral lift can be skipped when its
    // circle would leave the boundary and collide with the print limits. Full polygons
    // are stored (not a bounding box) so the check stays correct for non-rectangular
    // beds, and per-extruder areas are kept so printers with different boundaries per
    // extruder use the right limit for whichever extruder is active.
    auto to_scaled_polygon = [](const Pointfs &pts) {
        Polygon poly;
        poly.points.reserve(pts.size());
        for (const Vec2d &p : pts)
            poly.points.emplace_back(coord_t(scale_(p.x())), coord_t(scale_(p.y())));
        poly.make_counter_clockwise();
        return poly;
    };
 
    m_bed_printable_area.points.clear();
    m_extruder_printable_areas.clear();
 
    if (print_config.printable_area.values.size() >= 3)
        m_bed_printable_area = to_scaled_polygon(print_config.printable_area.values);
 
    const std::vector<Pointfs> &extruder_areas = print_config.extruder_printable_area.values;
    if (!extruder_areas.empty()) {
        m_extruder_printable_areas.resize(extruder_areas.size());
        for (size_t i = 0; i < extruder_areas.size(); ++i) {
            if (extruder_areas[i].size() < 3) {
                // No dedicated area for this extruder: it can reach the whole bed.
                m_extruder_printable_areas[i] = m_bed_printable_area;
                continue;
            }
            Polygon extruder_poly = to_scaled_polygon(extruder_areas[i]);
            if (m_bed_printable_area.points.size() < 3) {
                m_extruder_printable_areas[i] = std::move(extruder_poly);
                continue;
            }
            // The reachable area is the extruder area clipped to the bed. Bed shapes are
            // convex in practice, so keep the largest resulting contour.
            Polygons clipped = intersection(extruder_poly, m_bed_printable_area);
            const Polygon *largest = nullptr;
            double          best_area = 0.;
            for (const Polygon &p : clipped) {
                double a = std::abs(p.area());
                if (a > best_area) { best_area = a; largest = &p; }
            }
            m_extruder_printable_areas[i] = largest ? *largest : std::move(extruder_poly);
        }
    }
}

References config, Slic3r::gcfKlipper, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepRapFirmware, Slic3r::intersection(), LIMITS, LIMITS_UINT, m_bed_printable_area, m_extruder_printable_areas, m_max_acceleration, m_max_jerk_e, m_max_jerk_x, m_max_jerk_y, m_max_jerk_z, m_max_junction_deviation, m_max_travel_acceleration, m_resolution, m_single_extruder_multi_material, Slic3r::offset(), Slic3r::printer_options_with_variant_2, scale_, and supports_separate_travel_acceleration().

Here is the call graph for this function:

eager_lift()

std::string Slic3r::GCodeWriter::eager_lift

(

const LiftType

type

)

                                                     {
    const LiftType effective_type = m_force_normal_lift ? LiftType::NormalLift : type;
    std::string lift_move;
    double target_lift = 0;
    {
        //BBS
        int extruder_id = filament()->extruder_id();
        int filament_id = filament()->id();
        double above = this->config.retract_lift_above.get_at(extruder_id);
        double below = this->config.retract_lift_below.get_at(extruder_id);
        if (m_pos.z() >= above && (m_pos.z() <= below || below == 0.))
            target_lift = this->config.z_hop.get_at(filament_id);
    }
 
    // BBS: spiral lift only safe with known position
    if (effective_type == LiftType::SpiralLift && this->is_current_position_clear()) {
        double radius = target_lift / (2 * PI * atan(filament()->travel_slope()));
        // static spiral alignment when no move in x,y plane.
        // spiral centra is a radius distance to the right (y=0)
        Vec2d ij_offset = { radius, 0 };
        // Orca: keep the spiral inside the active extruder's printable area, otherwise
        // fall back to a normal lift to avoid colliding with the print boundary. m_pos
        // includes the plate offset, so remove it to match the printable area coordinates.
        const Vec2d spiral_center = { m_pos.x() - m_x_offset + ij_offset.x(), m_pos.y() - m_y_offset + ij_offset.y() };
        if (target_lift > 0 && this->spiral_lift_fits_printable_area(spiral_center, radius)) {
            lift_move = this->_spiral_travel_to_z(m_pos(2) + target_lift, ij_offset, "spiral lift Z");
        } else if (target_lift > 0) {
            lift_move = _travel_to_z(m_pos(2) + target_lift, "normal lift Z");
        }
    }
    //BBS: if position is unknown use normal lift
    else if (target_lift > 0) {
        if (this->must_skip_lift_now())
            // Skipped, not deferred: leave m_lifted at zero below so unlift()
            // does not descend from a height that was never commanded.
            target_lift = 0.;
        else
            lift_move = _travel_to_z(m_pos(2) + target_lift, "normal lift Z");
    }
    m_lifted = target_lift;
    m_to_lift = 0;
    return lift_move;
}

References _spiral_travel_to_z(), _travel_to_z(), config, Slic3r::Extruder::extruder_id(), filament(), Slic3r::Extruder::id(), is_current_position_clear(), m_force_normal_lift, m_lifted, m_pos, m_to_lift, m_x_offset, m_y_offset, must_skip_lift_now(), Slic3r::NormalLift, PI, spiral_lift_fits_printable_area(), Slic3r::SpiralLift, and Slic3r::travel_slope().

Here is the call graph for this function:

enable_power_loss_recovery()

std::string Slic3r::GCodeWriter::enable_power_loss_recovery

(

PowerLossRecoveryMode

mode

)

{
    std::ostringstream gcode;
 
    if (mode == PowerLossRecoveryMode::PrinterConfiguration)
        return std::string();
 
    const bool enable = mode == PowerLossRecoveryMode::Enable;
 
    if (m_is_bbl_printers) {
        gcode << "M1003 S" << (enable ? "1" : "0");
    }
    else if (FLAVOR_IS(gcfMarlinFirmware)) {
        gcode << "M413 S" << (enable ? "1" : "0");
    } else {
        return std::string();
    }
    if (GCodeWriter::full_gcode_comment) gcode << " ; set Power-loss Recovery";
    gcode << "\n";
    return gcode.str();
}

References Slic3r::Enable, FLAVOR_IS, full_gcode_comment, Slic3r::gcfMarlinFirmware, m_is_bbl_printers, and Slic3r::PrinterConfiguration.

extrude_arc_as_polyline()

void Slic3r::GCodeWriter::extrude_arc_as_polyline	(	std::string &	out,
		const Vec2d &	point,
		const Vec2d &	center_offset,
		double	dE,
		const bool	is_ccw,
		const std::string &	comment = std::string(),
		bool	force_no_extrusion = false )

{
    const Vec2d start  = Vec2d(m_pos.x(), m_pos.y());
    const Vec2d centre = start + center_offset;
    const double r     = (start - centre).norm();
    if (r < EPSILON) {
        // Degenerate: no arc to speak of, so a single move is exact.
        this->extrude_to_xy(out, point, dE, comment, force_no_extrusion);
        return;
    }
 
    double a0 = std::atan2(start.y() - centre.y(), start.x() - centre.x());
    double a1 = std::atan2(point.y() - centre.y(), point.x() - centre.x());
    double sweep = a1 - a0;
    if (is_ccw) { while (sweep <= 0.) sweep += 2. * PI; }
    else        { while (sweep >= 0.) sweep -= 2. * PI; }
 
    // Segment count from a chord-deviation bound: r*(1-cos(dtheta/2)) <= tol.
    const double tol  = 0.005;                       // mm
    const double dmax = (tol >= r) ? PI : 2. * std::acos(1. - tol / r);
    const int    n    = std::max(2, int(std::ceil(std::abs(sweep) / std::max(dmax, EPSILON))));
 
    for (int i = 1; i <= n; ++ i) {
        const double a = a0 + sweep * (double(i) / double(n));
        const Vec2d  p = (i == n) ? point
                                  : Vec2d(centre.x() + r * std::cos(a), centre.y() + r * std::sin(a));
        this->extrude_to_xy(out, p, dE / double(n), i == n ? comment : std::string(), force_no_extrusion);
    }
}

References EPSILON, extrude_to_xy(), Slic3r::Geometry::is_ccw(), m_pos, and PI.

Referenced by extrude_arc_to_xy().

Here is the call graph for this function:

Here is the caller graph for this function:

extrude_arc_to_xy() [1/2]

std::string Slic3r::GCodeWriter::extrude_arc_to_xy	(	const Vec2d &	point,
		const Vec2d &	center_offset,
		double	dE,
		const bool	is_ccw,
		const std::string &	comment = std::string(),
		bool	force_no_extrusion = false )

{
    std::string gcode;
    this->extrude_arc_to_xy(gcode, point, center_offset, dE, is_ccw, comment, force_no_extrusion);
    return gcode;
}

References extrude_arc_to_xy(), and Slic3r::Geometry::is_ccw().

Referenced by extrude_arc_to_xy().

Here is the call graph for this function:

Here is the caller graph for this function:

extrude_arc_to_xy() [2/2]

void Slic3r::GCodeWriter::extrude_arc_to_xy	(	std::string &	out,
		const Vec2d &	point,
		const Vec2d &	center_offset,
		double	dE,
		const bool	is_ccw,
		const std::string &	comment = std::string(),
		bool	force_no_extrusion = false )

{
    // Arcs emit only X/Y/I/J, so a mapping that moves logical X or Y cannot be
    // expressed as a G2/G3. GCode::should_disable_arc_fitting() normally stops
    // arcs being generated at all for such a mapping, but this is public API, so
    // define the behaviour rather than asserting.
    //
    // This check MUST precede every state mutation below: falling through to
    // extrude_to_xy() after filament()->extrude(dE) would advance E twice.
    //
    // A single chord is not a safe substitute either -- a semicircle would become
    // its diameter and a full circle a stationary blob -- so approximate the arc
    // with linear segments bounded by a chord tolerance, splitting dE between
    // them in proportion to arc length.
    if (! m_kinematics->supports_arc_moves()) {
        this->extrude_arc_as_polyline(out, point, center_offset, dE, is_ccw, comment, force_no_extrusion);
        return;
    }
 
    m_pos(0) = point(0);
    m_pos(1) = point(1);
    if (!force_no_extrusion)
        filament()->extrude(dE);
 
    Vec2d point_on_plate = { point(0) - m_x_offset, point(1) - m_y_offset };
 
    const bool high_precision = this->high_precision();
    GCodeG2G3Formatter w(is_ccw, high_precision);
    w.emit_xy(point_on_plate);
    w.emit_ij(center_offset);
    if (!force_no_extrusion)
        w.emit_e(filament()->E_to_emit(high_precision));
    //BBS
    w.emit_comment(GCodeWriter::full_gcode_comment, comment);
    w.append_to(out);
}

References Slic3r::GCodeFormatter::append_to(), Slic3r::GCodeFormatter::emit_comment(), Slic3r::GCodeFormatter::emit_e(), Slic3r::GCodeFormatter::emit_ij(), Slic3r::GCodeFormatter::emit_xy(), Slic3r::Extruder::extrude(), extrude_arc_as_polyline(), filament(), full_gcode_comment, high_precision(), Slic3r::Geometry::is_ccw(), m_kinematics, m_pos, m_x_offset, and m_y_offset.

Here is the call graph for this function:

extrude_to_xy() [1/2]

std::string Slic3r::GCodeWriter::extrude_to_xy	(	const Vec2d &	point,
		double	dE,
		const std::string &	comment = std::string(),
		bool	force_no_extrusion = false )

{
    std::string gcode;
    this->extrude_to_xy(gcode, point, dE, comment, force_no_extrusion);
    return gcode;
}

References extrude_to_xy().

Referenced by Slic3r::CalibPressureAdvance::draw_digit(), Slic3r::CalibPressureAdvance::draw_line(), extrude_arc_as_polyline(), extrude_to_xy(), and Slic3r::Wipe::wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

extrude_to_xy() [2/2]

void Slic3r::GCodeWriter::extrude_to_xy	(	std::string &	out,
		const Vec2d &	point,
		double	dE,
		const std::string &	comment = std::string(),
		bool	force_no_extrusion = false )

{
    m_pos(0) = point(0);
    m_pos(1) = point(1);
    if(std::abs(dE) <= std::numeric_limits<double>::epsilon())
        force_no_extrusion = true;
 
    if (!force_no_extrusion)
        filament()->extrude(dE);
 
    //BBS: take plate offset into consider
    Vec2d point_on_plate = { point(0) - m_x_offset, point(1) - m_y_offset };
 
    const bool high_precision = this->high_precision();
    GCodeG1Formatter w(high_precision);
    if (has_axis_remap()) {
        Vec3d machine = apply_axis_remap(Vec3d(point_on_plate.x(), point_on_plate.y(), m_pos.z()));
        w.emit_xyz(machine);
    } else {
        w.emit_xy(point_on_plate);
    }
    if (!force_no_extrusion)
        w.emit_e(filament()->E_to_emit(high_precision));
    //BBS
    w.emit_comment(GCodeWriter::full_gcode_comment, comment);
    w.append_to(out);
}

References Slic3r::GCodeFormatter::append_to(), apply_axis_remap(), Slic3r::GCodeFormatter::emit_comment(), Slic3r::GCodeFormatter::emit_e(), Slic3r::GCodeFormatter::emit_xy(), Slic3r::GCodeFormatter::emit_xyz(), Slic3r::Extruder::extrude(), filament(), full_gcode_comment, has_axis_remap(), high_precision(), m_pos, m_x_offset, and m_y_offset.

Here is the call graph for this function:

extrude_to_xyz() [1/2]

std::string Slic3r::GCodeWriter::extrude_to_xyz	(	const Vec3d &	point,
		double	dE,
		const std::string &	comment = std::string(),
		bool	force_no_extrusion = false )

{
    std::string gcode;
    this->extrude_to_xyz(gcode, point, dE, comment, force_no_extrusion);
    return gcode;
}

References extrude_to_xyz().

Referenced by extrude_to_xyz().

Here is the call graph for this function:

Here is the caller graph for this function:

extrude_to_xyz() [2/2]

void Slic3r::GCodeWriter::extrude_to_xyz	(	std::string &	out,
		const Vec3d &	point,
		double	dE,
		const std::string &	comment = std::string(),
		bool	force_no_extrusion = false )

{
    // Check if Z actually changes (at export precision) before emitting it.
    // ZAA sloped extrusions call this for every segment, but many consecutive
    // segments share the same quantized Z — emitting it every time is redundant.
    const bool high_precision = this->high_precision();
    bool z_changed = (GCodeFormatter::quantize_xyz(point(2), high_precision) != GCodeFormatter::quantize_xyz(m_pos(2), high_precision));
 
    m_pos = point;
    m_lifted = 0;
    if (!force_no_extrusion)
        filament()->extrude(dE);
 
    //BBS: take plate offset into consider
    Vec3d point_on_plate = { point(0) - m_x_offset, point(1) - m_y_offset, point(2) };
 
    GCodeG1Formatter w(high_precision);
    if (has_axis_remap()) {
        // z_changed was computed from the ORIGINAL slicing Z, but an axis remap can
        // make machine-Z depend on slicing X/Y. An X/Y-only move (slicing-Z
        // unchanged) would then drop the required machine-Z word, so always emit
        // full XYZ whenever a remap is active.
        point_on_plate = apply_axis_remap(point_on_plate);
        w.emit_xyz(point_on_plate);
    } else if (z_changed) {
        w.emit_xyz(point_on_plate);
    } else {
        w.emit_xy(Vec2d(point_on_plate.x(), point_on_plate.y()));
    }
    if (!force_no_extrusion)
        w.emit_e(filament()->E_to_emit(high_precision));
    //BBS
    w.emit_comment(GCodeWriter::full_gcode_comment, comment);
    w.append_to(out);
}

References Slic3r::GCodeFormatter::append_to(), apply_axis_remap(), Slic3r::GCodeFormatter::emit_comment(), Slic3r::GCodeFormatter::emit_e(), Slic3r::GCodeFormatter::emit_xy(), Slic3r::GCodeFormatter::emit_xyz(), Slic3r::Extruder::extrude(), filament(), full_gcode_comment, has_axis_remap(), high_precision(), m_lifted, m_pos, m_x_offset, m_y_offset, and Slic3r::GCodeFormatter::quantize_xyz().

Here is the call graph for this function:

extruder_ids()

std::vector< unsigned int > Slic3r::GCodeWriter::extruder_ids ( ) const

inline

                                                 {
        std::vector<unsigned int> out;
        out.reserve(m_filament_extruders.size());
        for (const Extruder &e : m_filament_extruders)
            out.push_back(e.id());
        return out;
    }

References m_filament_extruders.

Referenced by set_extruders().

Here is the caller graph for this function:

extruders()

const std::vector< Extruder > & Slic3r::GCodeWriter::extruders ( ) const

inline

{ return m_filament_extruders; }

References m_filament_extruders.

Referenced by Slic3r::CoolingBuffer::CoolingBuffer().

Here is the caller graph for this function:

filament() [1/4]

Extruder * Slic3r::GCodeWriter::filament ( )

inline

{ if (m_curr_extruder_id == -1) return nullptr; return m_curr_filament_extruder[m_curr_extruder_id]; }

References m_curr_extruder_id, and m_curr_filament_extruder.

Referenced by _retract(), active_printable_area(), eager_lift(), extrude_arc_to_xy(), extrude_to_xy(), extrude_to_xyz(), lazy_lift(), need_toolchange(), retract(), retract_for_toolchange(), travel_to_xyz(), and unretract().

Here is the caller graph for this function:

filament() [2/4]

const Extruder * Slic3r::GCodeWriter::filament ( ) const

inline

{ if(m_curr_extruder_id==-1) return nullptr; return m_curr_filament_extruder[m_curr_extruder_id]; }

References m_curr_extruder_id, and m_curr_filament_extruder.

filament() [3/4]

Extruder * Slic3r::GCodeWriter::filament ( size_t extruder_id )

inline

{ assert(extruder_id < m_curr_filament_extruder.size()); return m_curr_filament_extruder[extruder_id]; }

References m_curr_filament_extruder.

Referenced by Slic3r::OozePrevention::_get_temp(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), Slic3r::Wipe::calculateWipeRetractionLengths(), Slic3r::need_wipe(), Slic3r::OozePrevention::post_toolchange(), Slic3r::OozePrevention::pre_toolchange(), and Slic3r::Wipe::wipe().

Here is the caller graph for this function:

filament() [4/4]

const Extruder * Slic3r::GCodeWriter::filament ( size_t extruder_id ) const

inline

{ assert(extruder_id < m_curr_filament_extruder.size()); return m_curr_filament_extruder[extruder_id]; }

References m_curr_filament_extruder.

force_standard_precision()

bool Slic3r::GCodeWriter::force_standard_precision ( bool force )

inline

{ return std::exchange(m_force_standard_precision, force); }

References m_force_standard_precision.

get_current_speed()

double Slic3r::GCodeWriter::get_current_speed ( ) const

inline

{ return m_current_speed;}

References m_current_speed.

Referenced by Slic3r::Wipe::wipe().

Here is the caller graph for this function:

get_extruder_retracted_length()

double Slic3r::GCodeWriter::get_extruder_retracted_length

(

const int

filament_id

)

{
    double res = 0.0;
    auto filament_extruder_iter = Slic3r::lower_bound_by_predicate(m_filament_extruders.begin(), m_filament_extruders.end(),
        [filament_id](const Extruder &e) { return (int) e.id() < filament_id; });
    if (filament_extruder_iter == m_filament_extruders.end() || (int) filament_extruder_iter->id() != filament_id)
        return res;
 
    if (filament_extruder_iter->is_share_extruder())
        res = filament_extruder_iter->get_share_retracted_length();
    else
        res = filament_extruder_iter->get_single_retracted_length();
 
    return res;
}

References Slic3r::lower_bound_by_predicate(), and m_filament_extruders.

Referenced by Slic3r::WipeTowerIntegration::append_tcr().

Here is the call graph for this function:

Here is the caller graph for this function:

get_gcode_flavor()

GCodeFlavor Slic3r::GCodeWriter::get_gcode_flavor ( ) const

inline

{ return config.gcode_flavor; }

References config.

get_position() [1/2]

Vec3d & Slic3r::GCodeWriter::get_position ( )

inline

{ return m_pos; }

References m_pos.

get_position() [2/2]

const Vec3d & Slic3r::GCodeWriter::get_position ( ) const

inline

{ return m_pos; }

References m_pos.

Referenced by Slic3r::CoolingBuffer::CoolingBuffer(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), Slic3r::WipeTowerIntegration::finalize(), and Slic3r::OozePrevention::pre_toolchange().

Here is the caller graph for this function:

get_xy_offset()

Vec2f Slic3r::GCodeWriter::get_xy_offset ( )

inline

{ return Vec2f{m_x_offset, m_y_offset}; };

References m_x_offset, and m_y_offset.

get_zhop()

double Slic3r::GCodeWriter::get_zhop ( ) const

inline

{ return m_lifted; }

References m_lifted.

has_axis_remap()

bool Slic3r::GCodeWriter::has_axis_remap

(

)

const

{
    return m_kinematics->must_emit_all_axes();
}

References m_kinematics.

Referenced by _spiral_travel_to_z(), _travel_to_z(), extrude_to_xy(), extrude_to_xyz(), travel_to_xy(), and travel_to_xyz().

Here is the caller graph for this function:

high_precision()

bool Slic3r::GCodeWriter::high_precision ( ) const

inline

{ return config.high_precision_gcode.value && !m_force_standard_precision; }

References config, and m_force_standard_precision.

Referenced by _retract(), extrude_arc_to_xy(), extrude_to_xy(), extrude_to_xyz(), travel_to_xy(), and unretract().

Here is the caller graph for this function:

init_extruder()

void Slic3r::GCodeWriter::init_extruder

(

unsigned int

filament_id

)

{
    if (m_curr_extruder_id == -1 && filament_id != -1) {
        auto filament_extruder_iter = Slic3r::lower_bound_by_predicate(m_filament_extruders.begin(), m_filament_extruders.end(), [filament_id](const Extruder &e) { return e.id() < filament_id; });
        assert(filament_extruder_iter != m_filament_extruders.end() && filament_extruder_iter->id() == filament_id);
        m_curr_extruder_id = filament_extruder_iter->extruder_id();
        m_curr_filament_extruder[m_curr_extruder_id] = &*filament_extruder_iter;
        m_cached_extruder_idx = get_extruder_index(this->config, filament_id);
    }
}

References config, Slic3r::get_extruder_index(), Slic3r::lower_bound_by_predicate(), m_cached_extruder_idx, m_curr_extruder_id, m_curr_filament_extruder, and m_filament_extruders.

Here is the call graph for this function:

invalidate_acceleration()

void Slic3r::GCodeWriter::invalidate_acceleration ( )

inline

{ m_last_acceleration = 0; m_last_travel_acceleration = 0; }

References m_last_acceleration, and m_last_travel_acceleration.

invalidate_jerk()

void Slic3r::GCodeWriter::invalidate_jerk ( )

inline

{ m_last_jerk = 0; }

References m_last_jerk.

is_bbl_printers()

const bool Slic3r::GCodeWriter::is_bbl_printers ( ) const

inline

{return m_is_bbl_printers;}

References m_is_bbl_printers.

Referenced by toolchange().

Here is the caller graph for this function:

is_current_position_clear()

bool Slic3r::GCodeWriter::is_current_position_clear ( ) const

inline

{ return m_is_current_pos_clear; };

References m_is_current_pos_clear.

Referenced by Slic3r::WipeTowerIntegration::append_tcr2(), eager_lift(), must_skip_lift_now(), planned_travel_z(), and travel_to_xyz().

Here is the caller graph for this function:

is_object_end_str_empty()

bool Slic3r::GCodeWriter::is_object_end_str_empty ( )

inline

{ return m_gcode_label_objects_end.empty(); }

References m_gcode_label_objects_end.

is_object_start_str_empty()

bool Slic3r::GCodeWriter::is_object_start_str_empty ( )

inline

{ return m_gcode_label_objects_start.empty(); }

References m_gcode_label_objects_start.

kinematics()

const MachineKinematics & Slic3r::GCodeWriter::kinematics ( ) const

inline

{ return *m_kinematics; }

References m_kinematics.

Referenced by set_kinematics().

Here is the caller graph for this function:

lazy_lift()

std::string Slic3r::GCodeWriter::lazy_lift	(	LiftType	lift_type = LiftType::NormalLift,
		bool	spiral_vase = false )

{
    if (m_force_normal_lift)
        lift_type = LiftType::NormalLift;
    // check whether the above/below conditions are met
    double target_lift = 0;
    {
        //BBS
        int extruder_id = filament()->extruder_id();
        int filament_id = filament()->id();
        double above = this->config.retract_lift_above.get_at(extruder_id);
        double below = this->config.retract_lift_below.get_at(extruder_id);
        if (m_pos.z() >= above && (m_pos.z() <= below || below == 0.))
            target_lift = this->config.z_hop.get_at(filament_id);
    }
    // BBS
    if (m_lifted == 0 && m_to_lift == 0 && target_lift > 0) {
        if (spiral_vase) {
            if (this->must_skip_lift_now())
                // Record no lift, so a later unlift() does not descend from a
                // height that was never commanded.
                return "";
            m_lifted = target_lift;
            return this->_travel_to_z(m_pos(2) + target_lift, "lift Z");
        }
        else {
            m_to_lift = target_lift;
            m_to_lift_type = lift_type;
        }
    }
    return "";
}

References _travel_to_z(), config, Slic3r::Extruder::extruder_id(), filament(), Slic3r::Extruder::id(), m_force_normal_lift, m_lifted, m_pos, m_to_lift, m_to_lift_type, must_skip_lift_now(), and Slic3r::NormalLift.

Here is the call graph for this function:

must_skip_lift_now()

bool Slic3r::GCodeWriter::must_skip_lift_now ( ) const

protected

{
    return m_kinematics->suppress_lift_at_unknown_position() && ! this->is_current_position_clear();
}

References is_current_position_clear(), and m_kinematics.

Referenced by eager_lift(), lazy_lift(), and travel_to_xyz().

Here is the call graph for this function:

Here is the caller graph for this function:

need_toolchange()

bool Slic3r::GCodeWriter::need_toolchange

(

unsigned int

filament_id

)

const

{
    return filament()==nullptr || filament()->id()!=filament_id;
}

References filament(), and Slic3r::Extruder::id().

Referenced by Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), Slic3r::WipeTowerIntegration::is_empty_wipe_tower_gcode(), set_extruder(), and Slic3r::WipeTowerIntegration::tool_change().

Here is the call graph for this function:

Here is the caller graph for this function:

planned_travel_z()

std::pair< double, double > Slic3r::GCodeWriter::planned_travel_z	(	const Vec3d &	point,
		bool	force_z = false ) const

{
    double destination_z = point.z();
    if (std::abs(m_to_lift) > EPSILON) {
        if ((!this->is_current_position_clear() || m_pos != point) &&
            m_to_lift + m_pos.z() > point.z())
            destination_z = m_to_lift + m_pos.z();
    } else if (!force_z && !this->will_move_z(point.z())) {
        destination_z = m_pos.z();
    }
    return { m_pos.z(), destination_z };
}

References EPSILON, is_current_position_clear(), m_pos, m_to_lift, and will_move_z().

Here is the call graph for this function:

point_on_first_layer()

bool Slic3r::GCodeWriter::point_on_first_layer ( const Vec3d & point_logical ) const

protected

{
    if (m_first_layer_point_test)
        return m_first_layer_point_test(point_logical);
    return m_is_first_layer;
}

References m_first_layer_point_test, and m_is_first_layer.

Referenced by _travel_to_z(), travel_to_xy(), and travel_to_xyz().

Here is the caller graph for this function:

postamble()

std::string Slic3r::GCodeWriter::postamble

(

)

const

{
    std::ostringstream gcode;
    if (FLAVOR_IS(gcfMachinekit))
          gcode << "M2 ; end of program\n";
    return gcode.str();
}

References FLAVOR_IS, and Slic3r::gcfMachinekit.

preamble()

std::string Slic3r::GCodeWriter::preamble

(

)

{
    std::ostringstream gcode;
 
    if (FLAVOR_IS_NOT(gcfMakerWare)) {
        gcode << "G90\n";
        gcode << "G21\n";
    }
    if (FLAVOR_IS(gcfRepRapSprinter) ||
        FLAVOR_IS(gcfRepRapFirmware) ||
        FLAVOR_IS(gcfMarlinLegacy) ||
        FLAVOR_IS(gcfMarlinFirmware) ||
        FLAVOR_IS(gcfTeacup) ||
        FLAVOR_IS(gcfRepetier) ||
        FLAVOR_IS(gcfSmoothie) ||
        FLAVOR_IS(gcfKlipper))
    {
        if (this->config.use_relative_e_distances) {
            gcode << "M83 ; use relative distances for extrusion\n";
        } else {
            gcode << "M82 ; use absolute distances for extrusion\n";
        }
        gcode << this->reset_e(true);
    }
 
    return gcode.str();
}

References config, FLAVOR_IS, FLAVOR_IS_NOT, Slic3r::gcfKlipper, Slic3r::gcfMakerWare, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepetier, Slic3r::gcfRepRapFirmware, Slic3r::gcfRepRapSprinter, Slic3r::gcfSmoothie, Slic3r::gcfTeacup, and reset_e().

Here is the call graph for this function:

reset_e()

std::string Slic3r::GCodeWriter::reset_e

(

bool

force = false

)

{
    if (FLAVOR_IS(gcfMach3)
        || FLAVOR_IS(gcfMakerWare)
        || FLAVOR_IS(gcfSailfish))
        return "";
 
    if (m_curr_extruder_id!=-1 && m_curr_filament_extruder[m_curr_extruder_id] != nullptr) {
        if (is_zero(m_curr_filament_extruder[m_curr_extruder_id]->E()) && ! force)
            return "";
        m_curr_filament_extruder[m_curr_extruder_id]->reset_E();
    }
 
    if (! this->config.use_relative_e_distances) {
        std::ostringstream gcode;
        gcode << "G92 E0";
        //BBS
        if (GCodeWriter::full_gcode_comment) gcode << " ; reset extrusion distance";
        gcode << "\n";
        return gcode.str();
    } else {
        return "";
    }
}

References config, Slic3r::E, FLAVOR_IS, full_gcode_comment, Slic3r::gcfMach3, Slic3r::gcfMakerWare, Slic3r::gcfSailfish, Slic3r::is_zero(), m_curr_extruder_id, and m_curr_filament_extruder.

Referenced by add_object_end_labels(), preamble(), toolchange(), and unretract().

Here is the call graph for this function:

Here is the caller graph for this function:

retract()

std::string Slic3r::GCodeWriter::retract	(	bool	before_wipe = false,
		double	retract_length = 0 )

{
    double factor = before_wipe ? filament()->retract_before_wipe() : 1.;
    assert(factor >= 0. && factor <= 1. + EPSILON);
    return this->_retract(
        retract_length > EPSILON ? retract_length : factor * filament()->retraction_length(),
        factor * filament()->retract_restart_extra(),
        "retract"
    );
}

References _retract(), EPSILON, filament(), Slic3r::Extruder::retract_before_wipe(), and Slic3r::retract_restart_extra().

Referenced by _retract(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), and Slic3r::CalibPressureAdvance::move_to().

Here is the call graph for this function:

Here is the caller graph for this function:

retract_for_toolchange()

std::string Slic3r::GCodeWriter::retract_for_toolchange	(	bool	before_wipe = false,
		double	retract_length = 0 )

{
    double factor = before_wipe ? filament()->retract_before_wipe() : 1.;
    assert(factor >= 0. && factor <= 1. + EPSILON);
    return this->_retract(
        retract_length > EPSILON ? retract_length : factor * filament()->retract_length_toolchange(),
        factor * filament()->retract_restart_extra_toolchange(),
        "retract for toolchange"
    );
}

References _retract(), EPSILON, filament(), Slic3r::Extruder::retract_before_wipe(), and Slic3r::retract_length_toolchange().

Here is the call graph for this function:

set_accel_and_jerk()

std::string Slic3r::GCodeWriter::set_accel_and_jerk	(	unsigned int	acceleration,
		double	jerk )

{
    // Only Klipper supports setting acceleration and jerk at the same time. Throw an error if we try to do this on other flavours.
    if(FLAVOR_IS_NOT(gcfKlipper))
        throw std::runtime_error(_u8L("set_accel_and_jerk() is only supported by Klipper"));
 
    // Clamp the acceleration to the allowed maximum.
    if (EXTRUDER_LIMIT(m_max_acceleration) > 0 && acceleration > EXTRUDER_LIMIT(m_max_acceleration))
        acceleration = EXTRUDER_LIMIT(m_max_acceleration);
    
    // Clamp the jerk to the allowed maximum.
    if (EXTRUDER_LIMIT(m_max_jerk_x) > 0 && jerk > EXTRUDER_LIMIT(m_max_jerk_x))
        jerk = EXTRUDER_LIMIT(m_max_jerk_x);
    if (EXTRUDER_LIMIT(m_max_jerk_y) > 0 && jerk > EXTRUDER_LIMIT(m_max_jerk_y))
        jerk = EXTRUDER_LIMIT(m_max_jerk_y);
 
    const bool set_acceleration = acceleration != 0 && acceleration != m_last_acceleration;
    const bool set_jerk         = jerk > 0.01 && !is_approx(jerk, m_last_jerk);
    if (!set_acceleration && !set_jerk)
        return std::string();
 
    std::string gcode;
    gcode.reserve(128);
    gcode += "SET_VELOCITY_LIMIT";
    if (set_acceleration) {
        gcode += " ACCEL=";
        gcode += std::to_string(acceleration);
        if (this->config.accel_to_decel_enable)
            append_klipper_accel_to_decel(gcode, acceleration, this->config.accel_to_decel_factor.value);
        m_last_acceleration = acceleration;
    }
    if (set_jerk) {
        gcode += " SQUARE_CORNER_VELOCITY=";
        gcode += float_to_string_decimal_point(jerk);
        m_last_jerk = jerk;
    }
 
    if (GCodeWriter::full_gcode_comment)
        gcode += " ; adjust VELOCITY_LIMIT(accel/jerk)";
    gcode += "\n";
 
    return gcode;
 
}

References _u8L, append_klipper_accel_to_decel(), config, EXTRUDER_LIMIT, FLAVOR_IS_NOT, Slic3r::float_to_string_decimal_point(), full_gcode_comment, Slic3r::gcfKlipper, Slic3r::is_approx(), m_last_acceleration, m_last_jerk, m_max_acceleration, m_max_jerk_x, and m_max_jerk_y.

Here is the call graph for this function:

set_acceleration_internal()

std::string Slic3r::GCodeWriter::set_acceleration_internal ( Acceleration type, unsigned int acceleration )

private

{
    // Clamp the acceleration to the allowed maximum.
    if (type == Acceleration::Print && EXTRUDER_LIMIT(m_max_acceleration) > 0 && acceleration > EXTRUDER_LIMIT(m_max_acceleration))
        acceleration = EXTRUDER_LIMIT(m_max_acceleration);
    if (type == Acceleration::Travel && EXTRUDER_LIMIT(m_max_travel_acceleration) > 0 && acceleration > EXTRUDER_LIMIT(m_max_travel_acceleration))
        acceleration = EXTRUDER_LIMIT(m_max_travel_acceleration);
 
    // Are we setting travel acceleration for a flavour that supports separate travel and print acc?
    bool separate_travel = (type == Acceleration::Travel && supports_separate_travel_acceleration(this->config.gcode_flavor));
 
    auto& last_value = separate_travel ? m_last_travel_acceleration : m_last_acceleration ;
    if (acceleration == 0 || acceleration == last_value)
        return std::string();
 
    last_value = acceleration;
 
    const std::string value = std::to_string(acceleration);
    std::string       gcode;
    if (FLAVOR_IS(gcfRepetier)) {
        gcode += separate_travel ? "M202 X" : "M201 X";
        gcode += value;
        gcode += " Y";
        gcode += value;
    } else if (FLAVOR_IS(gcfRepRapFirmware) || FLAVOR_IS(gcfMarlinFirmware)) {
        gcode += separate_travel ? "M204 T" : "M204 P";
        gcode += value;
    } else if (FLAVOR_IS(gcfKlipper)) {
        gcode.reserve(128);
        gcode += "SET_VELOCITY_LIMIT ACCEL=";
        gcode += value;
        if (this->config.accel_to_decel_enable) {
            append_klipper_accel_to_decel(gcode, acceleration, this->config.accel_to_decel_factor.value);
            if (GCodeWriter::full_gcode_comment)
                gcode += " ; adjust ACCEL_TO_DECEL";
        }
    } else {
        gcode += "M204 S";
        gcode += value;
    }
 
    if (GCodeWriter::full_gcode_comment) gcode += " ; adjust acceleration";
    gcode += "\n";
 
    return gcode;
}

References append_klipper_accel_to_decel(), config, EXTRUDER_LIMIT, FLAVOR_IS, full_gcode_comment, Slic3r::gcfKlipper, Slic3r::gcfMarlinFirmware, Slic3r::gcfRepetier, Slic3r::gcfRepRapFirmware, m_last_acceleration, m_last_travel_acceleration, m_max_acceleration, m_max_travel_acceleration, Print, supports_separate_travel_acceleration(), and Travel.

Referenced by set_print_acceleration(), and set_travel_acceleration().

Here is the call graph for this function:

Here is the caller graph for this function:

set_additional_fan()

std::string Slic3r::GCodeWriter::set_additional_fan ( unsigned int speed )

static

{
    std::ostringstream gcode;
 
    gcode << "M106 " << "P2 " << "S" << (int)(255.0 * speed / 100.0);
    if (GCodeWriter::full_gcode_comment) {
        if (speed == 0)
            gcode << " ; disable additional fan ";
        else
            gcode << " ; enable additional fan ";
    }
    gcode << "\n";
    return gcode.str();
}

References full_gcode_comment.

Referenced by Slic3r::CoolingBuffer::apply_layer_cooldown().

Here is the caller graph for this function:

set_axis_remap()

void Slic3r::GCodeWriter::set_axis_remap	(	int	rx,
		int	ry,
		int	rz )

{
    m_remap_x = rx;
    m_remap_y = ry;
    m_remap_z = rz;
    m_kinematics->set_axis_remap(rx, ry, rz);
}

References m_kinematics, m_remap_x, m_remap_y, and m_remap_z.

set_bed_temperature()

std::string Slic3r::GCodeWriter::set_bed_temperature	(	int	temperature,
		bool	wait = false )

{
    if (temperature == m_last_bed_temperature && (! wait || m_last_bed_temperature_reached))
        return std::string();
 
    m_last_bed_temperature = temperature;
    m_last_bed_temperature_reached = wait;
 
    std::string code, comment;
    std::ostringstream gcode;
 
    if (wait) {
        code = "M190";
        comment = "set bed temperature and wait for it to be reached";
    }
    else {
        code = "M140";
        comment = "set bed temperature";
    }
 
    gcode << code << " S" << temperature << " ; " << comment << "\n";
    return gcode.str();
}

References m_last_bed_temperature, and m_last_bed_temperature_reached.

set_build_volume_max()

void Slic3r::GCodeWriter::set_build_volume_max

(

const Vec3d &

max

)

{
    m_build_vol_max = max;
    m_kinematics->set_build_volume_max(max);
}

References m_build_vol_max, and m_kinematics.

set_chamber_temperature()

std::string Slic3r::GCodeWriter::set_chamber_temperature	(	int	temperature,
		bool	wait = false )

{
    std::string code, comment;
    std::ostringstream gcode;
 
    if (wait)
    {
        // Orca: should we let the M191 command to turn on the auxiliary fan?
        if (config.auxiliary_fan)
            gcode << "M106 P2 S255 \n";
        gcode << "M191 S" << std::to_string(temperature) << " ;"
              << "set chamber_temperature and wait for it to be reached\n";
        if (config.auxiliary_fan)
            gcode << "M106 P2 S0 \n";
    }
    else {
        code = "M141";
        comment = "set chamber_temperature";
        gcode << code << " S" << temperature << ";" << comment << "\n";
    }
    return gcode.str();
}

References config.

set_current_position_clear()

void Slic3r::GCodeWriter::set_current_position_clear ( bool clear )

inline

{ m_is_current_pos_clear = clear; };

References m_is_current_pos_clear.

Referenced by Slic3r::WipeTowerIntegration::append_tcr(), travel_to_xy(), and travel_to_xyz().

Here is the caller graph for this function:

set_exhaust_fan()

std::string Slic3r::GCodeWriter::set_exhaust_fan ( int speed )

static

{
    std::ostringstream gcode;
    gcode << "M106" << " P3" << " S" << (int)(speed / 100.0 * 255);
 
    if (GCodeWriter::full_gcode_comment) {
        if (speed == 0)
            gcode << " ; disable exhaust fan ";
        else
            gcode << " ; enable exhaust fan ";
    }
 
    gcode << "\n";
    return gcode.str();
}

References full_gcode_comment.

set_extruder()

std::string Slic3r::GCodeWriter::set_extruder

(

unsigned int

filament_id

)

{
    auto filament_ext_it = Slic3r::lower_bound_by_predicate(m_filament_extruders.begin(), m_filament_extruders.end(), [filament_id](const Extruder &e) { return e.id() < filament_id; });
    unsigned int extruder_id = filament_ext_it->extruder_id();
    assert(filament_ext_it != m_filament_extruders.end() && filament_ext_it->id() == filament_id);
    // Orca: writer-only context (calibration paths) has no nozzle grouping; the
    // filament's own extruder id is the correct degenerate nozzle value.
    return this->need_toolchange(filament_id) ? this->toolchange(filament_id, (int) extruder_id) : "";
}

References Slic3r::lower_bound_by_predicate(), m_filament_extruders, need_toolchange(), and toolchange().

Here is the call graph for this function:

set_extruders()

void Slic3r::GCodeWriter::set_extruders

(

std::vector< unsigned int >

extruder_ids

)

{
    std::sort(extruder_ids.begin(), extruder_ids.end());
    m_filament_extruders.clear();
    //ORCA: Reset current extruder ID and clear pointers to prevent dangling pointers when extruders are recreated.
    m_curr_extruder_id = -1;
    m_cached_extruder_idx = 0;
    std::fill(m_curr_filament_extruder.begin(), m_curr_filament_extruder.end(), nullptr);
    m_filament_extruders.reserve(extruder_ids.size());
    for (unsigned int extruder_id : extruder_ids)
        m_filament_extruders.emplace_back(Extruder(extruder_id, &this->config, config.single_extruder_multi_material.value));
 
    /*  we enable support for multiple extruder if any extruder greater than 0 is used
        (even if prints only uses that one) since we need to output Tx commands
        first extruder has index 0 */
    //ORCA: Fix undefined behavior by checking if the vector is empty before taking max_element.
    this->multiple_extruders = !extruder_ids.empty() && (*std::max_element(extruder_ids.begin(), extruder_ids.end())) > 0;
}

References config, Slic3r::Extruder, extruder_ids(), m_cached_extruder_idx, m_curr_extruder_id, m_curr_filament_extruder, m_filament_extruders, and multiple_extruders.

Here is the call graph for this function:

set_fan() [1/2]

std::string Slic3r::GCodeWriter::set_fan ( const GCodeFlavor gcode_flavor, unsigned int speed, unsigned int part_cooling_fan_min_pwm = 0 )

static

{
    std::ostringstream gcode;
    // ORCA: clamp non-zero fan commands up to the configured PWM floor so fans that can't spool at low duty
    // cycles still start reliably. Zero (fan off) is preserved exactly so disable-fan commands are never altered.
    if (speed > 0 && part_cooling_fan_min_pwm > 0 && speed < part_cooling_fan_min_pwm)
        speed = part_cooling_fan_min_pwm;
    if (speed == 0) {
        switch (gcode_flavor) {
        case gcfTeacup:
            gcode << "M106 S0"; break;
        case gcfMakerWare:
        case gcfSailfish:
            gcode << "M127";    break;
        default:
            gcode << "M106 S0";    break;
        }
        if (GCodeWriter::full_gcode_comment)
            gcode << " ; disable fan";
        gcode << "\n";
    } else {
        switch (gcode_flavor) {
        case gcfMakerWare:
        case gcfSailfish:
            gcode << "M126";    break;
        case gcfMach3:
        case gcfMachinekit:
            gcode << "M106 P" << static_cast<unsigned int>(255.5 * speed / 100.0); break;
        default:
            gcode << "M106 S" << static_cast<unsigned int>(255.5 * speed / 100.0); break;
        }
        if (GCodeWriter::full_gcode_comment)
            gcode << " ; enable fan";
        gcode << "\n";
    }
    return gcode.str();
}

References full_gcode_comment, Slic3r::gcfMach3, Slic3r::gcfMachinekit, Slic3r::gcfMakerWare, Slic3r::gcfSailfish, Slic3r::gcfTeacup, Slic3r::gcode_flavor(), and Slic3r::part_cooling_fan_min_pwm().

Referenced by Slic3r::FanMover::_set_fan(), Slic3r::CoolingBuffer::apply_layer_cooldown(), and set_fan().

Here is the call graph for this function:

Here is the caller graph for this function:

set_fan() [2/2]

std::string Slic3r::GCodeWriter::set_fan

(

unsigned int

speed

)

const

{
    //BBS
    // ORCA: pick up the per-printer PWM floor from the active config.
    return GCodeWriter::set_fan(this->config.gcode_flavor, speed,
                                static_cast<unsigned int>(std::max(0, this->config.part_cooling_fan_min_pwm.value)));
}

References config, and set_fan().

Here is the call graph for this function:

set_first_layer_point_test()

void Slic3r::GCodeWriter::set_first_layer_point_test ( FirstLayerPointTest test )

inline

{ m_first_layer_point_test = std::move(test); }

References m_first_layer_point_test.

set_force_normal_lift()

void Slic3r::GCodeWriter::set_force_normal_lift ( bool force )

inline

{ m_force_normal_lift = force; }

References m_force_normal_lift.

set_input_shaping()

std::string Slic3r::GCodeWriter::set_input_shaping	(	char	axis,
		float	damp,
		float	freq,
		std::string	type ) const

{
    bool disable = type == "Disable";
    if (disable){
        freq = 0.0f;
        damp = 0.0f;
        axis = 'A';
        type = "Default";
    } else if (freq < 0.0f || damp < 0.f || damp > 1.0f || (axis != 'X' && axis != 'Y' && axis != 'Z' && axis != 'A')) { // A = all axis
        throw std::runtime_error("Invalid input shaping parameters: axis=" + std::string(1, axis) + ", freq=" + std::to_string(freq) + ", damp=" + std::to_string(damp));
    }
    std::ostringstream gcode;
    std::ostringstream params;
    switch (this->config.gcode_flavor) {
    case gcfKlipper: {
        if (!type.empty() && type != "Default") {
            params << " SHAPER_TYPE=" << type;
        }
        if (axis != 'A')
        {
            if (freq > 0.0f) {
                params << " SHAPER_FREQ_" << axis << "=" << std::fixed << std::setprecision(2) << freq;
            }
            if (damp > 0.0f) {
                params << " DAMPING_RATIO_" << axis << "=" << std::fixed << std::setprecision(3) << damp;
            }
        } else {
            if (freq > 0.0f || disable) {
                params << " SHAPER_FREQ_X=" << std::fixed << std::setprecision(2) << freq << " SHAPER_FREQ_Y=" << std::fixed << std::setprecision(2) << freq;
            }
            if (damp > 0.0f || disable) {
                params << " DAMPING_RATIO_X=" << std::fixed << std::setprecision(3) << damp << " DAMPING_RATIO_Y=" << std::fixed << std::setprecision(3) << damp;
            }
        }
        if (!params.str().empty()) {
            gcode << "SET_INPUT_SHAPER" << params.str();
        }
        break;
    }
    case gcfRepRapFirmware: {
        if (!type.empty() && type != "Default" && type != "DAA") {
            params << " P\"" << type << "\"";
        }
        if (freq > 0.0f || disable) {
            params << " F" << std::fixed << std::setprecision(2) << freq;
        }
        if (damp > 0.0f || disable) {
            params << " S" << std::fixed << std::setprecision(3) << damp;
        }
        if (!params.str().empty()) {
            gcode << "M593" << params.str();
        }
        break;
    }
    case gcfMarlinFirmware: {
        if (axis != 'A') {
            params << " " << axis;
        }
        if (freq > 0.0f || disable) {
            params << " F" << std::fixed << std::setprecision(2) << freq;
        }
        if (damp > 0.0f || disable) {
            params << " D" << std::fixed << std::setprecision(3) << damp;
        }
        if (!params.str().empty()) {
            gcode << "M593" << params.str();
        }
        break;
    }
    case gcfMarlinLegacy: {
        throw std::runtime_error(_u8L("Input shaping is not supported by Marlin < 2.1.2.\nCheck your firmware version and update your G-code flavor to ´Marlin 2´."));
    }
    default:
        throw std::runtime_error(_u8L("Input shaping is only supported by Klipper, RepRapFirmware and Marlin 2."));
    }
    if (!gcode.str().empty()) {
        if (GCodeWriter::full_gcode_comment) {
            gcode << " ; Override input shaping";
        }
        gcode << "\n";
    }
    return gcode.str();
}

References _u8L, config, full_gcode_comment, Slic3r::gcfKlipper, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, and Slic3r::gcfRepRapFirmware.

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

Here is the caller graph for this function:

set_is_bbl_machine()

void Slic3r::GCodeWriter::set_is_bbl_machine ( bool bval )

inline

{m_is_bbl_printers = bval;}

References m_is_bbl_printers.

set_is_first_layer()

void Slic3r::GCodeWriter::set_is_first_layer ( bool bval )

inline

{ m_is_first_layer = bval; }

References m_is_first_layer.

set_jerk_xy()

std::string Slic3r::GCodeWriter::set_jerk_xy

(

double

jerk

)

{
    if (jerk < 0.01 || is_approx(jerk, m_last_jerk))
        return std::string();
    
    m_last_jerk = jerk;
 
    std::ostringstream gcode;
    if (FLAVOR_IS(gcfKlipper)) {
        // Clamp the jerk to the allowed maximum.
        if (EXTRUDER_LIMIT(m_max_jerk_x) > 0 && jerk > EXTRUDER_LIMIT(m_max_jerk_x))
            jerk = EXTRUDER_LIMIT(m_max_jerk_x);
        if (EXTRUDER_LIMIT(m_max_jerk_y) > 0 && jerk > EXTRUDER_LIMIT(m_max_jerk_y))
            jerk = EXTRUDER_LIMIT(m_max_jerk_y);
        
        gcode << "SET_VELOCITY_LIMIT SQUARE_CORNER_VELOCITY=" << jerk;
        
    } else if (FLAVOR_IS(gcfRepetier)) {
        // Repetier uses M207 for temporary Jerk and combines X/Y into a single 'X' parameter.
        double jerk_xy = jerk;
        
        // Clamp against the X machine limit
        if (EXTRUDER_LIMIT(m_max_jerk_x) > 0 && jerk_xy > EXTRUDER_LIMIT(m_max_jerk_x))
            jerk_xy = EXTRUDER_LIMIT(m_max_jerk_x);
            
        // Clamp against the Y machine limit as well to be safe
        if (EXTRUDER_LIMIT(m_max_jerk_y) > 0 && jerk_xy > EXTRUDER_LIMIT(m_max_jerk_y))
            jerk_xy = EXTRUDER_LIMIT(m_max_jerk_y);
            
        // Output the lowest safe limit using ONLY the X parameter
        gcode << "M207 X" << jerk_xy;
    } else {
        double jerk_x = jerk;
        double jerk_y = jerk;
        // Clamp the axis jerk to the allowed maximum.
        if (EXTRUDER_LIMIT(m_max_jerk_x) > 0 && jerk > EXTRUDER_LIMIT(m_max_jerk_x))
            jerk_x = EXTRUDER_LIMIT(m_max_jerk_x);
        if (EXTRUDER_LIMIT(m_max_jerk_y) > 0 && jerk > EXTRUDER_LIMIT(m_max_jerk_y))
            jerk_y = EXTRUDER_LIMIT(m_max_jerk_y);
        
        gcode << "M205 X" << jerk_x << " Y" << jerk_y;
    }
    //the is_bbl check should be in the else statement above so that it doesn't inadverently added Z & E to klipper  
    if (m_is_bbl_printers)
        gcode << std::setprecision(2) << " Z" << EXTRUDER_LIMIT(m_max_jerk_z) << " E" << EXTRUDER_LIMIT(m_max_jerk_e);
 
    if (GCodeWriter::full_gcode_comment) gcode << " ; adjust jerk";
    gcode << "\n";
 
    return gcode.str();
 
}

References EXTRUDER_LIMIT, FLAVOR_IS, full_gcode_comment, Slic3r::gcfKlipper, Slic3r::gcfRepetier, Slic3r::is_approx(), m_is_bbl_printers, m_last_jerk, m_max_jerk_e, m_max_jerk_x, m_max_jerk_y, and m_max_jerk_z.

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_junction_deviation()

std::string Slic3r::GCodeWriter::set_junction_deviation

(

double

junction_deviation

)

                                                                      {
    std::ostringstream gcode;
    if (FLAVOR_IS(gcfMarlinFirmware) && EXTRUDER_LIMIT(m_max_junction_deviation) > 0 && junction_deviation > 0) {
        // Clamp the junction deviation to the allowed maximum.
        gcode << "M205 J";
        if (junction_deviation <= EXTRUDER_LIMIT(m_max_junction_deviation)) {
            gcode << std::fixed << std::setprecision(3) << junction_deviation;
        } else {
            gcode << std::fixed << std::setprecision(3) << EXTRUDER_LIMIT(m_max_junction_deviation);
        }
        if (GCodeWriter::full_gcode_comment) {
            gcode << " ; Junction Deviation";
        }
        gcode << "\n";
    }
    return gcode.str();
}

References EXTRUDER_LIMIT, FLAVOR_IS, full_gcode_comment, Slic3r::gcfMarlinFirmware, and m_max_junction_deviation.

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

Here is the caller graph for this function:

set_kinematics()

void Slic3r::GCodeWriter::set_kinematics

(

std::unique_ptr< MachineKinematics >

kinematics

)

{
    assert(kinematics);
    m_kinematics = std::move(kinematics);
    // Replay whatever was configured on the previous strategy so callers may
    // install the kinematics before or after set_axis_remap/set_build_volume_max.
    m_kinematics->set_axis_remap(m_remap_x, m_remap_y, m_remap_z);
    m_kinematics->set_build_volume_max(m_build_vol_max);
}

References kinematics(), m_build_vol_max, m_kinematics, m_remap_x, m_remap_y, and m_remap_z.

Referenced by Slic3r::install_belt_kinematics().

Here is the call graph for this function:

Here is the caller graph for this function:

set_object_end_str()

void Slic3r::GCodeWriter::set_object_end_str ( std::string end_string )

inline

{ m_gcode_label_objects_end = end_string; }

References m_gcode_label_objects_end.

set_object_start_str()

void Slic3r::GCodeWriter::set_object_start_str ( std::string start_string )

inline

{ m_gcode_label_objects_start = start_string; }

References m_gcode_label_objects_start.

set_position()

void Slic3r::GCodeWriter::set_position ( const Vec3d & in )

inline

{ m_pos = in; }

References m_pos.

Referenced by Slic3r::WipeTowerIntegration::append_tcr(), and Slic3r::WipeTowerIntegration::append_tcr2().

Here is the caller graph for this function:

set_pressure_advance()

std::string Slic3r::GCodeWriter::set_pressure_advance	(	double	pa,
		int	tool = -1 ) const

{
    std::ostringstream gcode;
    if (pa < 0)
        return gcode.str();
    if (m_is_bbl_printers) {
        // SoftFever: set L1000 to use linear model
        gcode << "M900 K" << std::setprecision(4) << pa << " L1000 M10 ; Override pressure advance value\n";
    } else if (FLAVOR_IS(gcfKlipper)) {
        // Klipper routes PA by extruder name, not active tool.
        // Convention: first extruder is "extruder", subsequent are "extruder1", "extruder2", etc.
        gcode << "SET_PRESSURE_ADVANCE ADVANCE=" << std::setprecision(4) << pa;
        if (tool > 0)
            gcode << " EXTRUDER=extruder" << tool;
        else if (tool == 0)
            gcode << " EXTRUDER=extruder";
        gcode << "; Override pressure advance value\n";
    } else if (FLAVOR_IS(gcfRepRapFirmware)) {
        // RRF: M572 D<n> targets a specific extruder; a bare M572 applies to whatever tool is
        // currently selected and errors when there isn't one. Callers with no tool index keep
        // the historical D0 rather than the bare form: PA would otherwise depend on
        // tool-selection state for every RRF user, none of whom are asking for IMEX.
        gcode << "M572 D" << (tool >= 0 ? tool : 0)
              << " S" << std::setprecision(4) << pa << "; Override pressure advance value\n";
    } else if (FLAVOR_IS(gcfRepetier)) {
        // Repetier M233: X is quadratic (K), Y is linear (L).
        // Applying the value to both parameters simultaneously.
        gcode << "M233 X" << std::setprecision(4) << pa << " Y" << std::setprecision(4) << pa << " ; Override pressure advance value\n";
    } else if (FLAVOR_IS(gcfMarlinFirmware)) {
        // Marlin 2.x supports T parameter for per-extruder LA
        gcode << "M900 K" << std::setprecision(4) << pa;
        if (tool >= 0)
            gcode << " T" << tool;
        gcode << "; Override pressure advance value\n";
    } else {
        // Marlin Legacy and everything else: single-extruder M900, no tool parameter
        gcode << "M900 K" << std::setprecision(4) << pa << "; Override pressure advance value\n";
    }
    return gcode.str();
}

References FLAVOR_IS, Slic3r::gcfKlipper, Slic3r::gcfMarlinFirmware, Slic3r::gcfRepetier, Slic3r::gcfRepRapFirmware, and m_is_bbl_printers.

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

Here is the caller graph for this function:

set_print_acceleration()

std::string Slic3r::GCodeWriter::set_print_acceleration ( unsigned int acceleration )

inline

{ return set_acceleration_internal(Acceleration::Print, acceleration); }

References Print, and set_acceleration_internal().

Here is the call graph for this function:

set_speed() [1/2]

std::string Slic3r::GCodeWriter::set_speed	(	double	F,
		const std::string &	comment = std::string(),
		const std::string &	cooling_marker = std::string() )

{
    std::string gcode;
    this->set_speed(gcode, F, comment, cooling_marker);
    return gcode;
}

References Slic3r::F, and set_speed().

Referenced by Slic3r::CalibPressureAdvance::draw_line(), Slic3r::CalibPressureAdvance::draw_number(), set_speed(), and Slic3r::Wipe::wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

set_speed() [2/2]

void Slic3r::GCodeWriter::set_speed	(	std::string &	out,
		double	F,
		const std::string &	comment = std::string(),
		const std::string &	cooling_marker = std::string() )

{
    assert(F > 0.);
    assert(F < 100000.);
    
    m_current_speed = F;
    GCodeG1Formatter w(config.high_precision_gcode.value);
    w.emit_f(F);
    //BBS
    w.emit_comment(GCodeWriter::full_gcode_comment, comment);
    w.emit_string(cooling_marker);
    w.append_to(out);
}

References Slic3r::GCodeFormatter::append_to(), config, Slic3r::GCodeFormatter::emit_comment(), Slic3r::GCodeFormatter::emit_f(), Slic3r::GCodeFormatter::emit_string(), Slic3r::F, full_gcode_comment, and m_current_speed.

Here is the call graph for this function:

set_temperature() [1/2]

std::string Slic3r::GCodeWriter::set_temperature	(	unsigned int	temperature,
		bool	wait = false,
		int	tool = -1 ) const

{
    // set tool to -1 to make sure we won't emit T parameter for single extruder or SEMM
    if (!this->multiple_extruders || m_single_extruder_multi_material) {
        tool = -1;
    } else {
        // Every caller of this overload addresses filaments by LOGICAL id, but M104/M109
        // name a physical heater -- so translate at the one point they all pass through.
        // The static overload below is already physical-in (GCode.cpp:5952,
        // GCode/GCodeProcessor.cpp:1410) and must not be remapped, which is why the
        // translation lives here and not there.
        tool = imex_physical_heater_for(this->config.is_imex.value, this->config.physical_extruder_map, tool);
    }
    return set_temperature(temperature, this->config.gcode_flavor, wait, tool);
}

References config, Slic3r::imex_physical_heater_for(), m_single_extruder_multi_material, multiple_extruders, and set_temperature().

Here is the call graph for this function:

set_temperature() [2/2]

std::string Slic3r::GCodeWriter::set_temperature ( unsigned int temperature, GCodeFlavor flavor, bool wait = false, int tool = -1, std::string comment = std::string() )

static

                                                                                                                          {
    if (wait && (flavor == gcfMakerWare || flavor == gcfSailfish))
        return "";
 
    std::string code;
    if (wait && flavor != gcfTeacup && flavor != gcfRepRapFirmware) {
        code    = "M109";
        if(comment.empty())
            comment = "set nozzle temperature and wait for it to be reached";
    } else {
        if (flavor == gcfRepRapFirmware) { // M104 is deprecated on RepRapFirmware
            code = "G10";
        } else {
            code = "M104";
        }
        if(comment.empty())
            comment = "set nozzle temperature";
    }
 
    std::ostringstream gcode;
    gcode << code << " ";
    if (flavor == gcfMach3 || flavor == gcfMachinekit) {
        gcode << "P";
    } else {
        gcode << "S";
    }
    gcode << temperature;
    if (tool != -1) {
        if (flavor == gcfRepRapFirmware) {
            gcode << " P" << tool;
        } else {
            gcode << " T" << tool;
        }
    }
    gcode << " ; " << comment << "\n";
 
    if ((flavor == gcfTeacup || flavor == gcfRepRapFirmware) && wait)
        gcode << "M116 ; wait for temperature to be reached\n";
 
    return gcode.str();
}

References Slic3r::gcfMach3, Slic3r::gcfMachinekit, Slic3r::gcfMakerWare, Slic3r::gcfRepRapFirmware, Slic3r::gcfSailfish, and Slic3r::gcfTeacup.

Referenced by Slic3r::OozePrevention::post_toolchange(), Slic3r::OozePrevention::pre_toolchange(), Slic3r::GCode::process_layer(), Slic3r::GCodeProcessor::run_post_process(), and set_temperature().

Here is the caller graph for this function:

set_travel_acceleration()

std::string Slic3r::GCodeWriter::set_travel_acceleration ( unsigned int acceleration )

inline

{ return set_acceleration_internal(Acceleration::Travel, acceleration); }

References set_acceleration_internal(), and Travel.

Here is the call graph for this function:

set_xy_offset()

void Slic3r::GCodeWriter::set_xy_offset ( double x, double y )

inline

{ m_x_offset = x; m_y_offset = y; }

References m_x_offset, and m_y_offset.

spiral_lift_fits_printable_area()

bool Slic3r::GCodeWriter::spiral_lift_fits_printable_area ( const Vec2d & center, double radius ) const

private

{
    const Polygon *area = this->active_printable_area();
    if (area == nullptr)
        return true; // Boundary unknown: don't restrict (preserve previous behavior).
 
    const Point  c        = Point::new_scale(center.x(), center.y());
    const double r_scaled = scale_(radius);
    const double r2       = r_scaled * r_scaled;
 
    // The spiral traces a full circle of `radius` around `center`, so the center must lie
    // inside the printable area and every edge must be at least `radius` away from it.
    if (!area->contains(c))
        return false;
    const Points &pts = area->points;
    for (size_t i = 0, n = pts.size(); i < n; ++i)
        if (Line::distance_to_squared(c, pts[i], pts[(i + 1) % n]) < r2)
            return false;
    return true;
}

References active_printable_area(), Slic3r::area(), Slic3r::center(), Slic3r::Line::distance_to_squared(), Slic3r::Point::new_scale(), and scale_.

Referenced by eager_lift(), and travel_to_xyz().

Here is the call graph for this function:

Here is the caller graph for this function:

supports_separate_travel_acceleration()

bool Slic3r::GCodeWriter::supports_separate_travel_acceleration ( GCodeFlavor flavor )

static

{
    return (flavor == gcfRepetier || flavor == gcfMarlinFirmware ||  flavor == gcfRepRapFirmware);
}

References Slic3r::gcfMarlinFirmware, Slic3r::gcfRepetier, and Slic3r::gcfRepRapFirmware.

Referenced by Slic3r::GCodeProcessor::apply_config(), apply_print_config(), and set_acceleration_internal().

Here is the caller graph for this function:

toolchange()

std::string Slic3r::GCodeWriter::toolchange	(	unsigned int	filament_id,
		int	nozzle_id )

{
    // set the new extruder
    auto filament_extruder_iter = Slic3r::lower_bound_by_predicate(m_filament_extruders.begin(), m_filament_extruders.end(), [filament_id](const Extruder &e) { return e.id() < filament_id; });
    assert(filament_extruder_iter != m_filament_extruders.end() && filament_extruder_iter->id() == filament_id);
    m_curr_extruder_id = filament_extruder_iter->extruder_id();
    m_curr_filament_extruder[m_curr_extruder_id] = &*filament_extruder_iter;
    m_cached_extruder_idx = get_extruder_index(this->config, filament_id);
 
    // return the toolchange command
    // if we are running a single-extruder setup, just set the extruder and return nothing
    std::ostringstream gcode;
    // Orca: also emit for non-BBL single-extruder multi-filament setups (MMU-style).
    if (this->multiple_extruders || (this->config.filament_diameter.values.size() > 1 && !is_bbl_printers())) {
        // Orca: manual filament change keeps its tag line even on BBL machines, so the
        // M1020 form must not shadow it. nozzle_id is signed: the null-safe nozzle
        // lookup legitimately yields -1 ("no specific nozzle"), matching the literal
        // H-1 the stock change templates emit; an unsigned would wrap.
        if (m_is_bbl_printers && !config.manual_filament_change)
            gcode << "M1020 S" << filament_id << " H" << nozzle_id;
        else
            gcode << this->toolchange_prefix() << filament_id;
        if (GCodeWriter::full_gcode_comment)
            gcode << " ; change extruder";
        gcode << "\n";
        gcode << this->reset_e(true);
    }
    return gcode.str();
}

References config, full_gcode_comment, Slic3r::get_extruder_index(), is_bbl_printers(), Slic3r::lower_bound_by_predicate(), m_cached_extruder_idx, m_curr_extruder_id, m_curr_filament_extruder, m_filament_extruders, m_is_bbl_printers, multiple_extruders, reset_e(), and toolchange_prefix().

Referenced by Slic3r::WipeTowerIntegration::append_tcr(), and set_extruder().

Here is the call graph for this function:

Here is the caller graph for this function:

toolchange_prefix()

std::string Slic3r::GCodeWriter::toolchange_prefix

(

)

const

{
    // Orca: the manual-filament-change tag must stay ahead of the flavor selection so
    // MMU manual-change handling keeps working.
    if (config.manual_filament_change)
        return ";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Manual_Tool_Change) + "T";
    return FLAVOR_IS(gcfMakerWare) ? "M135 T" :
           FLAVOR_IS(gcfSailfish)  ? "M108 T" : "T";
}

References config, FLAVOR_IS, Slic3r::gcfMakerWare, Slic3r::gcfSailfish, Slic3r::GCodeProcessor::Manual_Tool_Change, and Slic3r::GCodeProcessor::reserved_tag().

Referenced by Slic3r::WipeTowerIntegration::append_tcr(), and toolchange().

Here is the call graph for this function:

Here is the caller graph for this function:

travel_to_xy()

std::string Slic3r::GCodeWriter::travel_to_xy	(	const Vec2d &	point,
		const std::string &	comment = std::string() )

{
    m_pos(0) = point(0);
    m_pos(1) = point(1);
 
    this->set_current_position_clear(true);
    //BBS: take plate offset into consider
    Vec2d point_on_plate = { point(0) - m_x_offset, point(1) - m_y_offset };
 
    GCodeG1Formatter w(high_precision());
    if (has_axis_remap()) {
        // Axis remap may couple XY with Z; emit full XYZ in machine coordinates.
        Vec3d machine = apply_axis_remap(Vec3d(point_on_plate.x(), point_on_plate.y(), m_pos.z()));
        w.emit_xyz(machine);
    } else {
        w.emit_xy(point_on_plate);
    }
    auto speed = this->point_on_first_layer(Vec3d(point_on_plate.x(), point_on_plate.y(), m_pos.z()))
        ? this->config.get_abs_value_at("initial_layer_travel_speed", m_cached_extruder_idx) : this->config.travel_speed.get_at(m_cached_extruder_idx);
    w.emit_f(speed * 60.0);
    //BBS
    w.emit_comment(GCodeWriter::full_gcode_comment, comment);
    return w.string();
}

References apply_axis_remap(), config, Slic3r::GCodeFormatter::emit_comment(), Slic3r::GCodeFormatter::emit_f(), Slic3r::GCodeFormatter::emit_xy(), Slic3r::GCodeFormatter::emit_xyz(), full_gcode_comment, has_axis_remap(), high_precision(), m_cached_extruder_idx, m_pos, m_x_offset, m_y_offset, point_on_first_layer(), set_current_position_clear(), and Slic3r::GCodeFormatter::string().

Referenced by Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), Slic3r::CalibPressureAdvance::move_to(), and travel_to_xyz().

Here is the call graph for this function:

Here is the caller graph for this function:

travel_to_xyz()

std::string Slic3r::GCodeWriter::travel_to_xyz	(	const Vec3d &	point,
		const std::string &	comment = std::string(),
		bool	force_z = false )

{
    // FIXME: This function was not being used when travel_speed_z was separated (bd6badf).
    // Calculation of feedrate was not updated accordingly. If you want to use
    // this function, fix it first.
    //std::terminate();
 
    /*  If target Z is lower than current Z but higher than nominal Z we
        don't perform the Z move but we only move in the XY plane and
        adjust the nominal Z by reducing the lift amount that will be
        used for unlift. */
        // BBS
    Vec3d dest_point = point;
    auto travel_speed =
        this->point_on_first_layer(Vec3d(point.x() - m_x_offset, point.y() - m_y_offset, point.z())) ? this->config.get_abs_value_at("initial_layer_travel_speed", m_cached_extruder_idx) : this->config.travel_speed.get_at(m_cached_extruder_idx);
    // See uses_pointwise_travel_speed(): the historical path deliberately emits the
    // raw configured speed in the final branch below, ignoring travel_speed.
    const double final_travel_speed = this->uses_pointwise_travel_speed()
        ? travel_speed
        : this->config.travel_speed.get_at(m_cached_extruder_idx);
    //BBS: a z_hop need to be handle when travel
    if (std::abs(m_to_lift) > EPSILON) {
        assert(std::abs(m_lifted) < EPSILON);
        //BBS: don't need to do real lift if the current position is absolutely same with target.
        //This ususally happens when the last extrusion line is short and the end of wipe position
        //is same with the traget point by chance.
        if ((!this->is_current_position_clear() || m_pos != dest_point) &&
            m_to_lift + m_pos(2) > point(2)) {
            m_lifted = m_to_lift + m_pos(2) - point(2);
            dest_point(2) = m_to_lift + m_pos(2);
        }
        m_to_lift = 0.;
 
        std::string slop_move;
        //BBS: minus plate offset
        Vec3d source = { m_pos(0) - m_x_offset, m_pos(1) - m_y_offset, m_pos(2) };
        Vec3d target = { dest_point(0) - m_x_offset, dest_point(1) - m_y_offset, dest_point(2) };
        Vec3d delta = target - source;
        Vec2d delta_no_z = { delta(0), delta(1) };
        //BBS: don'need slope travel because we don't know where is the source position the first time
        //BBS: Also don't need to do slope move or spiral lift if x-y distance is absolute zero
        if (delta(2) > 0 && delta_no_z.norm() != 0.0f)    {
            //BBS: SpiralLift
            if (m_to_lift_type == LiftType::SpiralLift && this->is_current_position_clear()) {
                //BBS: todo: check the arc move all in bed area, if not, then use lazy lift
                double radius = delta(2) / (2 * PI * atan(this->filament()->travel_slope()));
                Vec2d ij_offset = radius * delta_no_z.normalized();
                ij_offset = { -ij_offset(1), ij_offset(0) };
                // Orca: only perform the spiral lift if its full circle stays inside the
                // printable area of the active extruder, otherwise fall back to a normal
                // lift to avoid colliding with the print boundary. `source` is already in
                // bed coordinates (plate offset removed), matching the printable area.
                const Vec2d spiral_center = { source.x() + ij_offset.x(), source.y() + ij_offset.y() };
                if (this->spiral_lift_fits_printable_area(spiral_center, radius))
                    slop_move = this->_spiral_travel_to_z(target(2), ij_offset, "spiral lift Z");
                else
                    slop_move = _travel_to_z(target.z(), "normal lift Z");
            }
            //BBS: SlopeLift
            else if (m_to_lift_type == LiftType::SlopeLift &&
                this->is_current_position_clear() &&
                atan2(delta(2), delta_no_z.norm()) < this->filament()->travel_slope()) {
                //BBS: check whether we can make a travel like
                //   _____
                //  /       to make the z list early to avoid to hit some warping place when travel is long.
                Vec2d temp = delta_no_z.normalized() * delta(2) / tan(this->filament()->travel_slope());
                Vec3d slope_top_point = Vec3d(temp(0), temp(1), delta(2)) + source;
                GCodeG1Formatter w0(config.high_precision_gcode.value);
                // A slope lift is a straight (linear) diagonal move, so remapping its
                // endpoint is exact. Route the destination through apply_axis_remap()
                // when a remap is active (no-op at identity).
                w0.emit_xyz(has_axis_remap() ? apply_axis_remap(slope_top_point) : slope_top_point);
                w0.emit_f(travel_speed * 60.0);
                //BBS
                w0.emit_comment(GCodeWriter::full_gcode_comment, comment);
                slop_move = w0.string();
            }
            else if (m_to_lift_type == LiftType::NormalLift && ! this->must_skip_lift_now()) {
                // Only lift in place when the current position is known, for a mapping
                // that makes _travel_to_z re-emit logical X/Y: at print start (and after
                // custom gcode) m_pos.xy is still the uninitialised origin, which would
                // map to a bogus machine point. The xy_z_move below then travels straight
                // to the destination with full XYZ and establishes the correct position.
                // Mappings that do not need this (the historical Cartesian behaviour)
                // report false and keep lifting unconditionally.
                slop_move = _travel_to_z(target.z(), "normal lift Z");
            }
        }
 
        std::string xy_z_move;
        {
            GCodeG1Formatter w0(config.high_precision_gcode.value);
            if (has_axis_remap()) {
                // Remap may couple XY with Z; emit full XYZ in machine coordinates.
                w0.emit_xyz(apply_axis_remap(target));
                w0.emit_f(travel_speed * 60.0);
                w0.emit_comment(GCodeWriter::full_gcode_comment, comment);
                xy_z_move = w0.string();
            }
            else if (this->is_current_position_clear()) {
                w0.emit_xyz(target);
                w0.emit_f(travel_speed * 60.0);
                w0.emit_comment(GCodeWriter::full_gcode_comment, comment);
                xy_z_move = w0.string();
            }
            else {
                w0.emit_xy(Vec2d(target.x(), target.y()));
                w0.emit_f(travel_speed * 60.0);
                w0.emit_comment(GCodeWriter::full_gcode_comment, comment);
                xy_z_move = w0.string() + _travel_to_z(target.z(), comment);
            }
        }
        m_pos = dest_point;
        this->set_current_position_clear(true);
        return slop_move + xy_z_move;
    }
    else if (!force_z && !this->will_move_z(point(2))) {
        double nominal_z = m_pos(2) - m_lifted;
        m_lifted -= (point(2) - nominal_z);
        // In case that z_hop == layer_height we could end up with almost zero in_m_lifted
        // and a retract could be skipped
        if (std::abs(m_lifted) < EPSILON)
            m_lifted = 0.;
        //BBS
        this->set_current_position_clear(true);
        return this->travel_to_xy(to_2d(point));
    }
    else {
        /*  In all the other cases, we perform an actual XYZ move and cancel
            the lift. */
        m_lifted = 0;
    }
 
    //BBS: take plate offset into consider
    Vec3d point_on_plate = { dest_point(0) - m_x_offset, dest_point(1) - m_y_offset, dest_point(2) };
    std::string out_string;
    GCodeG1Formatter w(config.high_precision_gcode.value);
    if (has_axis_remap()) {
        // Remap may couple XY with Z; emit full XYZ in machine coordinates.
        w.emit_xyz(apply_axis_remap(point_on_plate));
        w.emit_f(final_travel_speed * 60.0);
        w.emit_comment(GCodeWriter::full_gcode_comment, comment);
        out_string = w.string();
    } else if (!this->is_current_position_clear())
    {
        //force to move xy first then z after filament change
        w.emit_xy(Vec2d(point_on_plate.x(), point_on_plate.y()));
        w.emit_f(final_travel_speed * 60.0);
        w.emit_comment(GCodeWriter::full_gcode_comment, comment);
        out_string = w.string() + _travel_to_z(point_on_plate.z(), comment);
    } else {
        GCodeG1Formatter w(config.high_precision_gcode.value);
        w.emit_xyz(point_on_plate);
        w.emit_f(final_travel_speed * 60.0);
        w.emit_comment(GCodeWriter::full_gcode_comment, comment);
        out_string = w.string();
    }
 
    m_pos = dest_point;
    this->set_current_position_clear(true);
    return out_string;
}

References _spiral_travel_to_z(), _travel_to_z(), apply_axis_remap(), config, Slic3r::GCodeFormatter::emit_comment(), Slic3r::GCodeFormatter::emit_f(), Slic3r::GCodeFormatter::emit_xy(), Slic3r::GCodeFormatter::emit_xyz(), EPSILON, filament(), full_gcode_comment, has_axis_remap(), is_current_position_clear(), m_cached_extruder_idx, m_lifted, m_pos, m_to_lift, m_to_lift_type, m_x_offset, m_y_offset, must_skip_lift_now(), Slic3r::NormalLift, PI, point_on_first_layer(), set_current_position_clear(), Slic3r::SlopeLift, spiral_lift_fits_printable_area(), Slic3r::SpiralLift, Slic3r::GCodeFormatter::string(), Slic3r::to_2d(), Slic3r::travel_slope(), Slic3r::travel_speed(), travel_to_xy(), uses_pointwise_travel_speed(), and will_move_z().

Here is the call graph for this function:

travel_to_z()

std::string Slic3r::GCodeWriter::travel_to_z	(	double	z,
		const std::string &	comment = std::string(),
		bool	force = false )

{
    /*  If target Z is lower than current Z but higher than nominal Z
        we don't perform the move but we only adjust the nominal Z by
        reducing the lift amount that will be used for unlift. */
    if (!force && !this->will_move_z(z)) {
        double nominal_z = m_pos(2) - m_lifted;
        m_lifted -= (z - nominal_z);
        if (std::abs(m_lifted) < EPSILON)
            m_lifted = 0.;
        return "";
    }
 
    /*  In all the other cases, we perform an actual Z move and cancel
        the lift. */
    m_lifted = 0;
    return this->_travel_to_z(z, comment);
}

References _travel_to_z(), EPSILON, m_lifted, m_pos, and will_move_z().

Referenced by Slic3r::GCode::_extrude(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), and Slic3r::CalibPressureAdvance::move_to().

Here is the call graph for this function:

Here is the caller graph for this function:

unlift()

std::string Slic3r::GCodeWriter::unlift

(

)

{
    std::string gcode;
    if (m_lifted > 0) {
        gcode += this->_travel_to_z(m_pos(2) - m_lifted, "restore layer Z");
        m_lifted = 0;
    }
    m_to_lift = 0.;
    return gcode;
}

References _travel_to_z(), m_lifted, m_pos, and m_to_lift.

Referenced by Slic3r::WipeTowerIntegration::append_tcr2().

Here is the call graph for this function:

Here is the caller graph for this function:

unretract()

std::string Slic3r::GCodeWriter::unretract

(

float

extra_retract = 0.f

)

{
    std::string gcode;
 
    if (FLAVOR_IS(gcfMakerWare))
        gcode = "M101 ; extruder on\n";
 
    if (double dE = filament()->unretract(); !is_zero(dE)) {
        if (this->config.use_firmware_retraction) {
            gcode += FLAVOR_IS(gcfMachinekit) ? "G23 ; unretract\n" : "G11 ; unretract\n";
            gcode += this->reset_e();
        }
        else {
            //BBS
            // use G1 instead of G0 because G0 will blend the restart with the previous travel move
            const bool high_precision = this->high_precision();
            GCodeG1Formatter w(high_precision);
            // extra_retract over-extrudes for the PETG pre-extrusion; 0 by
            // default -> identical to the plain deretract E position.
            w.emit_e(filament()->E_to_emit(high_precision, extra_retract));
            w.emit_f(filament()->deretract_speed() * 60.);
            //BBS
            w.emit_comment(GCodeWriter::full_gcode_comment, " ; unretract");
            gcode += w.string();
        }
    }
 
    return gcode;
}

References config, Slic3r::GCodeFormatter::emit_comment(), Slic3r::GCodeFormatter::emit_e(), Slic3r::GCodeFormatter::emit_f(), filament(), FLAVOR_IS, full_gcode_comment, Slic3r::gcfMachinekit, Slic3r::gcfMakerWare, high_precision(), Slic3r::is_zero(), reset_e(), Slic3r::GCodeFormatter::string(), and unretract().

Referenced by Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), Slic3r::ProcessLayer::emit_custom_gcode_per_print_z(), Slic3r::CalibPressureAdvance::move_to(), and unretract().

Here is the call graph for this function:

Here is the caller graph for this function:

update_progress()

std::string Slic3r::GCodeWriter::update_progress	(	unsigned int	num,
		unsigned int	tot,
		bool	allow_100 = false ) const

{
    if (FLAVOR_IS_NOT(gcfMakerWare) && FLAVOR_IS_NOT(gcfSailfish))
        return "";
 
    if (config.disable_m73) {
        return "";
    }
 
    unsigned int percent = (unsigned int)floor(100.0 * num / tot + 0.5);
    if (!allow_100) percent = std::min(percent, (unsigned int)99);
 
    std::ostringstream gcode;
    gcode << "M73 P" << percent;
    //BBS
    if (GCodeWriter::full_gcode_comment) gcode << " ; update progress";
    gcode << "\n";
    return gcode.str();
}

References config, FLAVOR_IS_NOT, full_gcode_comment, Slic3r::gcfMakerWare, and Slic3r::gcfSailfish.

uses_pointwise_travel_speed()

bool Slic3r::GCodeWriter::uses_pointwise_travel_speed ( ) const

inlineprotected

{ return bool(m_first_layer_point_test); }

References m_first_layer_point_test.

Referenced by travel_to_xyz().

Here is the caller graph for this function:

will_move_z()

bool Slic3r::GCodeWriter::will_move_z

(

double

z

)

const

{
    /* If target Z is lower than current Z but higher than nominal Z
        we don't perform an actual Z move. */
    if (m_lifted > 0) {
        double nominal_z = m_pos(2) - m_lifted;
        if (z >= nominal_z && z <= m_pos(2))
            return false;
    }
    // BBS.
    // Dont move z if it is the same as target z
    else if (std::abs(m_pos(2) - z) < EPSILON) {
        return false;
    }
    return true;
}

References EPSILON, m_lifted, and m_pos.

Referenced by planned_travel_z(), travel_to_xyz(), and travel_to_z().

Here is the caller graph for this function:

Member Data Documentation

config

GCodeConfig Slic3r::GCodeWriter::config

Referenced by Slic3r::FanMover::FanMover(), _retract(), _spiral_travel_to_z(), _travel_to_z(), add_object_end_labels(), apply_print_config(), eager_lift(), get_gcode_flavor(), high_precision(), init_extruder(), lazy_lift(), preamble(), Slic3r::GCode::process_layer(), reset_e(), set_accel_and_jerk(), set_acceleration_internal(), set_chamber_temperature(), set_extruders(), set_fan(), set_input_shaping(), set_speed(), set_temperature(), toolchange(), toolchange_prefix(), travel_to_xy(), travel_to_xyz(), unretract(), and update_progress().

full_gcode_comment

bool Slic3r::GCodeWriter::full_gcode_comment = true

static

Referenced by _retract(), _spiral_travel_to_z(), _travel_to_z(), Slic3r::GCode::do_export(), enable_power_loss_recovery(), extrude_arc_to_xy(), extrude_to_xy(), extrude_to_xyz(), reset_e(), set_accel_and_jerk(), set_acceleration_internal(), set_additional_fan(), set_exhaust_fan(), set_fan(), set_input_shaping(), set_jerk_xy(), set_junction_deviation(), set_speed(), toolchange(), travel_to_xy(), travel_to_xyz(), unretract(), and update_progress().

m_bed_printable_area

Polygon Slic3r::GCodeWriter::m_bed_printable_area

private

Referenced by active_printable_area(), and apply_print_config().

m_build_vol_max

Vec3d Slic3r::GCodeWriter::m_build_vol_max = Vec3d::Zero()

protected

Referenced by set_build_volume_max(), and set_kinematics().

m_cached_extruder_idx

size_t Slic3r::GCodeWriter::m_cached_extruder_idx

protected

Referenced by GCodeWriter(), _spiral_travel_to_z(), _travel_to_z(), init_extruder(), set_extruders(), toolchange(), travel_to_xy(), and travel_to_xyz().

m_curr_extruder_id

int Slic3r::GCodeWriter::m_curr_extruder_id

private

Referenced by GCodeWriter(), filament(), filament(), init_extruder(), reset_e(), set_extruders(), and toolchange().

m_curr_filament_extruder

std::vector<Extruder*> Slic3r::GCodeWriter::m_curr_filament_extruder

private

Referenced by GCodeWriter(), filament(), filament(), filament(), filament(), init_extruder(), reset_e(), set_extruders(), and toolchange().

m_current_speed

double Slic3r::GCodeWriter::m_current_speed

protected

Referenced by GCodeWriter(), get_current_speed(), and set_speed().

m_extruder_printable_areas

std::vector<Polygon> Slic3r::GCodeWriter::m_extruder_printable_areas

private

Referenced by active_printable_area(), and apply_print_config().

m_filament_extruders

std::vector<Extruder> Slic3r::GCodeWriter::m_filament_extruders

private

Referenced by extruder_ids(), extruders(), get_extruder_retracted_length(), init_extruder(), set_extruder(), set_extruders(), and toolchange().

m_first_layer_point_test

FirstLayerPointTest Slic3r::GCodeWriter::m_first_layer_point_test

protected

Referenced by point_on_first_layer(), set_first_layer_point_test(), and uses_pointwise_travel_speed().

m_force_normal_lift

bool Slic3r::GCodeWriter::m_force_normal_lift = false

protected

Referenced by eager_lift(), lazy_lift(), and set_force_normal_lift().

m_force_standard_precision

bool Slic3r::GCodeWriter::m_force_standard_precision = false

protected

Referenced by force_standard_precision(), and high_precision().

m_gcode_label_objects_end

std::string Slic3r::GCodeWriter::m_gcode_label_objects_end

private

Referenced by add_object_end_labels(), is_object_end_str_empty(), and set_object_end_str().

m_gcode_label_objects_start

std::string Slic3r::GCodeWriter::m_gcode_label_objects_start

private

Referenced by add_object_start_labels(), is_object_start_str_empty(), and set_object_start_str().

m_is_bbl_printers

bool Slic3r::GCodeWriter::m_is_bbl_printers = false

private

Referenced by enable_power_loss_recovery(), is_bbl_printers(), set_is_bbl_machine(), set_jerk_xy(), set_pressure_advance(), and toolchange().

m_is_current_pos_clear

bool Slic3r::GCodeWriter::m_is_current_pos_clear = false

protected

Referenced by is_current_position_clear(), and set_current_position_clear().

m_is_first_layer

bool Slic3r::GCodeWriter::m_is_first_layer = true

protected

Referenced by GCodeWriter(), _spiral_travel_to_z(), point_on_first_layer(), and set_is_first_layer().

m_kinematics

std::unique_ptr<MachineKinematics> Slic3r::GCodeWriter::m_kinematics

protected

Referenced by GCodeWriter(), apply_axis_remap(), extrude_arc_to_xy(), has_axis_remap(), kinematics(), must_skip_lift_now(), set_axis_remap(), set_build_volume_max(), and set_kinematics().

m_last_acceleration

unsigned int Slic3r::GCodeWriter::m_last_acceleration

private

Referenced by GCodeWriter(), invalidate_acceleration(), set_accel_and_jerk(), and set_acceleration_internal().

m_last_bed_temperature

int Slic3r::GCodeWriter::m_last_bed_temperature

private

Referenced by GCodeWriter(), and set_bed_temperature().

m_last_bed_temperature_reached

bool Slic3r::GCodeWriter::m_last_bed_temperature_reached

private

Referenced by GCodeWriter(), and set_bed_temperature().

m_last_jerk

double Slic3r::GCodeWriter::m_last_jerk

private

Referenced by GCodeWriter(), invalidate_jerk(), set_accel_and_jerk(), and set_jerk_xy().

m_last_travel_acceleration

unsigned int Slic3r::GCodeWriter::m_last_travel_acceleration

private

Referenced by GCodeWriter(), invalidate_acceleration(), and set_acceleration_internal().

m_lifted

double Slic3r::GCodeWriter::m_lifted

protected

Referenced by GCodeWriter(), eager_lift(), extrude_to_xyz(), get_zhop(), lazy_lift(), travel_to_xyz(), travel_to_z(), unlift(), and will_move_z().

m_max_acceleration

std::vector<unsigned int> Slic3r::GCodeWriter::m_max_acceleration

private

Referenced by GCodeWriter(), apply_print_config(), set_accel_and_jerk(), and set_acceleration_internal().

m_max_jerk_e

std::vector<double> Slic3r::GCodeWriter::m_max_jerk_e

private

Referenced by apply_print_config(), and set_jerk_xy().

m_max_jerk_x

std::vector<double> Slic3r::GCodeWriter::m_max_jerk_x

private

Referenced by GCodeWriter(), apply_print_config(), set_accel_and_jerk(), and set_jerk_xy().

m_max_jerk_y

std::vector<double> Slic3r::GCodeWriter::m_max_jerk_y

private

Referenced by GCodeWriter(), apply_print_config(), set_accel_and_jerk(), and set_jerk_xy().

m_max_jerk_z

std::vector<double> Slic3r::GCodeWriter::m_max_jerk_z

private

Referenced by apply_print_config(), and set_jerk_xy().

m_max_junction_deviation

std::vector<double> Slic3r::GCodeWriter::m_max_junction_deviation

private

Referenced by apply_print_config(), and set_junction_deviation().

m_max_travel_acceleration

std::vector<unsigned int> Slic3r::GCodeWriter::m_max_travel_acceleration

private

Referenced by GCodeWriter(), apply_print_config(), and set_acceleration_internal().

m_pos

Vec3d Slic3r::GCodeWriter::m_pos = Vec3d::Zero()

protected

Referenced by _spiral_travel_to_z(), _travel_to_z(), eager_lift(), extrude_arc_as_polyline(), extrude_arc_to_xy(), extrude_to_xy(), extrude_to_xyz(), get_position(), get_position(), lazy_lift(), planned_travel_z(), set_position(), travel_to_xy(), travel_to_xyz(), travel_to_z(), unlift(), and will_move_z().

m_remap_x

int Slic3r::GCodeWriter::m_remap_x = 0

protected

Referenced by set_axis_remap(), and set_kinematics().

m_remap_y

int Slic3r::GCodeWriter::m_remap_y = 1

protected

Referenced by set_axis_remap(), and set_kinematics().

m_remap_z

int Slic3r::GCodeWriter::m_remap_z = 2

protected

Referenced by set_axis_remap(), and set_kinematics().

m_resolution

double Slic3r::GCodeWriter::m_resolution = 0.01

private

Referenced by _spiral_travel_to_z(), and apply_print_config().

m_single_extruder_multi_material

bool Slic3r::GCodeWriter::m_single_extruder_multi_material

private

Referenced by GCodeWriter(), apply_print_config(), and set_temperature().

m_to_lift

double Slic3r::GCodeWriter::m_to_lift

protected

Referenced by GCodeWriter(), eager_lift(), lazy_lift(), planned_travel_z(), travel_to_xyz(), and unlift().

m_to_lift_type

LiftType Slic3r::GCodeWriter::m_to_lift_type

protected

Referenced by GCodeWriter(), lazy_lift(), and travel_to_xyz().

m_x_offset

double Slic3r::GCodeWriter::m_x_offset { 0 }

protected

{ 0 };

Referenced by _spiral_travel_to_z(), _travel_to_z(), eager_lift(), extrude_arc_to_xy(), extrude_to_xy(), extrude_to_xyz(), get_xy_offset(), set_xy_offset(), travel_to_xy(), and travel_to_xyz().

m_y_offset

double Slic3r::GCodeWriter::m_y_offset { 0 }

protected

{ 0 };

Referenced by _spiral_travel_to_z(), _travel_to_z(), eager_lift(), extrude_arc_to_xy(), extrude_to_xy(), extrude_to_xyz(), get_xy_offset(), set_xy_offset(), travel_to_xy(), and travel_to_xyz().

multiple_extruders

bool Slic3r::GCodeWriter::multiple_extruders

Referenced by GCodeWriter(), set_extruders(), set_temperature(), and toolchange().

---

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

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