#include <src/libslic3r/GCode/ToolOrdering.hpp>

Collaboration diagram for Slic3r::WipingExtrusions:

Public Types
using	ExtruderPerCopy = std::vector< int32_t >

Public Member Functions
bool	is_anything_overridden () const

int	get_extruder_override (const ExtrusionEntity *entity, uint32_t instance_id) const

float	mark_wiping_extrusions (const Print &print, const LayerTools &lt, unsigned int old_extruder, unsigned int new_extruder, float volume_to_wipe)

void	ensure_perimeters_infills_order (const Print &print, const LayerTools &lt)

void	set_something_overridable ()

Private Member Functions
void	set_extruder_override (const ExtrusionEntity *entity, size_t copy_id, int extruder, size_t num_of_copies)

bool	is_entity_overridden (const ExtrusionEntity *entity, size_t copy_id) const

Private Attributes
std::map< const ExtrusionEntity *, ExtruderPerCopy >	m_entity_map

bool	m_something_overridable = false

bool	m_something_overridden = false

Detailed Description

Member Typedef Documentation

◆ ExtruderPerCopy

using Slic3r::WipingExtrusions::ExtruderPerCopy = std::vector<int32_t>

Member Function Documentation

◆ ensure_perimeters_infills_order()

void Slic3r::WipingExtrusions::ensure_perimeters_infills_order	(	const Print &	print,
		const LayerTools &	lt
	)

{
  if (! m_something_overridable)
    return;
 
    unsigned int first_nonsoluble_extruder = first_nonsoluble_extruder_on_layer(print.config(), lt);
    unsigned int last_nonsoluble_extruder = last_nonsoluble_extruder_on_layer(print.config(), lt);
 
    for (const PrintObject* object : print.objects()) {
        // Finds this layer:
        const Layer* this_layer = object->get_layer_at_printz(lt.print_z, EPSILON);
        if (this_layer == nullptr)
          continue;
        size_t num_of_copies = object->instances().size();
 
        for (size_t copy = 0; copy < num_of_copies; ++copy) {    // iterate through copies first, so that we mark neighbouring infills to minimize travel moves
            for (const LayerRegion *layerm : this_layer->regions()) {
                const auto &region = layerm->region();
                if (!region.config().wipe_into_infill && !object->config().wipe_into_objects)
                    continue;
 
                for (const ExtrusionEntity* ee : layerm->fills()) { // iterate through all infill Collections
                    auto* fill = dynamic_cast<const ExtrusionEntityCollection*>(ee);
                    assert(fill);
 
                    if (!is_overriddable(*fill, lt, print.config(), *object, region)
                     || is_entity_overridden(fill, copy) )
                        continue;
 
                    // This infill could have been overridden but was not - unless we do something, it could be
                    // printed before its perimeter, or not be printed at all (in case its original extruder has
                    // not been added to LayerTools
                    // Either way, we will now force-override it with something suitable:
                    if (print.config().infill_first
                    || object->config().wipe_into_objects  // in this case the perimeter is overridden, so we can override by the last one safely
                    || lt.is_extruder_order(lt.perimeter_extruder(region), last_nonsoluble_extruder)    // !infill_first, but perimeter is already printed when last extruder prints
                    || ! lt.has_extruder(lt.infill_extruder(region))) // we have to force override - this could violate infill_first (FIXME)
                        set_extruder_override(fill, copy, (print.config().infill_first ? first_nonsoluble_extruder : last_nonsoluble_extruder), num_of_copies);
                    else {
                        // In this case we can (and should) leave it to be printed normally.
                        // Force overriding would mean it gets printed before its perimeter.
                    }
                }
 
                // Now the same for perimeters - see comments above for explanation:
                for (const ExtrusionEntity* ee : layerm->perimeters()) { // iterate through all perimeter Collections
                    auto* fill = dynamic_cast<const ExtrusionEntityCollection*>(ee);
                    assert(fill);
                    if (is_overriddable(*fill, lt, print.config(), *object, region) && ! is_entity_overridden(fill, copy))
                        set_extruder_override(fill, copy, (print.config().infill_first ? last_nonsoluble_extruder : first_nonsoluble_extruder), num_of_copies);
                }
            }
        }
    }
}

References Slic3r::Print::config(), EPSILON, Slic3r::first_nonsoluble_extruder_on_layer(), Slic3r::LayerTools::has_extruder(), Slic3r::LayerTools::infill_extruder(), is_entity_overridden(), Slic3r::LayerTools::is_extruder_order(), Slic3r::is_overriddable(), Slic3r::last_nonsoluble_extruder_on_layer(), m_something_overridable, Slic3r::Print::objects(), Slic3r::LayerTools::perimeter_extruder(), Slic3r::LayerTools::print_z, Slic3r::Layer::regions(), and set_extruder_override().

Here is the call graph for this function:

◆ get_extruder_override()

int Slic3r::WipingExtrusions::get_extruder_override	(	const ExtrusionEntity *	entity,
		uint32_t	instance_id
	)		const

inline

                                                                                         {
        auto entity_map_it = m_entity_map.find(entity);
        return entity_map_it == m_entity_map.end() ? -1 : entity_map_it->second[instance_id];
    }

References m_entity_map.

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

Here is the caller graph for this function:

◆ is_anything_overridden()

bool Slic3r::WipingExtrusions::is_anything_overridden ( ) const

inline

                                        {   // if there are no overrides, all the agenda can be skipped - this function can tell us if that's the case
        return m_something_overridden;
    }

References m_something_overridden.

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

Here is the caller graph for this function:

◆ is_entity_overridden()

bool Slic3r::WipingExtrusions::is_entity_overridden	(	const ExtrusionEntity *	entity,
		size_t	copy_id
	)		const

inlineprivate

                                                                                   {
        auto it = m_entity_map.find(entity);
        return it == m_entity_map.end() ? false : it->second[copy_id] != -1;
    }

References m_entity_map.

Referenced by ensure_perimeters_infills_order(), and mark_wiping_extrusions().

Here is the caller graph for this function:

◆ mark_wiping_extrusions()

float Slic3r::WipingExtrusions::mark_wiping_extrusions	(	const Print &	print,
		const LayerTools &	lt,
		unsigned int	old_extruder,
		unsigned int	new_extruder,
		float	volume_to_wipe
	)

{
    const float min_infill_volume = 0.f; // ignore infill with smaller volume than this
 
    if (! m_something_overridable || volume_to_wipe <= 0. || 
        // Don't wipe a soluble filament into another object.
        print.config().filament_soluble.get_at(old_extruder) || 
        // Don't prime a soluble filament into another object.
        print.config().filament_soluble.get_at(new_extruder))
        // Soluble filament cannot be wiped in a random infill, neither the filament after it
        return std::max(0.f, volume_to_wipe);
 
    // we will sort objects so that dedicated for wiping are at the beginning:
    ConstPrintObjectPtrs object_list(print.objects().begin(), print.objects().end());
    std::sort(object_list.begin(), object_list.end(), [](const PrintObject* a, const PrintObject* b) { return a->config().wipe_into_objects && ! b->config().wipe_into_objects; });
 
    // We will now iterate through
    //  - first the dedicated objects to mark perimeters or infills (depending on infill_first)
    //  - second through the dedicated ones again to mark infills or perimeters (depending on infill_first)
    //  - then all the others to mark infills (in case that !infill_first, we must also check that the perimeter is finished already
    // this is controlled by the following variable:
    bool perimeters_done = false;
 
    for (int i=0 ; i<(int)object_list.size() + (perimeters_done ? 0 : 1); ++i) {
        if (!perimeters_done && (i==(int)object_list.size() || !object_list[i]->config().wipe_into_objects)) { // we passed the last dedicated object in list
            perimeters_done = true;
            i=-1;   // let's go from the start again
            continue;
        }
 
        const PrintObject* object = object_list[i];
 
        // Finds this layer:
        const Layer* this_layer = object->get_layer_at_printz(lt.print_z, EPSILON);
        if (this_layer == nullptr)
          continue;
        size_t num_of_copies = object->instances().size();
 
        // iterate through copies (aka PrintObject instances) first, so that we mark neighbouring infills to minimize travel moves
        for (unsigned int copy = 0; copy < num_of_copies; ++copy) {
            for (const LayerRegion *layerm : this_layer->regions()) {
                const auto &region = layerm->region();
                if (!region.config().wipe_into_infill && !object->config().wipe_into_objects)
                    continue;
 
                bool wipe_into_infill_only = ! object->config().wipe_into_objects && region.config().wipe_into_infill;
                if (print.config().infill_first != perimeters_done || wipe_into_infill_only) {
                    for (const ExtrusionEntity* ee : layerm->fills()) { // iterate through all infill Collections
                        auto* fill = dynamic_cast<const ExtrusionEntityCollection*>(ee);
 
                        if (!is_overriddable(*fill, lt, print.config(), *object, region))
                            continue;
 
                        if (wipe_into_infill_only && ! print.config().infill_first)
                            // In this case we must check that the original extruder is used on this layer before the one we are overridding
                            // (and the perimeters will be finished before the infill is printed):
                            if (!lt.is_extruder_order(lt.perimeter_extruder(region), new_extruder))
                                continue;
 
                        if ((!is_entity_overridden(fill, copy) && fill->total_volume() > min_infill_volume)) {     // this infill will be used to wipe this extruder
                            set_extruder_override(fill, copy, new_extruder, num_of_copies);
                            if ((volume_to_wipe -= float(fill->total_volume())) <= 0.f)
                              // More material was purged already than asked for.
                              return 0.f;
                        }
                    }
                }
 
                // Now the same for perimeters - see comments above for explanation:
                if (object->config().wipe_into_objects && print.config().infill_first == perimeters_done)
                {
                    for (const ExtrusionEntity* ee : layerm->perimeters()) {
                        auto* fill = dynamic_cast<const ExtrusionEntityCollection*>(ee);
                        if (is_overriddable(*fill, lt, print.config(), *object, region) && !is_entity_overridden(fill, copy) && fill->total_volume() > min_infill_volume) {
                            set_extruder_override(fill, copy, new_extruder, num_of_copies);
                            if ((volume_to_wipe -= float(fill->total_volume())) <= 0.f)
                              // More material was purged already than asked for.
                              return 0.f;
                        }
                    }
                }
            }
        }
    }
  // Some purge remains to be done on the Wipe Tower.
    assert(volume_to_wipe > 0.);
    return volume_to_wipe;
}

References Slic3r::PrintObject::config(), Slic3r::Print::config(), EPSILON, is_entity_overridden(), Slic3r::LayerTools::is_extruder_order(), Slic3r::is_overriddable(), m_something_overridable, Slic3r::Print::objects(), Slic3r::LayerTools::perimeter_extruder(), Slic3r::LayerTools::print_z, Slic3r::Layer::regions(), and set_extruder_override().

Here is the call graph for this function:

◆ set_extruder_override()

void Slic3r::WipingExtrusions::set_extruder_override	(	const ExtrusionEntity *	entity,
		size_t	copy_id,
		int	extruder,
		size_t	num_of_copies
	)

private

{
    m_something_overridden = true;
 
    auto entity_map_it = (m_entity_map.emplace(entity, ExtruderPerCopy())).first; // (add and) return iterator
    ExtruderPerCopy& copies_vector = entity_map_it->second;
    copies_vector.resize(num_of_copies, -1);
 
    assert(copies_vector[copy_id] == -1);
    if (copies_vector[copy_id] != -1)
        BOOST_LOG_TRIVIAL(error) << "ERROR: Entity extruder overriden multiple times!!!";
 
    copies_vector[copy_id] = extruder;
}