Slic3r::WipeTowerIntegration Class Reference

#include <src/libslic3r/GCode.hpp>

Collaboration diagram for Slic3r::WipeTowerIntegration:

Public Member Functions
	WipeTowerIntegration (const PrintConfig &print_config, const std::vector< WipeTower::ToolChangeResult > &priming, const std::vector< std::vector< WipeTower::ToolChangeResult > > &tool_changes, const WipeTower::ToolChangeResult &final_purge)
std::string	prime (GCode &gcodegen)
void	next_layer ()
std::string	tool_change (GCode &gcodegen, int extruder_id, bool finish_layer)
std::string	finalize (GCode &gcodegen)
std::vector< float >	used_filament_length () const

Private Member Functions
WipeTowerIntegration &	operator= (const WipeTowerIntegration &)
std::string	append_tcr (GCode &gcodegen, const WipeTower::ToolChangeResult &tcr, int new_extruder_id, double z=-1.) const
std::string	post_process_wipe_tower_moves (const WipeTower::ToolChangeResult &tcr, const Vec2f &translation, float angle) const

Private Attributes
const float	m_left
const float	m_right
const Vec2f	m_wipe_tower_pos
const float	m_wipe_tower_rotation
const std::vector< Vec2d >	m_extruder_offsets
const std::vector< WipeTower::ToolChangeResult > &	m_priming
const std::vector< std::vector< WipeTower::ToolChangeResult > > &	m_tool_changes
const WipeTower::ToolChangeResult &	m_final_purge
int	m_layer_idx
int	m_tool_change_idx
double	m_last_wipe_tower_print_z = 0.f

Detailed Description

Constructor & Destructor Documentation

WipeTowerIntegration()

Slic3r::WipeTowerIntegration::WipeTowerIntegration ( const PrintConfig &  print_config, const std::vector< WipeTower::ToolChangeResult > &  priming, const std::vector< std::vector< WipeTower::ToolChangeResult > > &  tool_changes, const WipeTower::ToolChangeResult &  final_purge  )

inline

                                                                                :
        m_left(/*float(print_config.wipe_tower_x.value)*/ 0.f),
        m_right(float(/*print_config.wipe_tower_x.value +*/ print_config.wipe_tower_width.value)),
        m_wipe_tower_pos(float(print_config.wipe_tower_x.value), float(print_config.wipe_tower_y.value)),
        m_wipe_tower_rotation(float(print_config.wipe_tower_rotation_angle)),
        m_extruder_offsets(print_config.extruder_offset.values),
        m_priming(priming),
        m_tool_changes(tool_changes),
        m_final_purge(final_purge),
        m_layer_idx(-1),
        m_tool_change_idx(0)
    {}

Member Function Documentation

append_tcr()

std::string Slic3r::WipeTowerIntegration::append_tcr ( GCode &  gcodegen, const WipeTower::ToolChangeResult &  tcr, int  new_extruder_id, double  z = -1.  ) const

private

    {
        if (new_extruder_id != -1 && new_extruder_id != tcr.new_tool)
            throw Slic3r::InvalidArgument("Error: WipeTowerIntegration::append_tcr was asked to do a toolchange it didn't expect.");
 
        std::string gcode;
 
        // Toolchangeresult.gcode assumes the wipe tower corner is at the origin (except for priming lines)
        // We want to rotate and shift all extrusions (gcode postprocessing) and starting and ending position
        float alpha = m_wipe_tower_rotation / 180.f * float(M_PI);
 
        auto transform_wt_pt = [&alpha, this](const Vec2f& pt) -> Vec2f {
            Vec2f out = Eigen::Rotation2Df(alpha) * pt;
            out += m_wipe_tower_pos;
            return out;
        };
 
        Vec2f start_pos = tcr.start_pos;
        Vec2f end_pos = tcr.end_pos;
        if (! tcr.priming) {
            start_pos = transform_wt_pt(start_pos);
            end_pos = transform_wt_pt(end_pos);
        }
 
        Vec2f wipe_tower_offset = tcr.priming ? Vec2f::Zero() : m_wipe_tower_pos;
        float wipe_tower_rotation = tcr.priming ? 0.f : alpha;
 
        std::string tcr_rotated_gcode = post_process_wipe_tower_moves(tcr, wipe_tower_offset, wipe_tower_rotation);
 
        gcode += gcodegen.writer().unlift(); // Make sure there is no z-hop (in most cases, there isn't).
 
        double current_z = gcodegen.writer().get_position().z();
        if (z == -1.) // in case no specific z was provided, print at current_z pos
            z = current_z;
 
        const bool needs_toolchange = gcodegen.writer().need_toolchange(new_extruder_id);
        const bool will_go_down = ! is_approx(z, current_z);
        if (tcr.force_travel || ! needs_toolchange || (gcodegen.config().single_extruder_multi_material && ! tcr.priming)) {
            // Move over the wipe tower. If this is not single-extruder MM, the first wipe tower move following the
            // toolchange will travel there anyway (if there is a toolchange).
            // FIXME: It would be better if the wipe tower set the force_travel flag for all toolchanges,
            // then we could simplify the condition and make it more readable.
            gcode += gcodegen.retract();
            gcodegen.m_avoid_crossing_perimeters.use_external_mp_once();
            gcode += gcodegen.travel_to(
                wipe_tower_point_to_object_point(gcodegen, start_pos),
                ExtrusionRole::Mixed,
                "Travel to a Wipe Tower");
            gcode += gcodegen.unretract();
        }
        
        if (will_go_down) {
            gcode += gcodegen.writer().retract();
            gcode += gcodegen.writer().travel_to_z(z, "Travel down to the last wipe tower layer.");
            gcode += gcodegen.writer().unretract();
        }
 
        std::string toolchange_gcode_str;
        std::string deretraction_str;
        if (tcr.priming || (new_extruder_id >= 0 && needs_toolchange)) {
            if (gcodegen.config().single_extruder_multi_material)
                gcodegen.m_wipe.reset_path(); // We don't want wiping on the ramming lines.
            toolchange_gcode_str = gcodegen.set_extruder(new_extruder_id, tcr.print_z); // TODO: toolchange_z vs print_z
            if (gcodegen.config().wipe_tower)
                deretraction_str = gcodegen.unretract();
        }
 
        
 
 
        // Insert the toolchange and deretraction gcode into the generated gcode.
        DynamicConfig config;
        config.set_key_value("toolchange_gcode", new ConfigOptionString(toolchange_gcode_str));
        config.set_key_value("deretraction_from_wipe_tower_generator", new ConfigOptionString(deretraction_str));
        std::string tcr_gcode, tcr_escaped_gcode = gcodegen.placeholder_parser_process("tcr_rotated_gcode", tcr_rotated_gcode, new_extruder_id, &config);
        unescape_string_cstyle(tcr_escaped_gcode, tcr_gcode);
        gcode += tcr_gcode;
        check_add_eol(toolchange_gcode_str);
 
        // A phony move to the end position at the wipe tower.
        gcodegen.writer().travel_to_xy(end_pos.cast<double>());
        gcodegen.set_last_pos(wipe_tower_point_to_object_point(gcodegen, end_pos));
        if (!is_approx(z, current_z)) {
            gcode += gcodegen.writer().retract();
            gcode += gcodegen.writer().travel_to_z(current_z, "Travel back up to the topmost object layer.");
            gcode += gcodegen.writer().unretract();
        }
 
        else {
            // Prepare a future wipe.
            gcodegen.m_wipe.reset_path();
            for (const Vec2f& wipe_pt : tcr.wipe_path)
                gcodegen.m_wipe.path.points.emplace_back(wipe_tower_point_to_object_point(gcodegen, transform_wt_pt(wipe_pt)));
        }
 
        // Let the planner know we are traveling between objects.
        gcodegen.m_avoid_crossing_perimeters.use_external_mp_once();
        return gcode;
    }

References Slic3r::check_add_eol(), Slic3r::GCode::config(), Slic3r::WipeTower::ToolChangeResult::end_pos, Slic3r::WipeTower::ToolChangeResult::force_travel, Slic3r::GCodeWriter::get_position(), Slic3r::is_approx(), Slic3r::GCode::m_avoid_crossing_perimeters, M_PI, Slic3r::GCode::m_wipe, m_wipe_tower_pos, m_wipe_tower_rotation, Slic3r::ExtrusionRole::Mixed, Slic3r::GCodeWriter::need_toolchange(), Slic3r::WipeTower::ToolChangeResult::new_tool, Slic3r::Wipe::path, Slic3r::GCode::placeholder_parser_process(), Slic3r::MultiPoint::points, post_process_wipe_tower_moves(), Slic3r::WipeTower::ToolChangeResult::priming, Slic3r::WipeTower::ToolChangeResult::print_z, Slic3r::Wipe::reset_path(), Slic3r::GCodeWriter::retract(), Slic3r::GCode::retract(), Slic3r::GCode::set_extruder(), Slic3r::DynamicConfig::set_key_value(), Slic3r::GCode::set_last_pos(), Slic3r::WipeTower::ToolChangeResult::start_pos, Slic3r::GCode::travel_to(), Slic3r::GCodeWriter::travel_to_xy(), Slic3r::GCodeWriter::travel_to_z(), Slic3r::unescape_string_cstyle(), Slic3r::GCodeWriter::unlift(), Slic3r::GCode::unretract(), Slic3r::GCodeWriter::unretract(), Slic3r::AvoidCrossingPerimeters::use_external_mp_once(), Slic3r::WipeTower::ToolChangeResult::wipe_path, Slic3r::wipe_tower_point_to_object_point(), and Slic3r::GCode::writer().

Referenced by finalize(), prime(), and tool_change().

Here is the call graph for this function:

Here is the caller graph for this function:

finalize()

std::string Slic3r::WipeTowerIntegration::finalize

(

GCode &

gcodegen

)

    {
        std::string gcode;
        if (std::abs(gcodegen.writer().get_position().z() - m_final_purge.print_z) > EPSILON)
            gcode += gcodegen.change_layer(m_final_purge.print_z);
        gcode += append_tcr(gcodegen, m_final_purge, -1);
        return gcode;
    }

References append_tcr(), Slic3r::GCode::change_layer(), EPSILON, Slic3r::GCodeWriter::get_position(), m_final_purge, Slic3r::WipeTower::ToolChangeResult::print_z, and Slic3r::GCode::writer().

Here is the call graph for this function:

next_layer()

void Slic3r::WipeTowerIntegration::next_layer ( )

inline

{ ++ m_layer_idx; m_tool_change_idx = 0; }

References m_layer_idx, and m_tool_change_idx.

operator=()

WipeTowerIntegration & Slic3r::WipeTowerIntegration::operator= ( const WipeTowerIntegration &  )

private

post_process_wipe_tower_moves()

std::string Slic3r::WipeTowerIntegration::post_process_wipe_tower_moves ( const WipeTower::ToolChangeResult &  tcr, const Vec2f &  translation, float  angle  ) const

private

    {
        Vec2f extruder_offset = m_extruder_offsets[tcr.initial_tool].cast<float>();
 
        std::istringstream gcode_str(tcr.gcode);
        std::string gcode_out;
        std::string line;
        Vec2f pos = tcr.start_pos;
        Vec2f transformed_pos = Eigen::Rotation2Df(angle) * pos + translation;
        Vec2f old_pos(-1000.1f, -1000.1f);
 
        while (gcode_str) {
            std::getline(gcode_str, line);  // we read the gcode line by line
 
            // All G1 commands should be translated and rotated. X and Y coords are
            // only pushed to the output when they differ from last time.
            // WT generator can override this by appending the never_skip_tag
            if (boost::starts_with(line, "G1 ")) {
                bool never_skip = false;
                auto it = line.find(WipeTower::never_skip_tag());
                if (it != std::string::npos) {
                    // remove the tag and remember we saw it
                    never_skip = true;
                    line.erase(it, it + WipeTower::never_skip_tag().size());
                }
                std::ostringstream line_out;
                std::istringstream line_str(line);
                line_str >> std::noskipws;  // don't skip whitespace
                char ch = 0;
                line_str >> ch >> ch; // read the "G1"
                while (line_str >> ch) {
                    if (ch == 'X' || ch == 'Y')
                        line_str >> (ch == 'X' ? pos.x() : pos.y());
                    else
                        line_out << ch;
                }
 
                transformed_pos = Eigen::Rotation2Df(angle) * pos + translation;
 
                if (transformed_pos != old_pos || never_skip) {
                    line = line_out.str();
                    boost::trim_left(line); // Remove leading spaces
                    std::ostringstream oss;
                    oss << std::fixed << std::setprecision(3) << "G1";
                    if (transformed_pos.x() != old_pos.x() || never_skip)
                        oss << " X" << transformed_pos.x() - extruder_offset.x();
                    if (transformed_pos.y() != old_pos.y() || never_skip)
                        oss << " Y" << transformed_pos.y() - extruder_offset.y();
                    if (! line.empty())
                        oss << " ";
                    line = oss.str() + line;
                    old_pos = transformed_pos;
                }
            }
 
            gcode_out += line + "\n";
 
            // If this was a toolchange command, we should change current extruder offset
            if (line == "[toolchange_gcode]") {
                extruder_offset = m_extruder_offsets[tcr.new_tool].cast<float>();
 
                // If the extruder offset changed, add an extra move so everything is continuous
                if (extruder_offset != m_extruder_offsets[tcr.initial_tool].cast<float>()) {
                    std::ostringstream oss;
                    oss << std::fixed << std::setprecision(3)
                        << "G1 X" << transformed_pos.x() - extruder_offset.x()
                        << " Y" << transformed_pos.y() - extruder_offset.y()
                        << "\n";
                    gcode_out += oss.str();
                }
            }
        }
        return gcode_out;
    }

References Slic3r::angle(), Slic3r::WipeTower::ToolChangeResult::gcode, Slic3r::WipeTower::ToolChangeResult::initial_tool, m_extruder_offsets, Slic3r::WipeTower::never_skip_tag(), Slic3r::WipeTower::ToolChangeResult::new_tool, and Slic3r::WipeTower::ToolChangeResult::start_pos.

Referenced by append_tcr().

Here is the call graph for this function:

Here is the caller graph for this function:

prime()

std::string Slic3r::WipeTowerIntegration::prime

(

GCode &

gcodegen

)

    {
        std::string gcode;
        for (const WipeTower::ToolChangeResult& tcr : m_priming) {
            if (! tcr.extrusions.empty())
                gcode += append_tcr(gcodegen, tcr, tcr.new_tool);
        }
        return gcode;
    }

References append_tcr(), and m_priming.

Here is the call graph for this function:

tool_change()

std::string Slic3r::WipeTowerIntegration::tool_change	(	GCode &	gcodegen,
		int	extruder_id,
		bool	finish_layer
	)

    {
        std::string gcode;
        assert(m_layer_idx >= 0);
        if (gcodegen.writer().need_toolchange(extruder_id) || finish_layer) {
            if (m_layer_idx < (int)m_tool_changes.size()) {
                if (!(size_t(m_tool_change_idx) < m_tool_changes[m_layer_idx].size()))
                    throw Slic3r::RuntimeError("Wipe tower generation failed, possibly due to empty first layer.");
 
                // Calculate where the wipe tower layer will be printed. -1 means that print z will not change,
                // resulting in a wipe tower with sparse layers.
                double wipe_tower_z = -1;
                bool ignore_sparse = false;
                if (gcodegen.config().wipe_tower_no_sparse_layers.value) {
                    wipe_tower_z = m_last_wipe_tower_print_z;
                    ignore_sparse = (m_tool_changes[m_layer_idx].size() == 1 && m_tool_changes[m_layer_idx].front().initial_tool == m_tool_changes[m_layer_idx].front().new_tool && m_layer_idx != 0);
                    if (m_tool_change_idx == 0 && !ignore_sparse)
                        wipe_tower_z = m_last_wipe_tower_print_z + m_tool_changes[m_layer_idx].front().layer_height;
                }
 
                if (!ignore_sparse) {
                    gcode += append_tcr(gcodegen, m_tool_changes[m_layer_idx][m_tool_change_idx++], extruder_id, wipe_tower_z);
                    m_last_wipe_tower_print_z = wipe_tower_z;
                }
            }
        }
        return gcode;
    }

References append_tcr(), Slic3r::GCode::config(), m_last_wipe_tower_print_z, m_layer_idx, m_tool_change_idx, m_tool_changes, Slic3r::GCodeWriter::need_toolchange(), and Slic3r::GCode::writer().

Here is the call graph for this function:

used_filament_length()

std::vector< float > Slic3r::WipeTowerIntegration::used_filament_length

(

)

const

Member Data Documentation

m_extruder_offsets

const std::vector<Vec2d> Slic3r::WipeTowerIntegration::m_extruder_offsets

private

Referenced by post_process_wipe_tower_moves().

m_final_purge

const WipeTower::ToolChangeResult& Slic3r::WipeTowerIntegration::m_final_purge

private

Referenced by finalize().

m_last_wipe_tower_print_z

double Slic3r::WipeTowerIntegration::m_last_wipe_tower_print_z = 0.f

private

Referenced by tool_change().

m_layer_idx

int Slic3r::WipeTowerIntegration::m_layer_idx

private

Referenced by next_layer(), and tool_change().

m_left

const float Slic3r::WipeTowerIntegration::m_left

private

m_priming

const std::vector<WipeTower::ToolChangeResult>& Slic3r::WipeTowerIntegration::m_priming

private

Referenced by prime().

m_right

const float Slic3r::WipeTowerIntegration::m_right

private

m_tool_change_idx

int Slic3r::WipeTowerIntegration::m_tool_change_idx

private

Referenced by next_layer(), and tool_change().

m_tool_changes

const std::vector<std::vector<WipeTower::ToolChangeResult> >& Slic3r::WipeTowerIntegration::m_tool_changes

private

Referenced by tool_change().

m_wipe_tower_pos

const Vec2f Slic3r::WipeTowerIntegration::m_wipe_tower_pos

private

Referenced by append_tcr().

m_wipe_tower_rotation

const float Slic3r::WipeTowerIntegration::m_wipe_tower_rotation

private

Referenced by append_tcr().

---

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

• src/libslic3r/GCode.hpp
• src/libslic3r/GCode.cpp