#include <src/libslic3r/GCode.hpp>

Collaboration diagram for Slic3r::Wipe:

Public Member Functions
	Wipe ()

bool	has_path () const

void	reset_path ()

std::string	wipe (GCode &gcodegen, bool toolchange)

Public Attributes
bool	enable

Polyline	path

Detailed Description

Constructor & Destructor Documentation

◆ Wipe()

Slic3r::Wipe::Wipe ( )

inline

56: enable(false) {}

Slic3r::Wipe::enable

bool enable

Definition GCode.hpp:53

Member Function Documentation

◆ has_path()

bool Slic3r::Wipe::has_path ( ) const

inline

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

Slic3r::MultiPoint::empty

bool empty() const

Definition MultiPoint.hpp:40

Slic3r::Wipe::path

Polyline path

Definition GCode.hpp:54

References Slic3r::MultiPoint::empty().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_path()

void Slic3r::Wipe::reset_path ( )

inline

58{ this->path.clear(); }

Slic3r::MultiPoint::clear

void clear()

Definition MultiPoint.hpp:70

References Slic3r::MultiPoint::clear().

Referenced by Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::GCode::change_layer(), Slic3r::GCode::set_extruder(), Slic3r::GCode::travel_to(), and wipe().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ wipe()

std::string Slic3r::Wipe::wipe	(	GCode &	gcodegen,
		bool	toolchange
	)

    {
        std::string     gcode;
        const Extruder &extruder = *gcodegen.writer().extruder();
 
        // Remaining quantized retraction length.
        if (double retract_length = extruder.retract_to_go(toolchange ? extruder.retract_length_toolchange() : extruder.retract_length()); 
            retract_length > 0 && this->path.size() >= 2) {
            // 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.
            const double wipe_speed = gcodegen.writer().config.travel_speed.value * 0.8;
            // Reduce retraction length a bit to avoid effective retraction speed to be greater than the configured one
            // due to rounding (TODO: test and/or better math for this).
            const double xy_to_e    = 0.95 * extruder.retract_speed() / wipe_speed;
            // Start with the current position, which may be different from the wipe path start in case of loop clipping.
            Vec2d prev = gcodegen.point_to_gcode_quantized(gcodegen.last_pos());
            auto  it   = this->path.points.begin();
            Vec2d p    = gcodegen.point_to_gcode_quantized(*(++ it));
            if (p != prev) {
                gcode += ";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Wipe_Start) + "\n";
                auto  end  = this->path.points.end();
                bool  done = false;
                for (; it != end && ! done; ++ it) {
                    p = gcodegen.point_to_gcode_quantized(*it);
                    double segment_length = (p - prev).norm();
                    double dE = GCodeFormatter::quantize_e(xy_to_e * segment_length);
                    if (dE > retract_length - EPSILON) {
                        if (dE > retract_length + EPSILON)
                            // Shorten the segment.
                            p = prev + (p - prev) * (retract_length / dE);
                        dE   = retract_length;
                        done = true;
                    }
                    //FIXME one shall not generate the unnecessary G1 Fxxx commands, here wipe_speed is a constant inside this cycle.
                    // Is it here for the cooling markers? Or should it be outside of the cycle?
                    gcode += gcodegen.writer().set_speed(wipe_speed * 60, {}, gcodegen.enable_cooling_markers() ? ";_WIPE" : "");
                    gcode += gcodegen.writer().extrude_to_xy(p, -dE, "wipe and retract");
                    prev = p;
                    retract_length -= dE;
                }
                // add tag for processor
                gcode += ";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Wipe_End) + "\n";
                gcodegen.set_last_pos(gcodegen.gcode_to_point(prev));
            }
        }
 
        // Prevent wiping again on the same path.
        this->reset_path();
        return gcode;
    }