Slic3r::Wipe Class Reference

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

Collaboration diagram for Slic3r::Wipe:

Classes
struct	RetractionValues

Public Member Functions
	Wipe ()
bool	has_path () const
void	reset_path ()
std::string	wipe (GCode &gcodegen, double length, bool toolchange=false, bool is_last=false)
RetractionValues	calculateWipeRetractionLengths (GCode &gcodegen, bool toolchange)
void	update_path (const ExtrusionPaths &paths, bool reverse=false)

Public Attributes
bool	enable
Polyline	path

Detailed Description

---

Class Documentation

Slic3r::Wipe::RetractionValues

struct Slic3r::Wipe::RetractionValues

Class Members
double	retraction_length_after_wipe = 0.
double	retraction_length_before_wipe = 0.
double	retraction_length_during_wipe = 0.

Constructor & Destructor Documentation

Wipe()

Slic3r::Wipe::Wipe ( )

inline

: enable(false) {}

References enable.

Member Function Documentation

calculateWipeRetractionLengths()

Wipe::RetractionValues Slic3r::Wipe::calculateWipeRetractionLengths	(	GCode &	gcodegen,
		bool	toolchange )

                                                                                              {
        auto& writer = gcodegen.writer();
        auto& config = gcodegen.config();
        auto extruder = writer.filament();
        auto last_pos = gcodegen.last_pos();
        
        // Declare & initialize retraction lengths
        double retraction_length_remaining = 0,
            retraction_length_before_wipe = 0,
            retraction_length_during_wipe = 0,
            retraction_length_after_wipe = 0;
        
        // Initialise the remaining retraction amount with the full retraction amount.
        retraction_length_remaining = toolchange ? 
            extruder->retract_length_toolchange() : extruder->retraction_length();
        
        // Nothing to retract - return early
        if (retraction_length_remaining <= EPSILON)
            return { 0.f, 0.f, 0.f };
        
        // Calculate retraction before and after wipe distances from the user setting. 
        // Keep adding to the for retraction before wipe variable any excess retraction 
        // needed to be performed before the wipe.
        retraction_length_before_wipe = retraction_length_remaining * extruder->retract_before_wipe();
        retraction_length_after_wipe = retraction_length_remaining * extruder->retract_after_wipe();
 
        // Subtract it from the remaining retraction length
        retraction_length_remaining -= retraction_length_before_wipe + retraction_length_after_wipe;
 
        // All of the retraction is to be done before the wipe
        if (retraction_length_remaining <= EPSILON) 
            return { retraction_length_before_wipe, 0., retraction_length_after_wipe };
        
        // Calculate wipe speed
        // Orca: resolve the travel_speed slot via the Print-side per-layer resolver; the writer's
        // per-layer synced config would yield the same index.
        double wipe_speed = config.role_based_wipe_speed ? writer.get_current_speed() / 60.0 : config.get_abs_value("wipe_speed", gcodegen.config().travel_speed.get_at(gcodegen.get_nozzle_config_index(gcodegen.writer().filament()->id())));
        wipe_speed = std::max(wipe_speed, 10.0);
 
        // Process wipe path & calculate wipe path length
        double wipe_dist = scale_(config.wipe_distance.get_at(extruder->config_index()));
        Polyline wipe_path = {last_pos};
        wipe_path.append(this->path.points.begin() + 1, this->path.points.end());
        double wipe_path_length = std::min(wipe_path.length(), wipe_dist);
 
        // Calculate the maximum retraction amount during wipe
        retraction_length_during_wipe = config.retraction_speed.get_at(extruder->config_index()) *
            unscale_(wipe_path_length) / wipe_speed;
 
        // If the maximum retraction amount during wipe is too small,
        // disable wipe-time retraction and leave any remaining retract amount
        // to the subsequent standard retract flow.
        if (retraction_length_during_wipe <= EPSILON) 
            return { retraction_length_before_wipe, 0., retraction_length_after_wipe };
        
        // If the maximum retraction amount during wipe is greater than any remaining retraction length
        // return the remaining retraction length to be retracted during the wipe
        if (retraction_length_during_wipe - retraction_length_remaining > EPSILON) 
            return { retraction_length_before_wipe, retraction_length_remaining, retraction_length_after_wipe };
        
        // We will always proceed with incrementing the retraction amount before wiping with the difference
        // and return the maximum allowed wipe amount to be retracted during the wipe move
        retraction_length_before_wipe += retraction_length_remaining - retraction_length_during_wipe;
 
        return { retraction_length_before_wipe, retraction_length_during_wipe, retraction_length_after_wipe };
    }

References Slic3r::Polyline::append(), Slic3r::GCode::config(), EPSILON, Slic3r::GCodeWriter::filament(), Slic3r::GCode::get_nozzle_config_index(), Slic3r::Extruder::id(), Slic3r::GCode::last_pos(), Slic3r::MultiPoint::length(), path, scale_, unscale_, and Slic3r::GCode::writer().

Here is the call graph for this function:

has_path()

bool Slic3r::Wipe::has_path ( ) const

inline

{ return !this->path.points.empty(); }

References Slic3r::MultiPoint::points.

reset_path()

void Slic3r::Wipe::reset_path ( )

inline

{ this->path = Polyline(); }

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

Here is the caller graph for this function:

update_path()

void Slic3r::Wipe::update_path	(	const ExtrusionPaths &	paths,
		bool	reverse = false )

    {
        reset_path();
        for (const ExtrusionPath& extrusion_path : paths)
            path.append(extrusion_path.polyline.to_polyline());
        if (reverse)
            path.reverse();
    }

References path, and reset_path().

Here is the call graph for this function:

wipe()

std::string Slic3r::Wipe::wipe	(	GCode &	gcodegen,
		double	length,
		bool	toolchange = false,
		bool	is_last = false )

    {
        std::string gcode;
 
        /*  Reduce feedrate a bit; travel speed is often too high to move on existing material.
            Too fast = ripping of existing material; too slow = short wipe path, thus more blob.  */
        // Orca: resolve the travel_speed slot via the Print-side per-layer resolver; the writer's
        // per-layer synced config would yield the same index.
        double _wipe_speed = gcodegen.config().get_abs_value("wipe_speed", gcodegen.config().travel_speed.get_at(gcodegen.get_nozzle_config_index(gcodegen.writer().filament()->id())));// gcodegen.writer().config.travel_speed.value * 0.8;
        if(gcodegen.config().role_based_wipe_speed)
            _wipe_speed = gcodegen.writer().get_current_speed() / 60.0;
        if(_wipe_speed < 10)
            _wipe_speed = 10;
 
 
        //SoftFever: allow 100% retract before wipe
        if (length >= 0)
        {
            /*  Calculate how long we need to travel in order to consume the required
                amount of retraction. In other words, how far do we move in XY at wipe_speed
                for the time needed to consume retraction_length at retraction_speed?  */
            // BBS
            double wipe_dist = scale_(gcodegen.config().wipe_distance.get_at(gcodegen.get_filament_config_index((int)gcodegen.writer().filament()->id())));
 
            /*  Take the stored wipe path and replace first point with the current actual position
                (they might be different, for example, in case of loop clipping).  */
            Polyline wipe_path;
            wipe_path.append(gcodegen.last_pos());
            wipe_path.append(
                this->path.points.begin() + 1,
                this->path.points.end()
            );
 
            wipe_path.clip_end(wipe_path.length() - wipe_dist);
 
            // subdivide the retraction in segments
            if (!wipe_path.empty()) {
                // BBS. Handle short path case.
                if (wipe_path.length() < wipe_dist) {
                    wipe_dist = wipe_path.length();
                    //BBS: avoid to divide 0
                    wipe_dist = wipe_dist < EPSILON ? EPSILON : wipe_dist;
                }
 
                // add tag for processor
                gcode += ";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Wipe_Start) + "\n";
                //BBS: don't need to enable cooling makers when this is the last wipe. Because no more cooling layer will clean this "_WIPE"
                //Softfever:
                std::string cooling_mark = "";
                if (gcodegen.enable_cooling_markers() && !is_last)
                    cooling_mark = /*gcodegen.config().role_based_wipe_speed ? ";_EXTERNAL_PERIMETER" : */";_WIPE";
 
                // Orca: set speed once because wipe_speed is constant for all segments.
                gcode += gcodegen.writer().set_speed(_wipe_speed * 60, "", cooling_mark);
                for (const Line& line : wipe_path.lines()) {
                    double segment_length = line.length();
                    double dE = length * (segment_length / wipe_dist);
                    gcode += gcodegen.writer().extrude_to_xy(
                        gcodegen.point_to_gcode(line.b),
                        -dE,
                        "wipe and retract"
                    );
                }
                // add tag for processor
                gcode += ";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Wipe_End) + "\n";
                gcodegen.set_last_pos(wipe_path.points.back());
            }
 
            // prevent wiping again on same path
            this->reset_path();
        }
 
        return gcode;
    }

References Slic3r::Polyline::append(), Slic3r::Polyline::clip_end(), Slic3r::GCode::config(), Slic3r::MultiPoint::empty(), Slic3r::GCode::enable_cooling_markers(), EPSILON, Slic3r::GCodeWriter::extrude_to_xy(), Slic3r::GCodeWriter::filament(), Slic3r::GCodeWriter::get_current_speed(), Slic3r::GCode::get_filament_config_index(), Slic3r::GCode::get_nozzle_config_index(), Slic3r::Extruder::id(), Slic3r::GCode::last_pos(), Slic3r::length(), Slic3r::MultiPoint::length(), Slic3r::Polyline::lines(), path, Slic3r::GCode::point_to_gcode(), Slic3r::MultiPoint::points, Slic3r::GCodeProcessor::reserved_tag(), reset_path(), scale_, Slic3r::segment_length(), Slic3r::GCode::set_last_pos(), Slic3r::GCodeWriter::set_speed(), Slic3r::GCodeProcessor::Wipe_End, Slic3r::GCodeProcessor::Wipe_Start, and Slic3r::GCode::writer().

Here is the call graph for this function:

Member Data Documentation

enable

bool Slic3r::Wipe::enable

Referenced by Wipe().

path

Polyline Slic3r::Wipe::path

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

---

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

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