Slic3r::SpiralVase Class Reference

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

Collaboration diagram for Slic3r::SpiralVase:

Classes
class	SpiralPoint

Public Member Functions
	SpiralVase (const PrintConfig &config)
void	enable (bool en)
std::string	process_layer (const std::string &gcode, bool last_layer)
void	set_max_xy_smoothing (float max)

Private Attributes
const PrintConfig &	m_config
GCodeReader	m_reader
float	m_max_xy_smoothing = 0.f
bool	m_enabled = false
bool	m_transition_layer = false
bool	m_smooth_spiral = false
std::vector< SpiralPoint > *	m_previous_layer

Detailed Description

Constructor & Destructor Documentation

SpiralVase()

Slic3r::SpiralVase::SpiralVase ( const PrintConfig & config )

inline

                                          : m_config(config)
    {
        m_reader.z() = (float)m_config.z_offset;
        m_reader.apply_config(m_config);
        m_previous_layer = NULL;
        m_smooth_spiral = config.spiral_mode_smooth;
    };

References m_config, m_previous_layer, m_reader, and m_smooth_spiral.

Member Function Documentation

enable()

void Slic3r::SpiralVase::enable ( bool en )

inline

                            {
      m_transition_layer = en && ! m_enabled;
      m_enabled        = en;
    }

References m_enabled, and m_transition_layer.

process_layer()

std::string Slic3r::SpiralVase::process_layer	(	const std::string &	gcode,
		bool	last_layer )

{
    /*  This post-processor relies on several assumptions:
        - all layers are processed through it, including those that are not supposed
          to be transformed, in order to update the reader with the XY positions
        - each call to this method includes a full layer, with a single Z move
          at the beginning
        - each layer is composed by suitable geometry (i.e. a single complete loop)
        - loops were not clipped before calling this method  */
    
    // If we're not going to modify G-code, just feed it to the reader
    // in order to update positions.
    if (! m_enabled) {
        m_reader.parse_buffer(gcode);
        return gcode;
    }
    
    // Get total XY length for this layer by summing all extrusion moves.
    float total_layer_length = 0;
    float layer_height = 0;
    float z = 0.f;
    
    {
        //FIXME Performance warning: This copies the GCodeConfig of the reader.
        GCodeReader r = m_reader;  // clone
        bool set_z = false;
        r.parse_buffer(gcode, [&total_layer_length, &layer_height, &z, &set_z]
            (GCodeReader &reader, const GCodeReader::GCodeLine &line) {
            if (line.cmd_is("G1")) {
                if (line.extruding(reader)) {
                    total_layer_length += line.dist_XY(reader);
                } else if (line.has(Z)) {
                    layer_height += line.dist_Z(reader);
                    if (!set_z) {
                        z = line.new_Z(reader);
                        set_z = true;
                    }
                }
            }
        });
    }
 
    // Remove layer height from initial Z.
    z -= layer_height;
 
    std::vector<SpiralVase::SpiralPoint>* current_layer = new std::vector<SpiralVase::SpiralPoint>();
    std::vector<SpiralVase::SpiralPoint>* previous_layer = m_previous_layer;
 
    bool smooth_spiral = m_smooth_spiral;
    std::string new_gcode;
    std::string transition_gcode;
    float max_xy_dist_for_smoothing = m_max_xy_smoothing;
    //FIXME Tapering of the transition layer only works reliably with relative extruder distances.
    // For absolute extruder distances it will be switched off.
    // Tapering the absolute extruder distances requires to process every extrusion value after the first transition
    // layer.
    bool  transition_in = m_transition_layer && m_config.use_relative_e_distances.value;
    bool  transition_out = last_layer && m_config.use_relative_e_distances.value;
 
    float starting_flowrate  = float(m_config.spiral_starting_flow_ratio.value);
    float finishing_flowrate = float(m_config.spiral_finishing_flow_ratio.value);
    const float min_segment_length = std::max(float(EPSILON), 2 * float(m_config.resolution.value));
 
    const int xyz_digits = GCodeFormatter::xyz_digits(m_config.high_precision_gcode.value);
    const int e_digits = GCodeFormatter::e_digits(m_config.high_precision_gcode.value);
    float len = 0.f;
    SpiralVase::SpiralPoint last_point = previous_layer != NULL && previous_layer->size() >0? previous_layer->at(previous_layer->size()-1): SpiralVase::SpiralPoint(0,0);
    m_reader.parse_buffer(gcode, [&new_gcode, &z, total_layer_length, layer_height, transition_in, &len, &current_layer, &previous_layer, &transition_gcode, transition_out, smooth_spiral, &max_xy_dist_for_smoothing, &last_point, starting_flowrate, finishing_flowrate, min_segment_length, xyz_digits, e_digits]
        (GCodeReader &reader, GCodeReader::GCodeLine line) {
        if (line.cmd_is("G1")) {
            // Orca: Filter out retractions at layer change
            if (line.retracting(reader) || (line.extruding(reader) && line.dist_XY(reader) < min_segment_length)) return;
            if (line.has_z() && !(line.has_x() || line.has_y())) {
                // If this is the initial Z move of the layer, replace it with a
                // (redundant) move to the last Z of previous layer.
                line.set(Z, z, xyz_digits);
                new_gcode += line.raw() + '\n';
                return;
            } else {
                float dist_XY = line.dist_XY(reader);
                if (line.has_x() || line.has_y()) { // Sometimes lines have X/Y but the move is to the last position
                    if (dist_XY > 0 && line.extruding(reader)) { // Exclude wipe and retract
                        len += dist_XY;
                        float factor = len / total_layer_length;
                        if (transition_in){
                            // Transition layer, interpolate the amount of extrusion starting from spiral_vase_starting_flow_rate to 100%.
                            float starting_e_factor = starting_flowrate + (factor * (1.f - starting_flowrate));
                            line.set(E, line.e() * starting_e_factor, e_digits);
                        } else if (transition_out) {
                            // We want the last layer to ramp down extrusion, but without changing z height!
                            // So clone the line before we mess with its Z and duplicate it into a new layer that ramps down E
                            // We add this new layer at the very end
                            // As with transition_in, the amount is ramped down from 100% to spiral_vase_finishing_flow_rate
                            GCodeReader::GCodeLine transitionLine(line);
                            float finishing_e_factor = finishing_flowrate + ((1.f -factor) * (1.f - finishing_flowrate));
                            transitionLine.set(E, line.e() * finishing_e_factor, e_digits);
                            transition_gcode += transitionLine.raw() + '\n';
                        }
                        // This line is the core of Spiral Vase mode, ramp up the Z smoothly
                        line.set(Z, z + factor * layer_height, xyz_digits);
                        if (smooth_spiral) {
                            // Now we also need to try to interpolate X and Y
                            SpiralVase::SpiralPoint p(line.x(), line.y()); // Get current x/y coordinates
                            current_layer->push_back(p);       // Store that point for later use on the next layer
                            if (previous_layer != NULL) {
                                bool        found    = false;
                                float       dist     = 0;
                                SpiralVase::SpiralPoint nearestp = SpiralVaseHelpers::nearest_point_on_lines(p, previous_layer, found, dist);
                                if (found && dist < max_xy_dist_for_smoothing) {
                                    // Interpolate between the point on this layer and the point on the previous layer
                                    SpiralVase::SpiralPoint target = SpiralVaseHelpers::add(SpiralVaseHelpers::scale(nearestp, 1 - factor), SpiralVaseHelpers::scale(p, factor));
 
                                    // Remove tiny movement
                                    // We need to figure out the distance of this new line!
                                    float modified_dist_XY = SpiralVaseHelpers::distance(last_point, target);
                                    if (modified_dist_XY < min_segment_length)
                                        line.clear();
                                    else {
                                        line.set(X, target.x, xyz_digits);
                                        line.set(Y, target.y, xyz_digits);
                                        // Scale the extrusion amount according to change in length
                                        line.set(E, line.e() * modified_dist_XY / dist_XY, e_digits);
                                        last_point = target;
                                    }
                                } else {
                                    last_point = p;
                                }
                            }
                        }
                        new_gcode += line.raw() + '\n';
                    }
                    return;
                    /*  Skip travel moves: the move to first perimeter point will
                        cause a visible seam when loops are not aligned in XY; by skipping
                        it we blend the first loop move in the XY plane (although the smoothness
                        of such blend depend on how long the first segment is; maybe we should
                        enforce some minimum length?).
                        When smooth_spiral is enabled, we're gonna end up exactly where the next layer should
                        start anyway, so we don't need the travel move */
                }
            }
        }
        new_gcode += line.raw() + '\n';
        if(transition_out) {
            transition_gcode += line.raw() + '\n';
        }
    });
 
    delete m_previous_layer;
    m_previous_layer = current_layer;
    
    return new_gcode + transition_gcode;
}

References Slic3r::SpiralVaseHelpers::add(), Slic3r::GCodeReader::GCodeLine::clear(), Slic3r::GCodeReader::GCodeLine::cmd_is(), Slic3r::Geometry::dist(), Slic3r::GCodeReader::GCodeLine::dist_XY(), Slic3r::GCodeReader::GCodeLine::dist_Z(), Slic3r::SpiralVaseHelpers::distance(), Slic3r::E, Slic3r::GCodeReader::GCodeLine::e(), Slic3r::GCodeFormatter::e_digits(), EPSILON, Slic3r::GCodeReader::GCodeLine::extruding(), Slic3r::GCodeReader::GCodeLine::has(), Slic3r::GCodeReader::GCodeLine::has_x(), Slic3r::GCodeReader::GCodeLine::has_y(), Slic3r::GCodeReader::GCodeLine::has_z(), Slic3r::layer_height(), m_config, m_enabled, m_max_xy_smoothing, m_previous_layer, m_reader, m_smooth_spiral, m_transition_layer, Slic3r::SpiralVaseHelpers::nearest_point_on_lines(), Slic3r::GCodeReader::GCodeLine::new_Z(), Slic3r::GCodeReader::parse_buffer(), Slic3r::GCodeReader::GCodeLine::raw(), Slic3r::GCodeReader::GCodeLine::retracting(), Slic3r::SpiralVaseHelpers::scale(), Slic3r::GCodeReader::GCodeLine::set(), Slic3r::X, Slic3r::GCodeReader::GCodeLine::x(), Slic3r::SpiralVase::SpiralPoint::x, Slic3r::GCodeFormatter::xyz_digits(), Slic3r::Y, Slic3r::GCodeReader::GCodeLine::y(), Slic3r::SpiralVase::SpiralPoint::y, and Slic3r::Z.

Here is the call graph for this function:

set_max_xy_smoothing()

void Slic3r::SpiralVase::set_max_xy_smoothing ( float max )

inline

                                         {
        m_max_xy_smoothing = max;
    }

References m_max_xy_smoothing.

Member Data Documentation

m_config

const PrintConfig& Slic3r::SpiralVase::m_config

private

Referenced by SpiralVase(), and process_layer().

m_enabled

bool Slic3r::SpiralVase::m_enabled = false

private

Referenced by enable(), and process_layer().

m_max_xy_smoothing

float Slic3r::SpiralVase::m_max_xy_smoothing = 0.f

private

Referenced by process_layer(), and set_max_xy_smoothing().

m_previous_layer

std::vector<SpiralPoint>* Slic3r::SpiralVase::m_previous_layer

private

Referenced by SpiralVase(), and process_layer().

m_reader

GCodeReader Slic3r::SpiralVase::m_reader

private

Referenced by SpiralVase(), and process_layer().

m_smooth_spiral

bool Slic3r::SpiralVase::m_smooth_spiral = false

private

Referenced by SpiralVase(), and process_layer().

m_transition_layer

bool Slic3r::SpiralVase::m_transition_layer = false

private

Referenced by enable(), and process_layer().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/SpiralVase.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/SpiralVase.cpp