Slic3r::WipingExtrusions Class Reference

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

Collaboration diagram for Slic3r::WipingExtrusions:

Public Types
typedef boost::container::small_vector< int32_t, 3 >	ExtruderPerCopy

Public Member Functions
bool	is_anything_overridden () const
const ExtruderPerCopy *	get_extruder_overrides (const ExtrusionEntity *entity, const PrintObject *object, int correct_extruder_id, size_t num_of_copies)
int	get_support_extruder_overrides (const PrintObject *object)
int	get_support_interface_extruder_overrides (const PrintObject *object)
float	mark_wiping_extrusions (const Print &print, unsigned int old_extruder, unsigned int new_extruder, float volume_to_wipe)
void	ensure_perimeters_infills_order (const Print &print)
bool	is_overriddable (const ExtrusionEntityCollection &ee, const PrintConfig &print_config, const PrintObject &object, const PrintRegion &region) const
bool	is_overriddable_and_mark (const ExtrusionEntityCollection &ee, const PrintConfig &print_config, const PrintObject &object, const PrintRegion &region)
bool	is_support_overriddable (const ExtrusionRole role, const PrintObject &object) const
bool	is_support_overriddable_and_mark (const ExtrusionRole role, const PrintObject &object)
bool	is_support_overridden (const PrintObject *object) const
bool	is_support_interface_overridden (const PrintObject *object) const
void	set_layer_tools_ptr (const LayerTools *lt)
bool	is_entity_overridden (const ExtrusionEntity *entity, const PrintObject *object, size_t copy_id) const

Private Member Functions
int	first_nonsoluble_extruder_on_layer (const PrintConfig &print_config) const
int	last_nonsoluble_extruder_on_layer (const PrintConfig &print_config) const
void	set_extruder_override (const ExtrusionEntity *entity, const PrintObject *object, size_t copy_id, int extruder, size_t num_of_copies)
void	set_support_extruder_override (const PrintObject *object, size_t copy_id, int extruder, size_t num_of_copies)
void	set_support_interface_extruder_override (const PrintObject *object, size_t copy_id, int extruder, size_t num_of_copies)

Private Attributes
std::map< std::tuple< const ExtrusionEntity *, const PrintObject * >, ExtruderPerCopy >	entity_map
std::map< const PrintObject *, int >	support_map
std::map< const PrintObject *, int >	support_intf_map
bool	something_overridable = false
bool	something_overridden = false
const LayerTools *	m_layer_tools = nullptr

Detailed Description

Member Typedef Documentation

ExtruderPerCopy

typedef boost::container::small_vector<int32_t, 3> Slic3r::WipingExtrusions::ExtruderPerCopy

Member Function Documentation

ensure_perimeters_infills_order()

void Slic3r::WipingExtrusions::ensure_perimeters_infills_order

(

const Print &

print

)

{
  if (! this->something_overridable)
    return;
 
    const LayerTools& lt = *m_layer_tools;
    unsigned int first_nonsoluble_extruder = first_nonsoluble_extruder_on_layer(print.config());
    unsigned int last_nonsoluble_extruder = last_nonsoluble_extruder_on_layer(print.config());
 
    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();
                //BBS
                if (!object->config().flush_into_infill && !object->config().flush_into_objects)
                    continue;
 
                bool is_infill_first = region.config().is_infill_first;
                for (const ExtrusionEntity* ee : layerm->fills.entities) {                      // iterate through all infill Collections
                    auto* fill = dynamic_cast<const ExtrusionEntityCollection*>(ee);
 
                    if (!is_overriddable(*fill, print.config(), *object, region)
                     || is_entity_overridden(fill, object, 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:
                    //BBS
                    if (is_infill_first
                    //BBS
                    //|| object->config().flush_into_objects  // in this case the perimeter is overridden, so we can override by the last one safely
                    || lt.is_extruder_order(lt.wall_extruder_id(region), last_nonsoluble_extruder    // !infill_first, but perimeter is already printed when last extruder prints
                    || ! lt.has_extruder(lt.sparse_infill_filament_id(region)))) // we have to force override - this could violate infill_first (FIXME)
                        set_extruder_override(fill, object, copy, (is_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.entities) {                      // iterate through all perimeter Collections
                    auto* fill = dynamic_cast<const ExtrusionEntityCollection*>(ee);
                    if (is_overriddable(*fill, print.config(), *object, region) && ! is_entity_overridden(fill, object, copy))
                        set_extruder_override(fill, object, copy, (is_infill_first ? last_nonsoluble_extruder : first_nonsoluble_extruder), num_of_copies);
                }
            }
        }
    }
}

References Slic3r::Print::config(), ensure_perimeters_infills_order(), EPSILON, first_nonsoluble_extruder_on_layer(), Slic3r::LayerTools::has_extruder(), is_entity_overridden(), Slic3r::LayerTools::is_extruder_order(), Slic3r::is_infill_first(), is_overriddable(), last_nonsoluble_extruder_on_layer(), m_layer_tools, Slic3r::Print::objects(), Slic3r::LayerTools::print_z, Slic3r::Layer::regions(), set_extruder_override(), something_overridable, Slic3r::LayerTools::sparse_infill_filament_id(), and Slic3r::LayerTools::wall_extruder_id().

Referenced by ensure_perimeters_infills_order().

Here is the call graph for this function:

Here is the caller graph for this function:

first_nonsoluble_extruder_on_layer()

int Slic3r::WipingExtrusions::first_nonsoluble_extruder_on_layer ( const PrintConfig & print_config ) const

private

{
    const LayerTools& lt = *m_layer_tools;
    for (auto extruders_it = lt.extruders.begin(); extruders_it != lt.extruders.end(); ++extruders_it)
        if (!print_config.filament_soluble.get_at(*extruders_it) && !print_config.filament_is_support.get_at(*extruders_it))
            return (*extruders_it);
 
    return (-1);
}

References Slic3r::LayerTools::extruders, first_nonsoluble_extruder_on_layer(), and m_layer_tools.

Referenced by ensure_perimeters_infills_order(), and first_nonsoluble_extruder_on_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

get_extruder_overrides()

const WipingExtrusions::ExtruderPerCopy * Slic3r::WipingExtrusions::get_extruder_overrides	(	const ExtrusionEntity *	entity,
		const PrintObject *	object,
		int	correct_extruder_id,
		size_t	num_of_copies )

{
  ExtruderPerCopy *overrides = nullptr;
    auto entity_map_it = entity_map.find(std::make_tuple(entity, object));
    if (entity_map_it != entity_map.end()) {
        overrides = &entity_map_it->second;
      overrides->resize(num_of_copies, -1);
      // Each -1 now means "print as usual" - we will replace it with actual extruder id (shifted it so we don't lose that information):
      std::replace(overrides->begin(), overrides->end(), -1, -correct_extruder_id-1);
  }
    return overrides;
}

References entity_map, and get_extruder_overrides().

Referenced by get_extruder_overrides().

Here is the call graph for this function:

Here is the caller graph for this function:

get_support_extruder_overrides()

int Slic3r::WipingExtrusions::get_support_extruder_overrides

(

const PrintObject *

object

)

{
    auto iter = support_map.find(object);
    if (iter != support_map.end())
        return iter->second;
 
    return -1;
}

References get_support_extruder_overrides(), and support_map.

Referenced by get_support_extruder_overrides(), and Slic3r::GCode::process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

get_support_interface_extruder_overrides()

int Slic3r::WipingExtrusions::get_support_interface_extruder_overrides

(

const PrintObject *

object

)

{
    auto iter = support_intf_map.find(object);
    if (iter != support_intf_map.end())
        return iter->second;
 
    return -1;
}

References get_support_interface_extruder_overrides(), and support_intf_map.

Referenced by get_support_interface_extruder_overrides(), and Slic3r::GCode::process_layer().

Here is the call graph for this function:

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 something_overridden;
    }

References something_overridden.

is_entity_overridden()

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

inline

                                                                                                              {
        auto it = entity_map.find(std::make_tuple(entity, object));
        return it != entity_map.end() && copy_id < it->second.size() && it->second[copy_id] != -1;
    }

References entity_map.

Referenced by ensure_perimeters_infills_order().

Here is the caller graph for this function:

is_overriddable()

bool Slic3r::WipingExtrusions::is_overriddable	(	const ExtrusionEntityCollection &	ee,
		const PrintConfig &	print_config,
		const PrintObject &	object,
		const PrintRegion &	region ) const

{
    if (print_config.filament_soluble.get_at(m_layer_tools->extruder(eec, region)))
        return false;
 
    if (object.config().flush_into_objects)
        return true;
 
    if (!object.config().flush_into_infill || eec.role() != erInternalInfill)
        return false;
 
    return true;
}

References Slic3r::erInternalInfill, is_overriddable(), m_layer_tools, and Slic3r::ExtrusionEntityCollection::role().

Referenced by ensure_perimeters_infills_order(), is_overriddable(), and is_overriddable_and_mark().

Here is the call graph for this function:

Here is the caller graph for this function:

is_overriddable_and_mark()

bool Slic3r::WipingExtrusions::is_overriddable_and_mark ( const ExtrusionEntityCollection & ee, const PrintConfig & print_config, const PrintObject & object, const PrintRegion & region )

inline

                                                                                                                                                              {
      bool out = this->is_overriddable(ee, print_config, object, region);
      this->something_overridable |= out;
      return out;
    }

References is_overriddable(), and something_overridable.

Here is the call graph for this function:

is_support_interface_overridden()

bool Slic3r::WipingExtrusions::is_support_interface_overridden ( const PrintObject * object ) const

inline

                                                                          {
        return support_intf_map.find(object) != support_intf_map.end();
    }

References support_intf_map.

is_support_overriddable()

bool Slic3r::WipingExtrusions::is_support_overriddable	(	const ExtrusionRole	role,
		const PrintObject &	object ) const

{
    if (!object.config().flush_into_support)
        return false;
 
    if (role == erMixed) {
        return object.config().support_filament == 0 || object.config().support_interface_filament == 0;
    }
    else if (role == erSupportMaterial || role == erSupportTransition) {
        return object.config().support_filament == 0;
    }
    else if (role == erSupportMaterialInterface) {
        return object.config().support_interface_filament == 0;
    }
 
    return false;
}

References Slic3r::erMixed, Slic3r::erSupportMaterial, Slic3r::erSupportMaterialInterface, Slic3r::erSupportTransition, and is_support_overriddable().

Referenced by is_support_overriddable(), and is_support_overriddable_and_mark().

Here is the call graph for this function:

Here is the caller graph for this function:

is_support_overriddable_and_mark()

bool Slic3r::WipingExtrusions::is_support_overriddable_and_mark ( const ExtrusionRole role, const PrintObject & object )

inline

                                                                                               {
        bool out = this->is_support_overriddable(role, object);
        this->something_overridable |= out;
        return out;
    }

References is_support_overriddable(), and something_overridable.

Here is the call graph for this function:

is_support_overridden()

bool Slic3r::WipingExtrusions::is_support_overridden ( const PrintObject * object ) const

inline

                                                                {
        return support_map.find(object) != support_map.end();
    }

References support_map.

last_nonsoluble_extruder_on_layer()

int Slic3r::WipingExtrusions::last_nonsoluble_extruder_on_layer ( const PrintConfig & print_config ) const

private

{
    const LayerTools& lt = *m_layer_tools;
    for (auto extruders_it = lt.extruders.rbegin(); extruders_it != lt.extruders.rend(); ++extruders_it)
        if (!print_config.filament_soluble.get_at(*extruders_it) && !print_config.filament_is_support.get_at(*extruders_it))
            return (*extruders_it);
 
    return (-1);
}

References Slic3r::LayerTools::extruders, last_nonsoluble_extruder_on_layer(), and m_layer_tools.

Referenced by ensure_perimeters_infills_order(), and last_nonsoluble_extruder_on_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

mark_wiping_extrusions()

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

{
    const LayerTools& lt = *m_layer_tools;
    const float min_infill_volume = 0.f; // ignore infill with smaller volume than this
 
    if (! this->something_overridable || volume_to_wipe <= 0. || print.config().filament_soluble.get_at(old_extruder) || print.config().filament_soluble.get_at(new_extruder))
        return std::max(0.f, volume_to_wipe); // Soluble filament cannot be wiped in a random infill, neither the filament after it
 
    // BBS
    if (print.config().filament_is_support.get_at(old_extruder) || print.config().filament_is_support.get_at(new_extruder))
        return std::max(0.f, volume_to_wipe); // Support filament cannot be used to print support, infill, wipe_tower, etc.
 
    // we will sort objects so that dedicated for wiping are at the beginning:
    ConstPrintObjectPtrs object_list = print.objects().vector();
    // BBS: fix the exception caused by not fixed order between different objects
    std::sort(object_list.begin(), object_list.end(), [object_list](const PrintObject* a, const PrintObject* b) {
        if (a->config().flush_into_objects != b->config().flush_into_objects) {
            return a->config().flush_into_objects.getBool();
        }
        else {
            return a->id() < b->id();
        }
    });
 
    // 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().flush_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 (!object->config().flush_into_infill && !object->config().flush_into_objects && !object->config().flush_into_support)
                    continue;
                bool wipe_into_infill_only = !object->config().flush_into_objects && object->config().flush_into_infill;
                bool is_infill_first = region.config().is_infill_first;
                if (is_infill_first != perimeters_done || wipe_into_infill_only) {
                    for (const ExtrusionEntity* ee : layerm->fills.entities) {                      // iterate through all infill Collections
                        auto* fill = dynamic_cast<const ExtrusionEntityCollection*>(ee);
 
                        if (!is_overriddable(*fill, print.config(), *object, region))
                            continue;
 
                        if (wipe_into_infill_only && ! is_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.wall_extruder_id(region), new_extruder))
                                continue;
 
                        if ((!is_entity_overridden(fill, object, copy) && fill->total_volume() > min_infill_volume))
                        {     // this infill will be used to wipe this extruder
                            set_extruder_override(fill, object, 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().flush_into_objects && is_infill_first == perimeters_done)
                {
                    for (const ExtrusionEntity* ee : layerm->perimeters.entities) {
                        auto* fill = dynamic_cast<const ExtrusionEntityCollection*>(ee);
                        if (is_overriddable(*fill, print.config(), *object, region) && !is_entity_overridden(fill, object, copy) && fill->total_volume() > min_infill_volume) {
                            set_extruder_override(fill, object, 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;
                        }
                    }
                }
            }
 
            // BBS
            if (object->config().flush_into_support) {
                auto& object_config = object->config();
                const SupportLayer* this_support_layer = object->get_support_layer_at_printz(lt.print_z, EPSILON);
 
                do {
                    if (this_support_layer == nullptr)
                        break;
 
                    bool support_overriddable = object_config.support_filament == 0;
                    bool support_intf_overriddable = object_config.support_interface_filament == 0;
                    if (!support_overriddable && !support_intf_overriddable)
                        break;
 
                    auto &entities = this_support_layer->support_fills.entities;
                    if (support_overriddable && !is_support_overridden(object) && !(object_config.support_interface_not_for_body.value && !support_intf_overriddable &&(new_extruder==object_config.support_interface_filament-1||old_extruder==object_config.support_interface_filament-1))) {
                        set_support_extruder_override(object, copy, new_extruder, num_of_copies);
                        for (const ExtrusionEntity* ee : entities) {
                            if (ee->role() == erSupportMaterial || ee->role() == erSupportTransition)
                                volume_to_wipe -= ee->total_volume();
 
                            if (volume_to_wipe <= 0.f)
                                return 0.f;
                        }
                    }
 
                    if (support_intf_overriddable && !is_support_interface_overridden(object)) {
                        set_support_interface_extruder_override(object, copy, new_extruder, num_of_copies);
                        for (const ExtrusionEntity* ee : entities) {
                            if (ee->role() == erSupportMaterialInterface)
                                volume_to_wipe -= ee->total_volume();
 
                            if (volume_to_wipe <= 0.f)
                                return 0.f;
                        }
                    }
                } while (0);
            }
        }
    }
  // Some purge remains to be done on the Wipe Tower.
    assert(volume_to_wipe > 0.);
    return volume_to_wipe;
}

References Slic3r::Print::config(), m_layer_tools, mark_wiping_extrusions(), Slic3r::Print::objects(), something_overridable, and Slic3r::ConstVectorOfPtrsAdaptor< T >::vector().

Referenced by mark_wiping_extrusions().

Here is the call graph for this function:

Here is the caller graph for this function:

set_extruder_override()

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

private

{
    something_overridden = true;
 
    auto entity_map_it = (entity_map.emplace(std::make_tuple(entity, object), ExtruderPerCopy())).first; // (add and) return iterator
    ExtruderPerCopy& copies_vector = entity_map_it->second;
    copies_vector.resize(num_of_copies, -1);
 
    if (copies_vector[copy_id] != -1)
        std::cout << "ERROR: Entity extruder overriden multiple times!!!\n";    // A debugging message - this must never happen.
 
    copies_vector[copy_id] = extruder;
}

References entity_map, set_extruder_override(), and something_overridden.

Referenced by ensure_perimeters_infills_order(), and set_extruder_override().

Here is the call graph for this function:

Here is the caller graph for this function:

set_layer_tools_ptr()

void Slic3r::WipingExtrusions::set_layer_tools_ptr ( const LayerTools * lt )

inline

{ m_layer_tools = lt; }

References m_layer_tools.

set_support_extruder_override()

void Slic3r::WipingExtrusions::set_support_extruder_override ( const PrintObject * object, size_t copy_id, int extruder, size_t num_of_copies )

private

{
    something_overridden = true;
    support_map.emplace(object, extruder);
}

References set_support_extruder_override(), something_overridden, and support_map.

Referenced by set_support_extruder_override().

Here is the call graph for this function:

Here is the caller graph for this function:

set_support_interface_extruder_override()

void Slic3r::WipingExtrusions::set_support_interface_extruder_override ( const PrintObject * object, size_t copy_id, int extruder, size_t num_of_copies )

private

{
    something_overridden = true;
    support_intf_map.emplace(object, extruder);
}

References set_support_interface_extruder_override(), something_overridden, and support_intf_map.

Referenced by set_support_interface_extruder_override().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

entity_map

std::map<std::tuple<const ExtrusionEntity*, const PrintObject *>, ExtruderPerCopy> Slic3r::WipingExtrusions::entity_map

private

Referenced by get_extruder_overrides(), is_entity_overridden(), and set_extruder_override().

m_layer_tools

const LayerTools* Slic3r::WipingExtrusions::m_layer_tools = nullptr

private

Referenced by ensure_perimeters_infills_order(), first_nonsoluble_extruder_on_layer(), is_overriddable(), last_nonsoluble_extruder_on_layer(), mark_wiping_extrusions(), and set_layer_tools_ptr().

something_overridable

bool Slic3r::WipingExtrusions::something_overridable = false

private

Referenced by ensure_perimeters_infills_order(), is_overriddable_and_mark(), is_support_overriddable_and_mark(), and mark_wiping_extrusions().

something_overridden

bool Slic3r::WipingExtrusions::something_overridden = false

private

Referenced by is_anything_overridden(), set_extruder_override(), set_support_extruder_override(), and set_support_interface_extruder_override().

support_intf_map

std::map<const PrintObject*, int> Slic3r::WipingExtrusions::support_intf_map

private

Referenced by get_support_interface_extruder_overrides(), is_support_interface_overridden(), and set_support_interface_extruder_override().

support_map

std::map<const PrintObject*, int> Slic3r::WipingExtrusions::support_map

private

Referenced by get_support_extruder_overrides(), is_support_overridden(), and set_support_extruder_override().

---

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

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