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

Collaboration diagram for Slic3r::ToolOrdering:

Public Member Functions
	ToolOrdering ()=default

	ToolOrdering (const PrintObject &object, unsigned int first_extruder, bool prime_multi_material=false)

	ToolOrdering (const Print &print, unsigned int first_extruder, bool prime_multi_material=false)

void	clear ()

void	assign_custom_gcodes (const Print &print)

unsigned int	first_extruder () const

unsigned int	last_extruder () const

const std::vector< unsigned int > &	all_extruders () const

const LayerTools &	tools_for_layer (coordf_t print_z) const

LayerTools &	tools_for_layer (coordf_t print_z)

const LayerTools &	front () const

const LayerTools &	back () const

std::vector< LayerTools >::const_iterator	begin () const

std::vector< LayerTools >::const_iterator	end () const

bool	empty () const

std::vector< LayerTools > &	layer_tools ()

bool	has_wipe_tower () const

Private Member Functions
void	initialize_layers (std::vector< coordf_t > &zs)

void	collect_extruders (const PrintObject &object, const std::vector< std::pair< double, unsigned int > > &per_layer_extruder_switches)

void	reorder_extruders (unsigned int last_extruder_id)

void	fill_wipe_tower_partitions (const PrintConfig &config, coordf_t object_bottom_z, coordf_t max_layer_height)

bool	insert_wipe_tower_extruder ()

void	mark_skirt_layers (const PrintConfig &config, coordf_t max_layer_height)

void	collect_extruder_statistics (bool prime_multi_material)

Private Attributes
std::vector< LayerTools >	m_layer_tools

unsigned int	m_first_printing_extruder = (unsigned int)-1

unsigned int	m_last_printing_extruder = (unsigned int)-1

std::vector< unsigned int >	m_all_printing_extruders

const PrintConfig *	m_print_config_ptr = nullptr

Detailed Description

Constructor & Destructor Documentation

◆ ToolOrdering() [1/3]

Slic3r::ToolOrdering::ToolOrdering ( )

default

◆ ToolOrdering() [2/3]

Slic3r::ToolOrdering::ToolOrdering	(	const PrintObject &	object,
		unsigned int	first_extruder,
		bool	prime_multi_material = `false`
	)

{
    if (object.layers().empty())
        return;
 
    // Initialize the print layers for just a single object.
    {
        std::vector<coordf_t> zs;
        zs.reserve(zs.size() + object.layers().size() + object.support_layers().size());
        for (auto layer : object.layers())
            zs.emplace_back(layer->print_z);
        for (auto layer : object.support_layers())
            zs.emplace_back(layer->print_z);
        this->initialize_layers(zs);
    }
    double max_layer_height = calc_max_layer_height(object.print()->config(), object.config().layer_height);
 
    // Collect extruders required to print the layers.
    this->collect_extruders(object, std::vector<std::pair<double, unsigned int>>());
 
    // Reorder the extruders to minimize tool switches.
    this->reorder_extruders(first_extruder);
 
    this->fill_wipe_tower_partitions(object.print()->config(), object.layers().front()->print_z - object.layers().front()->height, max_layer_height);
 
    this->collect_extruder_statistics(prime_multi_material);
 
    this->mark_skirt_layers(object.print()->config(), max_layer_height);
}

References Slic3r::calc_max_layer_height(), collect_extruder_statistics(), collect_extruders(), empty(), fill_wipe_tower_partitions(), front(), initialize_layers(), Slic3r::layer_height(), mark_skirt_layers(), and reorder_extruders().

Here is the call graph for this function:

◆ ToolOrdering() [3/3]

Slic3r::ToolOrdering::ToolOrdering	(	const Print &	print,
		unsigned int	first_extruder,
		bool	prime_multi_material = `false`
	)

{
    m_print_config_ptr = &print.config();
 
    // Initialize the print layers for all objects and all layers.
    coordf_t object_bottom_z = 0.;
    coordf_t max_layer_height = 0.;
    {
        std::vector<coordf_t> zs;
        for (auto object : print.objects()) {
            zs.reserve(zs.size() + object->layers().size() + object->support_layers().size());
            for (auto layer : object->layers())
                zs.emplace_back(layer->print_z);
            for (auto layer : object->support_layers())
                zs.emplace_back(layer->print_z);
 
            // Find first object layer that is not empty and save its print_z
            for (const Layer* layer : object->layers())
                if (layer->has_extrusions()) {
                    object_bottom_z = layer->print_z - layer->height;
                    break;
                }
 
            max_layer_height = std::max(max_layer_height, object->config().layer_height.value);
        }
        this->initialize_layers(zs);
    }
    max_layer_height = calc_max_layer_height(print.config(), max_layer_height);
 
  // Use the extruder switches from Model::custom_gcode_per_print_z to override the extruder to print the object.
  // Do it only if all the objects were configured to be printed with a single extruder.
  std::vector<std::pair<double, unsigned int>> per_layer_extruder_switches;
  if (auto num_extruders = unsigned(print.config().nozzle_diameter.size());
    num_extruders > 1 && print.object_extruders().size() == 1 && // the current Print's configuration is CustomGCode::MultiAsSingle
    print.model().custom_gcode_per_print_z.mode == CustomGCode::MultiAsSingle) {
    // Printing a single extruder platter on a printer with more than 1 extruder (or single-extruder multi-material).
    // There may be custom per-layer tool changes available at the model.
    per_layer_extruder_switches = custom_tool_changes(print.model().custom_gcode_per_print_z, num_extruders);
  }
 
    // Collect extruders reuqired to print the layers.
    for (auto object : print.objects())
        this->collect_extruders(*object, per_layer_extruder_switches);
 
    // Reorder the extruders to minimize tool switches.
    this->reorder_extruders(first_extruder);
 
    this->fill_wipe_tower_partitions(print.config(), object_bottom_z, max_layer_height);
 
    if (this->insert_wipe_tower_extruder()) {
        this->reorder_extruders(first_extruder);
        this->fill_wipe_tower_partitions(print.config(), object_bottom_z, max_layer_height);
    }
 
    this->collect_extruder_statistics(prime_multi_material);
 
    this->mark_skirt_layers(print.config(), max_layer_height);
}

References Slic3r::calc_max_layer_height(), collect_extruder_statistics(), collect_extruders(), Slic3r::Print::config(), Slic3r::Model::custom_gcode_per_print_z, Slic3r::CustomGCode::custom_tool_changes(), fill_wipe_tower_partitions(), initialize_layers(), insert_wipe_tower_extruder(), m_print_config_ptr, mark_skirt_layers(), Slic3r::CustomGCode::Info::mode, Slic3r::PrintBase::model(), Slic3r::CustomGCode::MultiAsSingle, Slic3r::Print::object_extruders(), Slic3r::Print::objects(), and reorder_extruders().

Here is the call graph for this function:

Member Function Documentation

◆ all_extruders()

const std::vector< unsigned int > & Slic3r::ToolOrdering::all_extruders ( ) const

inline

151{ return m_all_printing_extruders; }

Slic3r::ToolOrdering::m_all_printing_extruders

std::vector< unsigned int > m_all_printing_extruders

Definition ToolOrdering.hpp:180

References m_all_printing_extruders.

Referenced by Slic3r::GCode::_do_export(), and Slic3r::Print::_make_wipe_tower().

Here is the caller graph for this function:

◆ assign_custom_gcodes()

void Slic3r::ToolOrdering::assign_custom_gcodes ( const Print & print )

{
  // Only valid for non-sequential print.
  assert(! print.config().complete_objects.value);
 
  const CustomGCode::Info &custom_gcode_per_print_z = print.model().custom_gcode_per_print_z;
  if (custom_gcode_per_print_z.gcodes.empty())
    return;
 
  auto            num_extruders = unsigned(print.config().nozzle_diameter.size());
  CustomGCode::Mode       mode          =
    (num_extruders == 1) ? CustomGCode::SingleExtruder :
    print.object_extruders().size() == 1 ? CustomGCode::MultiAsSingle : CustomGCode::MultiExtruder;
  CustomGCode::Mode           model_mode    = print.model().custom_gcode_per_print_z.mode;
  std::vector<unsigned char>  extruder_printing_above(num_extruders, false);
  auto            custom_gcode_it = custom_gcode_per_print_z.gcodes.rbegin();
  // Tool changes and color changes will be ignored, if the model's tool/color changes were entered in mm mode and the print is in non mm mode
  // or vice versa.
  bool            ignore_tool_and_color_changes = (mode == CustomGCode::MultiExtruder) != (model_mode == CustomGCode::MultiExtruder);
  // If printing on a single extruder machine, make the tool changes trigger color change (M600) events.
  bool            tool_changes_as_color_changes = mode == CustomGCode::SingleExtruder && model_mode == CustomGCode::MultiAsSingle;
 
  // From the last layer to the first one:
  for (auto it_lt = m_layer_tools.rbegin(); it_lt != m_layer_tools.rend(); ++ it_lt) {
    LayerTools &lt = *it_lt;
    // Add the extruders of the current layer to the set of extruders printing at and above this print_z.
    for (unsigned int i : lt.extruders)
      extruder_printing_above[i] = true;
    // Skip all custom G-codes above this layer and skip all extruder switches.
    for (; custom_gcode_it != custom_gcode_per_print_z.gcodes.rend() && (custom_gcode_it->print_z > lt.print_z + EPSILON || custom_gcode_it->type == CustomGCode::ToolChange); ++ custom_gcode_it);
    if (custom_gcode_it == custom_gcode_per_print_z.gcodes.rend())
      // Custom G-codes were processed.
      break;
    // Some custom G-code is configured for this layer or a layer below.
    const CustomGCode::Item &custom_gcode = *custom_gcode_it;
    // print_z of the layer below the current layer.
    coordf_t print_z_below = 0.;
    if (auto it_lt_below = it_lt; ++ it_lt_below != m_layer_tools.rend())
      print_z_below = it_lt_below->print_z;
    if (custom_gcode.print_z > print_z_below + 0.5 * EPSILON) {
      // The custom G-code applies to the current layer.
      bool color_change = custom_gcode.type == CustomGCode::ColorChange;
      bool tool_change  = custom_gcode.type == CustomGCode::ToolChange;
      bool pause_or_custom_gcode = ! color_change && ! tool_change;
      bool apply_color_change = ! ignore_tool_and_color_changes &&
        // If it is color change, it will actually be useful as the exturder above will print.
        (color_change ? 
          mode == CustomGCode::SingleExtruder || 
            (custom_gcode.extruder <= int(num_extruders) && extruder_printing_above[unsigned(custom_gcode.extruder - 1)]) :
          tool_change && tool_changes_as_color_changes);
      if (pause_or_custom_gcode || apply_color_change)
            lt.custom_gcode = &custom_gcode;
      // Consume that custom G-code event.
      ++ custom_gcode_it;
    }
  }
}

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ back()

const LayerTools & Slic3r::ToolOrdering::back ( ) const

inline

158{ return m_layer_tools.back(); }

References m_layer_tools.

Referenced by Slic3r::Print::_make_wipe_tower().

Here is the caller graph for this function:

◆ begin()

std::vector< LayerTools >::const_iterator Slic3r::ToolOrdering::begin ( ) const

inline

159{ return m_layer_tools.begin(); }

References m_layer_tools.

Referenced by Slic3r::DoubleSlider::TickCodeInfo::get_used_extruders_for_tick().

Here is the caller graph for this function:

◆ clear()

void Slic3r::ToolOrdering::clear ( )

inline

136{ m_layer_tools.clear(); }

References m_layer_tools.

Referenced by Slic3r::Print::process().

Here is the caller graph for this function:

◆ collect_extruder_statistics()

void Slic3r::ToolOrdering::collect_extruder_statistics ( bool prime_multi_material )

private

{
    m_first_printing_extruder = (unsigned int)-1;
    for (const auto &lt : m_layer_tools)
        if (! lt.extruders.empty()) {
            m_first_printing_extruder = lt.extruders.front();
            break;
        }
 
    m_last_printing_extruder = (unsigned int)-1;
    for (auto lt_it = m_layer_tools.rbegin(); lt_it != m_layer_tools.rend(); ++ lt_it)
        if (! lt_it->extruders.empty()) {
            m_last_printing_extruder = lt_it->extruders.back();
            break;
        }
 
    m_all_printing_extruders.clear();
    for (const auto &lt : m_layer_tools) {
        append(m_all_printing_extruders, lt.extruders);
        sort_remove_duplicates(m_all_printing_extruders);
    }
 
    if (prime_multi_material && ! m_all_printing_extruders.empty()) {
        // Reorder m_all_printing_extruders in the sequence they will be primed, the last one will be m_first_printing_extruder.
        // Then set m_first_printing_extruder to the 1st extruder primed.
        m_all_printing_extruders.erase(
            std::remove_if(m_all_printing_extruders.begin(), m_all_printing_extruders.end(),
                [ this ](const unsigned int eid) { return eid == m_first_printing_extruder; }),
            m_all_printing_extruders.end());
        m_all_printing_extruders.emplace_back(m_first_printing_extruder);
        m_first_printing_extruder = m_all_printing_extruders.front();
    }
}

References Slic3r::append(), m_all_printing_extruders, m_first_printing_extruder, m_last_printing_extruder, m_layer_tools, and Slic3r::sort_remove_duplicates().

Referenced by ToolOrdering(), and ToolOrdering().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collect_extruders()

void Slic3r::ToolOrdering::collect_extruders	(	const PrintObject &	object,
		const std::vector< std::pair< double, unsigned int > > &	per_layer_extruder_switches
	)

private

{
    // Collect the support extruders.
    for (auto support_layer : object.support_layers()) {
        LayerTools   &layer_tools = this->tools_for_layer(support_layer->print_z);
        ExtrusionRole role = support_layer->support_fills.role();
        bool         has_support        = role == ExtrusionRole::Mixed || role == ExtrusionRole::SupportMaterial;
        bool         has_interface      = role == ExtrusionRole::Mixed || role == ExtrusionRole::SupportMaterialInterface;
        unsigned int extruder_support   = object.config().support_material_extruder.value;
        unsigned int extruder_interface = object.config().support_material_interface_extruder.value;
        if (has_support)
            layer_tools.extruders.push_back(extruder_support);
        if (has_interface)
            layer_tools.extruders.push_back(extruder_interface);
        if (has_support || has_interface)
            layer_tools.has_support = true;
    }
 
    // Extruder overrides are ordered by print_z.
    std::vector<std::pair<double, unsigned int>>::const_iterator it_per_layer_extruder_override;
  it_per_layer_extruder_override = per_layer_extruder_switches.begin();
    unsigned int extruder_override = 0;
 
    // Collect the object extruders.
    for (auto layer : object.layers()) {
        LayerTools &layer_tools = this->tools_for_layer(layer->print_z);
 
        // Override extruder with the next 
      for (; it_per_layer_extruder_override != per_layer_extruder_switches.end() && it_per_layer_extruder_override->first < layer->print_z + EPSILON; ++ it_per_layer_extruder_override)
        extruder_override = (int)it_per_layer_extruder_override->second;
 
        // Store the current extruder override (set to zero if no overriden), so that layer_tools.wiping_extrusions().is_overridable_and_mark() will use it.
        layer_tools.extruder_override = extruder_override;
 
        // What extruders are required to print this object layer?
        for (const LayerRegion *layerm : layer->regions()) {
            const PrintRegion &region = layerm->region();
 
            if (! layerm->perimeters().empty()) {
                bool something_nonoverriddable = true;
 
                if (m_print_config_ptr) { // in this case complete_objects is false (see ToolOrdering constructors)
                    something_nonoverriddable = false;
                    for (const ExtrusionEntity *eec : layerm->perimeters()) // let's check if there are nonoverriddable entities
                        if (is_overriddable(dynamic_cast<const ExtrusionEntityCollection&>(*eec), layer_tools, *m_print_config_ptr, object, region))
                            layer_tools.wiping_extrusions_nonconst().set_something_overridable();
                        else
                            something_nonoverriddable = true;
                }
 
                if (something_nonoverriddable)
                  layer_tools.extruders.emplace_back(extruder_override == 0 ? region.config().perimeter_extruder.value : extruder_override);
 
                layer_tools.has_object = true;
            }
 
            bool has_infill       = false;
            bool has_solid_infill = false;
            bool something_nonoverriddable = false;
            for (const ExtrusionEntity *ee : layerm->fills()) {
                // fill represents infill extrusions of a single island.
                const auto *fill = dynamic_cast<const ExtrusionEntityCollection*>(ee);
                ExtrusionRole role = fill->entities.empty() ? ExtrusionRole::None : fill->entities.front()->role();
                if (role.is_solid_infill())
                    has_solid_infill = true;
                else if (role != ExtrusionRole::None)
                    has_infill = true;
 
                if (m_print_config_ptr) {
                    if (is_overriddable(*fill, layer_tools, *m_print_config_ptr, object, region))
                        layer_tools.wiping_extrusions_nonconst().set_something_overridable();
                    else
                        something_nonoverriddable = true;
                }
            }
 
            if (something_nonoverriddable || !m_print_config_ptr) {
              if (extruder_override == 0) {
                  if (has_solid_infill)
                      layer_tools.extruders.emplace_back(region.config().solid_infill_extruder);
                  if (has_infill)
                      layer_tools.extruders.emplace_back(region.config().infill_extruder);
              } else if (has_solid_infill || has_infill)
                layer_tools.extruders.emplace_back(extruder_override);
            }
            if (has_solid_infill || has_infill)
                layer_tools.has_object = true;
        }
    }
 
    for (auto& layer : m_layer_tools) {
        // Sort and remove duplicates
        sort_remove_duplicates(layer.extruders);
 
        // make sure that there are some tools for each object layer (e.g. tall wiping object will result in empty extruders vector)
        if (layer.extruders.empty() && layer.has_object)
            layer.extruders.emplace_back(0); // 0="dontcare" extruder - it will be taken care of in reorder_extruders
    }
}

References Slic3r::PrintRegion::config(), EPSILON, Slic3r::is_overriddable(), Slic3r::ExtrusionRole::is_solid_infill(), layer_tools(), m_layer_tools, m_print_config_ptr, Slic3r::ExtrusionRole::Mixed, Slic3r::ExtrusionRole::None, Slic3r::sort_remove_duplicates(), Slic3r::ExtrusionRole::SupportMaterial, Slic3r::ExtrusionRole::SupportMaterialInterface, and tools_for_layer().

Referenced by ToolOrdering(), and ToolOrdering().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ empty()

bool Slic3r::ToolOrdering::empty ( ) const

inline

161{ return m_layer_tools.empty(); }

References m_layer_tools.

Referenced by ToolOrdering(), Slic3r::DoubleSlider::TickCodeInfo::get_used_extruders_for_tick(), and Slic3r::Print::process().

Here is the caller graph for this function:

◆ end()

std::vector< LayerTools >::const_iterator Slic3r::ToolOrdering::end ( ) const

inline

160{ return m_layer_tools.end(); }

References m_layer_tools.

Referenced by Slic3r::DoubleSlider::TickCodeInfo::get_used_extruders_for_tick().

Here is the caller graph for this function:

◆ fill_wipe_tower_partitions()

void Slic3r::ToolOrdering::fill_wipe_tower_partitions	(	const PrintConfig &	config,
		coordf_t	object_bottom_z,
		coordf_t	max_layer_height
	)

private

{
    if (m_layer_tools.empty())
        return;
 
    // Count the minimum number of tool changes per layer.
    size_t last_extruder = size_t(-1);
    for (LayerTools &lt : m_layer_tools) {
        lt.wipe_tower_partitions = lt.extruders.size();
        if (! lt.extruders.empty()) {
            if (last_extruder == size_t(-1) || last_extruder == lt.extruders.front())
                // The first extruder on this layer is equal to the current one, no need to do an initial tool change.
                -- lt.wipe_tower_partitions;
            last_extruder = lt.extruders.back();
        }
    }
 
    // Propagate the wipe tower partitions down to support the upper partitions by the lower partitions.
    for (int i = int(m_layer_tools.size()) - 2; i >= 0; -- i)
        m_layer_tools[i].wipe_tower_partitions = std::max(m_layer_tools[i + 1].wipe_tower_partitions, m_layer_tools[i].wipe_tower_partitions);
 
    //FIXME this is a hack to get the ball rolling.
    for (LayerTools &lt : m_layer_tools)
        lt.has_wipe_tower = (lt.has_object && lt.wipe_tower_partitions > 0) || lt.print_z < object_bottom_z + EPSILON;
 
    // Test for a raft, insert additional wipe tower layer to fill in the raft separation gap.
    for (size_t i = 0; i + 1 < m_layer_tools.size(); ++ i) {
        const LayerTools &lt      = m_layer_tools[i];
        const LayerTools &lt_next = m_layer_tools[i + 1];
        if (lt.print_z < object_bottom_z + EPSILON && lt_next.print_z >= object_bottom_z + EPSILON) {
            // lt is the last raft layer. Find the 1st object layer.
            size_t j = i + 1;
            for (; j < m_layer_tools.size() && ! m_layer_tools[j].has_wipe_tower; ++ j);
            if (j < m_layer_tools.size()) {
                const LayerTools &lt_object = m_layer_tools[j];
                coordf_t gap = lt_object.print_z - lt.print_z;
                assert(gap > 0.f);
                if (gap > max_layer_height + EPSILON) {
                    // Insert one additional wipe tower layer between lh.print_z and lt_object.print_z.
                    LayerTools lt_new(0.5f * (lt.print_z + lt_object.print_z));
                    // Find the 1st layer above lt_new.
                    for (j = i + 1; j < m_layer_tools.size() && m_layer_tools[j].print_z < lt_new.print_z - EPSILON; ++ j);
                    if (std::abs(m_layer_tools[j].print_z - lt_new.print_z) < EPSILON) {
            m_layer_tools[j].has_wipe_tower = true;
          } else {
            LayerTools &lt_extra = *m_layer_tools.insert(m_layer_tools.begin() + j, lt_new);
                        //LayerTools &lt_prev  = m_layer_tools[j];
                        LayerTools &lt_next  = m_layer_tools[j + 1];
                        assert(! m_layer_tools[j - 1].extruders.empty() && ! lt_next.extruders.empty());
                        // FIXME: Following assert tripped when running combine_infill.t. I decided to comment it out for now.
                        // If it is a bug, it's likely not critical, because this code is unchanged for a long time. It might
                        // still be worth looking into it more and decide if it is a bug or an obsolete assert.
                        //assert(lt_prev.extruders.back() == lt_next.extruders.front());
                        lt_extra.has_wipe_tower = true;
                        lt_extra.extruders.push_back(lt_next.extruders.front());
                        lt_extra.wipe_tower_partitions = lt_next.wipe_tower_partitions;
                    }
                }
            }
            break;
        }
    }
 
    // If the model contains empty layers (such as https://github.com/prusa3d/Slic3r/issues/1266), there might be layers
    // that were not marked as has_wipe_tower, even when they should have been. This produces a crash with soluble supports
    // and maybe other problems. We will therefore go through layer_tools and detect and fix this.
    // So, if there is a non-object layer starting with different extruder than the last one ended with (or containing more than one extruder),
    // we'll mark it with has_wipe tower.
    for (unsigned int i=0; i+1<m_layer_tools.size(); ++i) {
        LayerTools& lt = m_layer_tools[i];
        LayerTools& lt_next = m_layer_tools[i+1];
        if (lt.extruders.empty() || lt_next.extruders.empty())
            break;
        if (!lt_next.has_wipe_tower && (lt_next.extruders.front() != lt.extruders.back() || lt_next.extruders.size() > 1))
            lt_next.has_wipe_tower = true;
        // We should also check that the next wipe tower layer is no further than max_layer_height:
        unsigned int j = i+1;
        double last_wipe_tower_print_z = lt_next.print_z;
        while (++j < m_layer_tools.size()-1 && !m_layer_tools[j].has_wipe_tower)
            if (m_layer_tools[j+1].print_z - last_wipe_tower_print_z > max_layer_height + EPSILON) {
                m_layer_tools[j].has_wipe_tower = true;
                last_wipe_tower_print_z = m_layer_tools[j].print_z;
            }
    }
 
    // Calculate the wipe_tower_layer_height values.
    coordf_t wipe_tower_print_z_last = 0.;
    for (LayerTools &lt : m_layer_tools)
        if (lt.has_wipe_tower) {
            lt.wipe_tower_layer_height = lt.print_z - wipe_tower_print_z_last;
            wipe_tower_print_z_last = lt.print_z;
        }
}

References EPSILON, Slic3r::LayerTools::extruders, Slic3r::LayerTools::has_wipe_tower, last_extruder(), m_layer_tools, Slic3r::LayerTools::print_z, and Slic3r::LayerTools::wipe_tower_partitions.

Referenced by ToolOrdering(), and ToolOrdering().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ first_extruder()

unsigned int Slic3r::ToolOrdering::first_extruder ( ) const

inline

145{ return m_first_printing_extruder; }

References m_first_printing_extruder.

Referenced by Slic3r::GCode::_do_export(), and Slic3r::Print::_make_wipe_tower().

Here is the caller graph for this function:

◆ front()

const LayerTools & Slic3r::ToolOrdering::front ( ) const

inline

157{ return m_layer_tools.front(); }

References m_layer_tools.

Referenced by ToolOrdering(), and Slic3r::Print::_make_wipe_tower().

Here is the caller graph for this function:

◆ has_wipe_tower()

bool Slic3r::ToolOrdering::has_wipe_tower ( ) const

inline

163{ return ! m_layer_tools.empty() && m_first_printing_extruder != (unsigned int)-1 && m_layer_tools.front().wipe_tower_partitions > 0; }

References m_first_printing_extruder, and m_layer_tools.

Referenced by Slic3r::GCode::_do_export(), and Slic3r::Print::_make_wipe_tower().

Here is the caller graph for this function:

◆ initialize_layers()

void Slic3r::ToolOrdering::initialize_layers ( std::vector< coordf_t > & zs )

private

{
    sort_remove_duplicates(zs);
    // Merge numerically very close Z values.
    for (size_t i = 0; i < zs.size();) {
        // Find the last layer with roughly the same print_z.
        size_t j = i + 1;
        coordf_t zmax = zs[i] + EPSILON;
        for (; j < zs.size() && zs[j] <= zmax; ++ j) ;
        // Assign an average print_z to the set of layers with nearly equal print_z.
        m_layer_tools.emplace_back(LayerTools(0.5 * (zs[i] + zs[j-1])));
        i = j;
    }
}

References EPSILON, m_layer_tools, and Slic3r::sort_remove_duplicates().

Referenced by ToolOrdering(), and ToolOrdering().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insert_wipe_tower_extruder()

bool Slic3r::ToolOrdering::insert_wipe_tower_extruder ( )

private

{
    // In case that wipe_tower_extruder is set to non-zero, we must make sure that the extruder will be in the list.
    bool changed = false;
    if (m_print_config_ptr->wipe_tower_extruder != 0) {
        for (LayerTools& lt : m_layer_tools) {
            if (lt.wipe_tower_partitions > 0) {
                lt.extruders.emplace_back(m_print_config_ptr->wipe_tower_extruder - 1);
                sort_remove_duplicates(lt.extruders);
                changed = true;
            }
        }
        // Now convert the 0-based list to 1-based again.
        for (LayerTools& lt : m_layer_tools) {
            for (auto& extruder : lt.extruders)
                    ++extruder;
        }
    }
    return changed;
}

References m_layer_tools, m_print_config_ptr, and Slic3r::sort_remove_duplicates().

Referenced by ToolOrdering().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ last_extruder()

unsigned int Slic3r::ToolOrdering::last_extruder ( ) const

inline

148{ return m_last_printing_extruder; }

References m_last_printing_extruder.

Referenced by Slic3r::GCode::_do_export(), fill_wipe_tower_partitions(), and Slic3r::Print::process().

Here is the caller graph for this function:

◆ layer_tools()

std::vector< LayerTools > & Slic3r::ToolOrdering::layer_tools ( )

inline

162{ return m_layer_tools; }

References m_layer_tools.

Referenced by Slic3r::GCode::_do_export(), Slic3r::Print::_make_wipe_tower(), and collect_extruders().

Here is the caller graph for this function:

◆ mark_skirt_layers()

void Slic3r::ToolOrdering::mark_skirt_layers	(	const PrintConfig &	config,
		coordf_t	max_layer_height
	)

private

{
    if (m_layer_tools.empty())
        return;
 
    if (m_layer_tools.front().extruders.empty()) {
        // Empty first layer, no skirt will be printed.
        //FIXME throw an exception?
        return;
    }
 
    size_t i = 0;
    for (;;) {
        m_layer_tools[i].has_skirt = true;
        size_t j = i + 1;
        for (; j < m_layer_tools.size() && ! m_layer_tools[j].has_object; ++ j);
        // i and j are two successive layers printing an object.
        if (j == m_layer_tools.size())
            // Don't print skirt above the last object layer.
            break;
        // Mark some printing intermediate layers as having skirt.
        double last_z = m_layer_tools[i].print_z;
        for (size_t k = i + 1; k < j; ++ k) {
            if (m_layer_tools[k + 1].print_z - last_z > max_layer_height + EPSILON) {
                // Layer k is the last one not violating the maximum layer height.
                // Don't extrude skirt on empty layers.
                while (m_layer_tools[k].extruders.empty())
                    -- k;
                if (m_layer_tools[k].has_skirt) {
                    // Skirt cannot be generated due to empty layers, there would be a missing layer in the skirt.
                    //FIXME throw an exception?
                    break;
                }
                m_layer_tools[k].has_skirt = true;
                last_z = m_layer_tools[k].print_z;
            }
        }
        i = j;
    }
}

References EPSILON, and m_layer_tools.

Referenced by ToolOrdering(), and ToolOrdering().

Here is the caller graph for this function:

◆ reorder_extruders()

void Slic3r::ToolOrdering::reorder_extruders ( unsigned int last_extruder_id )

private

{
    if (m_layer_tools.empty())
        return;
 
    if (last_extruder_id == (unsigned int)-1) {
        // The initial print extruder has not been decided yet.
        // Initialize the last_extruder_id with the first non-zero extruder id used for the print.
        last_extruder_id = 0;
        for (size_t i = 0; i < m_layer_tools.size() && last_extruder_id == 0; ++ i) {
            const LayerTools &lt = m_layer_tools[i];
            for (unsigned int extruder_id : lt.extruders)
                if (extruder_id > 0) {
                    last_extruder_id = extruder_id;
                    break;
                }
        }
        if (last_extruder_id == 0)
            // Nothing to extrude.
            return;
    } else
        // 1 based index
        ++ last_extruder_id;
 
    for (LayerTools &lt : m_layer_tools) {
        if (lt.extruders.empty())
            continue;
        if (lt.extruders.size() == 1 && lt.extruders.front() == 0)
            lt.extruders.front() = last_extruder_id;
        else {
            if (lt.extruders.front() == 0)
                // Pop the "don't care" extruder, the "don't care" region will be merged with the next one.
                lt.extruders.erase(lt.extruders.begin());
            // Reorder the extruders to start with the last one.
            for (size_t i = 1; i < lt.extruders.size(); ++ i)
                if (lt.extruders[i] == last_extruder_id) {
                    // Move the last extruder to the front.
                    memmove(lt.extruders.data() + 1, lt.extruders.data(), i * sizeof(unsigned int));
                    lt.extruders.front() = last_extruder_id;
                    break;
                }
 
            // On first layer with wipe tower, prefer a soluble extruder
            // at the beginning, so it is not wiped on the first layer.
            if (lt == m_layer_tools[0] && m_print_config_ptr && m_print_config_ptr->wipe_tower) {
                for (size_t i = 0; i<lt.extruders.size(); ++i)
                    if (m_print_config_ptr->filament_soluble.get_at(lt.extruders[i]-1)) { // 1-based...
                        std::swap(lt.extruders[i], lt.extruders.front());
                        break;
                    }
            }
        }
        last_extruder_id = lt.extruders.back();
    }
 
    // Reindex the extruders, so they are zero based, not 1 based.
    for (LayerTools &lt : m_layer_tools)
        for (unsigned int &extruder_id : lt.extruders) {
            assert(extruder_id > 0);
            -- extruder_id;
        }    
}

References Slic3r::LayerTools::extruders, m_layer_tools, and m_print_config_ptr.

Referenced by ToolOrdering(), and ToolOrdering().

Here is the caller graph for this function:

◆ tools_for_layer() [1/2]

LayerTools & Slic3r::ToolOrdering::tools_for_layer ( coordf_t print_z )

inline

155{ return const_cast<LayerTools&>(std::as_const(*this).tools_for_layer(print_z)); }

◆ tools_for_layer() [2/2]

const LayerTools & Slic3r::ToolOrdering::tools_for_layer ( coordf_t print_z ) const

{
    auto it_layer_tools = std::lower_bound(m_layer_tools.begin(), m_layer_tools.end(), LayerTools(print_z - EPSILON));
    assert(it_layer_tools != m_layer_tools.end());
    coordf_t dist_min = std::abs(it_layer_tools->print_z - print_z);
    for (++ it_layer_tools; it_layer_tools != m_layer_tools.end(); ++ it_layer_tools) {
        coordf_t d = std::abs(it_layer_tools->print_z - print_z);
        if (d >= dist_min)
            break;
        dist_min = d;
    }
    -- it_layer_tools;
    assert(dist_min < EPSILON);
    return *it_layer_tools;
}

References EPSILON, and m_layer_tools.

Referenced by collect_extruders(), Slic3r::GCode::process_layers(), and Slic3r::GCode::process_layers().

Here is the caller graph for this function:

Member Data Documentation

◆ m_all_printing_extruders

std::vector<unsigned int> Slic3r::ToolOrdering::m_all_printing_extruders

private

Referenced by all_extruders(), and collect_extruder_statistics().

◆ m_first_printing_extruder

unsigned int Slic3r::ToolOrdering::m_first_printing_extruder = (unsigned int)-1

private

Referenced by collect_extruder_statistics(), first_extruder(), and has_wipe_tower().

◆ m_last_printing_extruder

unsigned int Slic3r::ToolOrdering::m_last_printing_extruder = (unsigned int)-1

private

Referenced by collect_extruder_statistics(), and last_extruder().

◆ m_layer_tools

std::vector<LayerTools> Slic3r::ToolOrdering::m_layer_tools

private

Referenced by assign_custom_gcodes(), back(), begin(), clear(), collect_extruder_statistics(), collect_extruders(), empty(), end(), fill_wipe_tower_partitions(), front(), has_wipe_tower(), initialize_layers(), insert_wipe_tower_extruder(), layer_tools(), mark_skirt_layers(), reorder_extruders(), and tools_for_layer().

◆ m_print_config_ptr

const PrintConfig* Slic3r::ToolOrdering::m_print_config_ptr = nullptr

private

Referenced by ToolOrdering(), collect_extruders(), insert_wipe_tower_extruder(), and reorder_extruders().

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

src/libslic3r/GCode/ToolOrdering.hpp
src/libslic3r/GCode/ToolOrdering.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ToolOrdering() [1/3]

◆ ToolOrdering() [2/3]

◆ ToolOrdering() [3/3]

Member Function Documentation

◆ all_extruders()

◆ assign_custom_gcodes()

◆ back()

◆ begin()

◆ clear()

◆ collect_extruder_statistics()

◆ collect_extruders()

◆ empty()

◆ end()

◆ fill_wipe_tower_partitions()

◆ first_extruder()

◆ front()

◆ has_wipe_tower()

◆ initialize_layers()

◆ insert_wipe_tower_extruder()

◆ last_extruder()

◆ layer_tools()

◆ mark_skirt_layers()

◆ reorder_extruders()

◆ tools_for_layer() [1/2]

◆ tools_for_layer() [2/2]

Member Data Documentation

◆ m_all_printing_extruders

◆ m_first_printing_extruder

◆ m_last_printing_extruder

◆ m_layer_tools

◆ m_print_config_ptr