Slic3r::ToolOrdering Class Reference

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

Collaboration diagram for Slic3r::ToolOrdering:

Public Types
enum	FilamentChangeMode { SingleExt , MultiExtBest , MultiExtCurr }

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	handle_dontcare_extruder (const std::vector< unsigned int > &first_layer_tool_order)
void	handle_dontcare_extruder (unsigned int first_extruder)
void	sort_and_build_data (const PrintObject &object, unsigned int first_extruder, bool prime_multi_material=false)
void	sort_and_build_data (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 std::vector< unsigned int > &	used_mixed_filaments () 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
int	get_most_used_extruder () const
const MultiNozzleUtils::LayeredNozzleGroupResult &	get_layered_nozzle_group_result () const
const MultiNozzleUtils::NozzleStatusRecorder &	get_nozzle_status () const
void	set_nozzle_status (const MultiNozzleUtils::NozzleStatusRecorder &status)
FilamentChangeStats	get_filament_change_stats (FilamentChangeMode mode)
void	cal_most_used_extruder (const PrintConfig &config)
float	cal_max_additional_fan (const PrintConfig &config)
bool	cal_non_support_filaments (const PrintConfig &config, unsigned int &first_non_support_filament, std::vector< int > &initial_non_support_filaments, std::vector< int > &initial_filaments)
bool	has_non_support_filament (const PrintConfig &config)
bool	is_last_extrusion_layer (coordf_t print_z, unsigned int extruder_id) const

Static Public Member Functions
static MultiNozzleUtils::LayeredNozzleGroupResult	get_recommended_filament_maps (const std::vector< std::vector< unsigned int > > &layer_filaments, const Print *print, const FilamentMapMode mode, const std::vector< std::set< int > > &physical_unprintables, const std::vector< std::set< int > > &geometric_unprintables, const std::map< int, std::set< NozzleVolumeType > > &unprintable_volumes={}, const std::unordered_map< int, int > &nozzle_status={})
static MultiNozzleUtils::LayeredNozzleGroupResult	build_sequential_group_result (Print *print, std::vector< std::vector< int > > nozzle_map_per_layer, const std::vector< std::vector< unsigned int > > &layer_filaments, const std::vector< std::vector< unsigned int > > &layer_sequences, const std::vector< unsigned int > &used_filaments, const std::vector< std::set< int > > &physical_unprintables, const std::vector< std::set< int > > &geometric_unprintables, const std::map< int, std::set< NozzleVolumeType > > &unprintable_volumes)

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	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)
void	reorder_extruders_for_minimum_flush_volume (bool reorder_first_layer)
void	resolve_mixed_filaments (const PrintConfig &config)
void	enforce_mixed_component_order ()
std::vector< unsigned int >	generate_first_layer_tool_order (const Print &print)
std::vector< unsigned int >	generate_first_layer_tool_order (const PrintObject &object)

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
std::vector< unsigned int >	m_used_mixed_filaments
const DynamicPrintConfig *	m_print_full_config = nullptr
const PrintConfig *	m_print_config_ptr = nullptr
std::map< unsigned int, std::map< const PrintObject *, std::vector< size_t > > >	m_mixed_object_layers
std::map< const PrintObject *, std::vector< size_t > >	m_object_all_layer_indices
std::map< unsigned int, std::map< LayerTools::MixedSubLayerGroup::VolumeKey, std::vector< size_t > > >	m_gradient_volume_layers
std::map< unsigned int, coordf_t >	m_last_layer_per_extruder
const PrintObject *	m_print_object_ptr = nullptr
Print *	m_print
bool	m_sorted = false
FilamentChangeStats	m_stats_by_single_extruder
FilamentChangeStats	m_stats_by_multi_extruder_curr
FilamentChangeStats	m_stats_by_multi_extruder_best
MultiNozzleUtils::LayeredNozzleGroupResult	m_nozzle_group_result
MultiNozzleUtils::NozzleStatusRecorder	m_initial_nozzle_status
MultiNozzleUtils::NozzleStatusRecorder	m_nozzle_status
int	most_used_extruder

Detailed Description

Member Enumeration Documentation

FilamentChangeMode

enum Slic3r::ToolOrdering::FilamentChangeMode

Enumerator
SingleExt
MultiExtBest
MultiExtCurr

                            {
        SingleExt,
        MultiExtBest,
        MultiExtCurr
    };

Constructor & Destructor Documentation

ToolOrdering() [1/3]

Slic3r::ToolOrdering::ToolOrdering ( )

default

References first_extruder().

Here is the call graph for this function:

ToolOrdering() [2/3]

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

{
    m_print_full_config = &object.print()->full_print_config();
    m_print_config_ptr = &object.print()->config();
    m_print_object_ptr = &object;
    m_print = const_cast<Print*>(object.print());
    if (object.layers().empty())
        return;
 
    // Initialize the print layers for just a single object.
    {
        // construct layer tools by z height
        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);
        // Belt brim apron bands sit below the object's first layer and have no
        // layer of their own, but tools_for_layer() asserts an exact Z match, so
        // their print_z must be part of the ordering.
        for (const BeltBrimBand &band : object.belt_brim_prologue())
            zs.emplace_back(band.print_z);
        this->initialize_layers(zs);
    }
 
    // Collect extruders reuqired to print the layers. Add dontcare extruders
    this->collect_extruders(object, std::vector<std::pair<double, unsigned int>>());
 
    // BBS
    // Reorder the extruders to minimize tool switches.
    std::vector<unsigned int> first_layer_tool_order;
    if (first_extruder == (unsigned int) -1) {
        first_layer_tool_order = generate_first_layer_tool_order(object);
    }
 
    if (!first_layer_tool_order.empty()) {
        this->handle_dontcare_extruder(first_layer_tool_order);
    } else {
        this->handle_dontcare_extruder(first_extruder);
    }
 
    this->collect_extruder_statistics(prime_multi_material);
 
    double max_layer_height = calc_max_layer_height(object.print()->config(), object.config().layer_height);
 
    this->mark_skirt_layers(object.print()->config(), max_layer_height);
}

References Slic3r::calc_max_layer_height(), collect_extruder_statistics(), collect_extruders(), empty(), first_extruder(), generate_first_layer_tool_order(), handle_dontcare_extruder(), initialize_layers(), Slic3r::layer_height(), m_print, m_print_config_ptr, m_print_full_config, m_print_object_ptr, and mark_skirt_layers().

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_full_config = &print.full_print_config();
    m_print = const_cast<Print *>(&print);  // for update the context of print
    m_print_config_ptr = &print.config();
 
    // Initialize the print layers for all objects and all layers.
    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);
            // See the single-object ctor: belt brim apron bands need their own
            // ordering entries or tools_for_layer() will assert.
            for (const BeltBrimBand &band : object->belt_brim_prologue())
                zs.emplace_back(band.print_z);
 
            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;
 
    // BBS
  if (auto num_filaments = unsigned(print.config().filament_diameter.size());
    num_filaments > 1 && print.object_extruders().size() == 1 && // the current Print's configuration is CustomGCode::MultiAsSingle
        //BBS: replace model custom gcode with current plate custom gcode
        print.model().get_curr_plate_custom_gcodes().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().get_curr_plate_custom_gcodes(), num_filaments);
  }
 
    // 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.
    std::vector<unsigned int> first_layer_tool_order;
    if (first_extruder == (unsigned int)-1) {
        first_layer_tool_order = generate_first_layer_tool_order(print);
    }
 
    if(!first_layer_tool_order.empty())
        this->handle_dontcare_extruder(first_layer_tool_order);
    else
        this->handle_dontcare_extruder(first_extruder);
 
    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::CustomGCode::custom_tool_changes(), first_extruder(), Slic3r::PrintBase::full_print_config(), generate_first_layer_tool_order(), Slic3r::Model::get_curr_plate_custom_gcodes(), handle_dontcare_extruder(), initialize_layers(), m_print, m_print_config_ptr, m_print_full_config, mark_skirt_layers(), Slic3r::CustomGCode::Info::mode, Slic3r::PrintBase::model(), Slic3r::CustomGCode::MultiAsSingle, Slic3r::Print::object_extruders(), and Slic3r::Print::objects().

Here is the call graph for this function:

Member Function Documentation

all_extruders()

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

inline

{ return m_all_printing_extruders; }

References m_all_printing_extruders.

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

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().print_sequence == PrintSequence::ByLayer);
 
    custom_gcode_per_print_z = print.model().get_curr_plate_custom_gcodes();
  if (custom_gcode_per_print_z.gcodes.empty())
    return;
 
    // BBS
  auto            num_filaments = unsigned(print.config().filament_diameter.size());
  CustomGCode::Mode       mode          =
    (num_filaments == 1) ? CustomGCode::SingleExtruder :
    print.object_extruders().size() == 1 ? CustomGCode::MultiAsSingle : CustomGCode::MultiExtruder;
    CustomGCode::Mode           model_mode    = print.model().get_curr_plate_custom_gcodes().mode;
  std::vector<unsigned char>  extruder_printing_above(num_filaments, 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:
    coordf_t print_z_above = std::numeric_limits<coordf_t>::lowest();
  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() && (
            (print_z_above > lt.print_z && custom_gcode_it->print_z > 0.5 * (lt.print_z + print_z_above))
            || custom_gcode_it->type == CustomGCode::ToolChange); ++ custom_gcode_it) {}
        print_z_above = lt.print_z;
    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 > 0.5 * (print_z_below + lt.print_z)) {
      // 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.
                // BBS
        (color_change ? 
          mode == CustomGCode::SingleExtruder || 
            (custom_gcode.extruder <= int(num_filaments) && 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;
    }
  }
}

References assign_custom_gcodes(), Slic3r::ByLayer, Slic3r::CustomGCode::ColorChange, Slic3r::Print::config(), Slic3r::LayerTools::custom_gcode, Slic3r::custom_gcode_per_print_z, Slic3r::CustomGCode::Item::extruder, Slic3r::LayerTools::extruders, Slic3r::Model::get_curr_plate_custom_gcodes(), m_layer_tools, Slic3r::CustomGCode::Info::mode, Slic3r::PrintBase::model(), Slic3r::CustomGCode::MultiAsSingle, Slic3r::CustomGCode::MultiExtruder, Slic3r::Print::object_extruders(), Slic3r::CustomGCode::Item::print_z, Slic3r::LayerTools::print_z, Slic3r::CustomGCode::SingleExtruder, Slic3r::CustomGCode::ToolChange, and Slic3r::CustomGCode::Item::type.

Referenced by Slic3r::GCode::_do_export(), and assign_custom_gcodes().

Here is the call graph for this function:

Here is the caller graph for this function:

back()

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

inline

{ return m_layer_tools.back(); }

References m_layer_tools.

begin()

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

inline

{ return m_layer_tools.begin(); }

References m_layer_tools.

build_sequential_group_result()

MultiNozzleUtils::LayeredNozzleGroupResult Slic3r::ToolOrdering::build_sequential_group_result ( Print * print, std::vector< std::vector< int > > nozzle_map_per_layer, const std::vector< std::vector< unsigned int > > & layer_filaments, const std::vector< std::vector< unsigned int > > & layer_sequences, const std::vector< unsigned int > & used_filaments, const std::vector< std::set< int > > & physical_unprintables, const std::vector< std::set< int > > & geometric_unprintables, const std::map< int, std::set< NozzleVolumeType > > & unprintable_volumes )

static

{
    MultiNozzleUtils::normalize_nozzle_map_per_layer(nozzle_map_per_layer, layer_filaments);
    auto context = build_filament_group_context(print, layer_filaments, physical_unprintables, geometric_unprintables,
                                                unprintable_volumes, FilamentMapMode::fmmAutoForFlush, {});
    auto result = MultiNozzleUtils::LayeredNozzleGroupResult::create(nozzle_map_per_layer, context.nozzle_info.nozzle_list,
                                                                     used_filaments, layer_sequences);
    return result ? *result : MultiNozzleUtils::LayeredNozzleGroupResult();
}

References Slic3r::build_filament_group_context(), build_sequential_group_result(), Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::create(), Slic3r::fmmAutoForFlush, and Slic3r::MultiNozzleUtils::normalize_nozzle_map_per_layer().

Referenced by build_sequential_group_result().

Here is the call graph for this function:

Here is the caller graph for this function:

cal_max_additional_fan()

float Slic3r::ToolOrdering::cal_max_additional_fan

(

const PrintConfig &

config

)

{
    std::set<unsigned int> used_filaments;
    for (const LayerTools &layer_tools : m_layer_tools)
        used_filaments.insert(layer_tools.extruders.begin(), layer_tools.extruders.end());
    if (used_filaments.empty())
        return 0;
 
    // Orca: additional_cooling_fan_speed can hold one value per extruder variant a filament prints with;
    // filament_self_index maps such a column to its filament.
    const std::vector<int> &self_index = config.filament_self_index.values;
    const size_t columns = std::max(config.additional_cooling_fan_speed.size(), size_t(*used_filaments.rbegin()) + 1);
    float max_fan = 0;
    for (size_t column = 0; column < columns; ++column) {
        const unsigned int filament_id = self_index.size() == columns ? self_index[column] - 1 : column;
        if (used_filaments.count(filament_id) && max_fan < config.additional_cooling_fan_speed.get_at(column))
            max_fan = config.additional_cooling_fan_speed.get_at(column);
    }
    return max_fan;
}

References cal_max_additional_fan(), layer_tools(), and m_layer_tools.

Referenced by Slic3r::GCode::_do_export(), and cal_max_additional_fan().

Here is the call graph for this function:

Here is the caller graph for this function:

cal_most_used_extruder()

void Slic3r::ToolOrdering::cal_most_used_extruder

(

const PrintConfig &

config

)

{
    // record
    std::vector<int> extruder_count;
    extruder_count.resize(config.nozzle_diameter.size(), 0);
    for (LayerTools &layer_tools : m_layer_tools) {
        std::vector<unsigned int> filaments = layer_tools.extruders;
        std::set<int> layer_extruder_count;
        //count once only
        for (unsigned int &filament : filaments) {
            layer_extruder_count.insert(config.filament_map.values[filament] - 1);
        }
 
        //record
        for (int extruder_id : layer_extruder_count) {
            extruder_count[extruder_id]++;
        }
    }
 
    // set key for most used extruder
    // count most used extruder
    most_used_extruder = 0;
    for (int extruder_id = 1; extruder_id < extruder_count.size(); extruder_id++) {
        if (extruder_count[extruder_id] >= extruder_count[most_used_extruder])
            most_used_extruder = extruder_id;
    }
}

References cal_most_used_extruder(), layer_tools(), m_layer_tools, and most_used_extruder.

Referenced by Slic3r::GCode::_do_export(), and cal_most_used_extruder().

Here is the call graph for this function:

Here is the caller graph for this function:

cal_non_support_filaments()

bool Slic3r::ToolOrdering::cal_non_support_filaments	(	const PrintConfig &	config,
		unsigned int &	first_non_support_filament,
		std::vector< int > &	initial_non_support_filaments,
		std::vector< int > &	initial_filaments )

{
    int find_count = 0;
    int find_first_filaments_count = 0;
    bool has_non_support = has_non_support_filament(config);
    // The selector can move a filament between extruders per layer; resolve the extruder from
    // the published result then, so the first filament attributed to an extruder is one it
    // actually prints there. Static results keep the cross-layer filament_map arithmetic.
    const bool use_dynamic_map = m_nozzle_group_result.is_support_dynamic_nozzle_map() && m_nozzle_group_result.get_layer_count() > 0;
    auto extruder_for_filament = [&](unsigned int filament, size_t layer_idx) -> int {
        if (use_dynamic_map)
            return m_nozzle_group_result.get_extruder_id(static_cast<int>(filament), static_cast<int>(layer_idx));
        return config.filament_map.values[filament] - 1;
    };
    for (size_t layer_idx = 0; layer_idx < m_layer_tools.size(); ++layer_idx) {
        for (const unsigned int &filament : m_layer_tools[layer_idx].extruders) {
            //check first filament
            if (!config.filament_map.values.empty()) {
                const int extruder_id = extruder_for_filament(filament, layer_idx);
                if (extruder_id >= 0 && extruder_id < static_cast<int>(initial_filaments.size()) && initial_filaments[extruder_id] == -1) {
                    initial_filaments[extruder_id] = filament;
                    find_first_filaments_count++;
                }
            }
 
            if (has_non_support) {
                // check first non support filaments
                if (config.filament_is_support.get_at(filament))
                    continue;
 
                if (first_non_support_filament == (unsigned int) -1) first_non_support_filament = filament;
 
                // params missing, add protection
                // filament map missing means single nozzle, no need to set initial_non_support_filaments
                if (config.filament_map.values.empty())
                    return true;
 
                const int extruder_id = extruder_for_filament(filament, layer_idx);
                if (extruder_id >= 0 && extruder_id < static_cast<int>(initial_non_support_filaments.size()) && initial_non_support_filaments[extruder_id] == -1) {
                    initial_non_support_filaments[extruder_id] = filament;
                    find_count++;
                }
 
                if (find_count == initial_non_support_filaments.size())
                    return true;
            } else if (find_first_filaments_count == initial_filaments.size() || config.filament_map.values.empty()){
                    return false;
            }
 
        }
    }
 
    return false;
}

References cal_non_support_filaments(), has_non_support_filament(), m_layer_tools, and m_nozzle_group_result.

Referenced by Slic3r::GCode::_do_export(), and cal_non_support_filaments().

Here is the call graph for this function:

Here is the caller graph for this function:

clear()

void Slic3r::ToolOrdering::clear ( )

inline

                    {
        m_layer_tools.clear();
        m_stats_by_single_extruder.clear();
        m_stats_by_multi_extruder_best.clear();
        m_stats_by_multi_extruder_curr.clear();
    }

References m_layer_tools, m_stats_by_multi_extruder_best, m_stats_by_multi_extruder_curr, and m_stats_by_single_extruder.

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);
    }
 
    m_last_layer_per_extruder.clear();
    for (const LayerTools& lt : m_layer_tools) {
        for (unsigned int ext : lt.extruders) {
            m_last_layer_per_extruder[ext] = lt.print_z;
        }
    }
 
    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(), collect_extruder_statistics(), m_all_printing_extruders, m_first_printing_extruder, m_last_layer_per_extruder, m_last_printing_extruder, m_layer_tools, and Slic3r::sort_remove_duplicates().

Referenced by ToolOrdering(), ToolOrdering(), collect_extruder_statistics(), sort_and_build_data(), and sort_and_build_data().

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

{
    // 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;
 
    // Pre-compute 1-based IDs of mixed filament slots for per-object tracking.
    // mixed_slots_1based covers ALL mixed slots (needed by calc_slot_lh for
    // accurate layer height when a slot skips layers). gradient_slots_1based
    // and per_part_slots_1based are subsets for gradient-specific logic.
    std::set<unsigned int> mixed_slots_1based;
    std::set<unsigned int> gradient_slots_1based;
    std::set<unsigned int> per_part_slots_1based;
    {
        const PrintConfig &cfg       = object.print()->config();
        const auto        &is_mixed  = cfg.filament_is_mixed.values;
        const auto        &grad_flags = cfg.filament_mixed_gradient.values;
        const auto        &per_part_flags = cfg.filament_mixed_gradient_per_part.values;
        const auto        &comp_strs = cfg.filament_mixed_components.values;
        for (size_t i = 0; i < is_mixed.size(); ++i) {
            if (!is_mixed[i])
                continue;
            auto comps = parse_mixed_components(i < comp_strs.size() ? comp_strs[i] : "");
            if (comps.size() < 2)
                continue;
            mixed_slots_1based.insert(static_cast<unsigned int>(i + 1));
            // Gradient/per-part are only defined for 2-component slots; keep their
            // tracking limited to them (mirrors the is_gradient guard at resolve time).
            if (comps.size() != 2)
                continue;
            if (i >= grad_flags.size() || !grad_flags[i])
                continue;
            gradient_slots_1based.insert(static_cast<unsigned int>(i + 1));
            if (i < per_part_flags.size() && per_part_flags[i])
                per_part_slots_1based.insert(static_cast<unsigned int>(i + 1));
        }
    }
 
    // BBS: collect first layer extruders of an object's wall, which will be used by brim generator
    int layerCount = 0;
    std::vector<int> firstLayerExtruders;
    firstLayerExtruders.clear();
 
    // Collect the object extruders.
    for (auto layer : object.layers()) {
        LayerTools &layer_tools = this->tools_for_layer(layer->print_z);
 
        m_object_all_layer_indices[&object].push_back(
            static_cast<size_t>(&layer_tools - m_layer_tools.data()));
 
        // 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;
 
        // Snapshot extruders before this object's regions to track new additions.
        const size_t ext_snapshot = layer_tools.extruders.size();
 
        // What extruders are required to print this object layer?
        for (const LayerRegion *layerm : layer->regions()) {
            const PrintRegion &region = layerm->region();
 
            if (! layerm->perimeters.entities.empty()) {
                bool something_nonoverriddable = true;
 
                if (m_print_config_ptr) { // in this case print->config().print_sequence != PrintSequence::ByObject (see ToolOrdering constructors)
                    something_nonoverriddable = false;
                    for (const auto& eec : layerm->perimeters.entities) // let's check if there are nonoverriddable entities
                        if (!layer_tools.wiping_extrusions().is_overriddable_and_mark(dynamic_cast<const ExtrusionEntityCollection&>(*eec), *m_print_config_ptr, object, region))
                            something_nonoverriddable = true;
                }
 
                if (something_nonoverriddable){
                  layer_tools.extruders.emplace_back((extruder_override == 0) ? region.config().outer_wall_filament_id.value : extruder_override);
                    const ExtrusionEntitiesPtr &islands = layerm->perimeters.entities;
                    const bool has_inner_wall = std::any_of(islands.begin(), islands.end(), [](const ExtrusionEntity *island) {
                        const ExtrusionEntitiesPtr &walls = static_cast<const ExtrusionEntityCollection*>(island)->entities;
                        return std::any_of(walls.begin(), walls.end(), [](const ExtrusionEntity *ee) { return is_inner_wall(*ee); });
                    });
                    if (extruder_override == 0 && region.config().wall_loops.value > 1 && has_inner_wall)
                        layer_tools.extruders.emplace_back(region.config().inner_wall_filament_id.value);
                    if (layerCount == 0) {
                        firstLayerExtruders.emplace_back((extruder_override == 0) ? region.config().outer_wall_filament_id.value : extruder_override);
                    }
                }
 
                layer_tools.has_object = true;
            }
 
            std::vector<unsigned int> fill_filaments;
            bool something_nonoverriddable = false;
            for (const ExtrusionEntity *ee : layerm->fills.entities) {
                // fill represents infill extrusions of a single island.
                const auto *fill = dynamic_cast<const ExtrusionEntityCollection*>(ee);
                if (! fill->entities.empty())
                    fill_filaments.emplace_back(region_filament(*fill, region.config()));
 
                if (m_print_config_ptr) {
                    if (! layer_tools.wiping_extrusions().is_overriddable_and_mark(*fill, *m_print_config_ptr, object, region))
                        something_nonoverriddable = true;
                }
            }
 
            if (something_nonoverriddable || !m_print_config_ptr) {
              if (extruder_override == 0)
                    append(layer_tools.extruders, fill_filaments);
                else if (! fill_filaments.empty())
                layer_tools.extruders.emplace_back(extruder_override);
            }
            if (! fill_filaments.empty())
                layer_tools.has_object = true;
        }
 
        // Record mixed slot usage for this object at this layer.
        // All mixed slots are tracked (not just gradient) so that calc_slot_lh
        // can compute accurate layer heights even when a slot skips layers.
        if (!mixed_slots_1based.empty()) {
            size_t layer_idx = static_cast<size_t>(&layer_tools - m_layer_tools.data());
            std::set<unsigned int> seen;
            for (size_t ei = ext_snapshot; ei < layer_tools.extruders.size(); ++ei) {
                unsigned int ext_1based = layer_tools.extruders[ei];
                if (mixed_slots_1based.count(ext_1based) && seen.insert(ext_1based).second)
                    m_mixed_object_layers[ext_1based - 1][&object].push_back(layer_idx);
            }
        }
 
        // Per-part gradient: walk LayerRegions and record which (slot, ModelVolume) pairs
        // contributed to this layer. Only regions tagged by PrintApply.cpp's get_create_region
        // (i.e. gradient_volume_id().valid()) are considered, so this loop is a strict no-op
        // unless per_part_gradient is enabled for at least one slot AND the corresponding
        // ModelObject has >=2 model-part volumes using that slot. The per-object pass above is
        // unaffected — both run the same layer's data through orthogonal containers.
        if (!per_part_slots_1based.empty()) {
            size_t layer_idx = static_cast<size_t>(&layer_tools - m_layer_tools.data());
            std::set<std::pair<unsigned int, ObjectID>> vol_seen;
            for (const LayerRegion *layerm : layer->regions()) {
                if (layerm->slices.empty())
                    continue;
                const PrintRegion &region = layerm->region();
                ObjectID vol_id = region.gradient_volume_id();
                if (! vol_id.valid())
                    continue;
                const PrintRegionConfig &rcfg = region.config();
                // Orca splits BBS's three role slots into five; cover them all so a mixed
                // slot used by any role is tracked.
                const unsigned int role_slots[5] = {
                    static_cast<unsigned int>(rcfg.outer_wall_filament_id.value),
                    static_cast<unsigned int>(rcfg.inner_wall_filament_id.value),
                    static_cast<unsigned int>(rcfg.sparse_infill_filament_id.value),
                    static_cast<unsigned int>(rcfg.top_surface_filament_id.value),
                    static_cast<unsigned int>(rcfg.bottom_surface_filament_id.value),
                };
                for (unsigned int ext_1based : role_slots) {
                    if (ext_1based >= 1
                        && per_part_slots_1based.count(ext_1based)
                        && vol_seen.insert({ext_1based, vol_id}).second)
                        m_gradient_volume_layers[ext_1based - 1][{&object, vol_id}].push_back(layer_idx);
                }
            }
        }
        layerCount++;
    }
 
    sort_remove_duplicates(firstLayerExtruders);
    const_cast<PrintObject&>(object).object_first_layer_wall_extruders = firstLayerExtruders;
 
    // 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   = false;
        bool          has_interface = false;
        for (const ExtrusionEntity *ee : support_layer->support_fills.entities) {
            ExtrusionRole er = ee->role();
            if (er == erSupportMaterial || er == erSupportTransition) has_support = true;
            if (er == erSupportMaterialInterface) has_interface = true;
            if (has_support && has_interface) break;
        }
        unsigned int extruder_support   = object.config().support_filament.value;
        unsigned int extruder_interface = object.config().support_interface_filament.value;
        if (has_support) {
            if (extruder_support > 0 || !has_interface || extruder_interface == 0 || layer_tools.has_object)
                layer_tools.extruders.push_back(extruder_support);
            else {
                auto all_extruders     = object.print()->extruders();
                auto get_next_extruder = [&](int current_extruder, const std::vector<unsigned int> &extruders) {
                    std::vector<float> flush_matrix(
                        cast<float>(get_flush_volumes_matrix(object.print()->config().flush_volumes_matrix.values, 0, object.print()->config().nozzle_diameter.values.size())));
                    const unsigned int number_of_extruders = (unsigned int) (sqrt(flush_matrix.size()) + EPSILON);
                    // Extract purging volumes for each extruder pair:
                    std::vector<std::vector<float>> wipe_volumes;
                    for (unsigned int i = 0; i < number_of_extruders; ++i)
                        wipe_volumes.push_back(std::vector<float>(flush_matrix.begin() + i * number_of_extruders, flush_matrix.begin() + (i + 1) * number_of_extruders));
                    int   next_extruder = current_extruder;
                    float min_flush     = std::numeric_limits<float>::max();
                    for (auto extruder_id : extruders) {
                        if (object.print()->config().filament_soluble.get_at(extruder_id) || extruder_id == current_extruder) continue;
                        if (wipe_volumes[extruder_interface - 1][extruder_id] < min_flush) {
                            next_extruder = extruder_id;
                            min_flush     = wipe_volumes[extruder_interface - 1][extruder_id];
                        }
                    }
                    return next_extruder;
                };
                bool interface_not_for_body = object.config().support_interface_not_for_body;
                layer_tools.extruders.push_back(get_next_extruder(interface_not_for_body ? extruder_interface - 1 : -1, all_extruders) + 1);
            }
        }
        if (has_interface) layer_tools.extruders.push_back(extruder_interface);
        if (has_support || has_interface) {
            layer_tools.has_support = true;
            layer_tools.wiping_extrusions().is_support_overriddable_and_mark(role, object);
        }
    }
 
    // Belt brim apron bands own their layers outright: they print below the
    // object's first layer, so no object or support layer claims an extruder there
    // and process_layer() would bail out at "Nothing to extrude".  Claim the
    // object's outer wall filament, in the same raw 1-based domain the loops above
    // push.  Deliberately not layer_tools.has_object, which drives skirt marking
    // and wiping overrides.
    if (! object.belt_brim_prologue().empty()) {
        // 1-based, same domain the object/support pushes above use; reindexed to 0-based
        // with the rest of the list later.
        const unsigned int brim_filament = object.belt_brim_filament();
        for (const BeltBrimBand &band : object.belt_brim_prologue()) {
            if (band.fills.empty())
                continue;
            LayerTools &layer_tools = this->tools_for_layer(band.print_z);
            layer_tools.extruders.push_back(brim_filament);
        }
    }
 
    // Coincident brim bands (belt_brim_by_layer) print ON an object layer rather than
    // below it, but that layer can produce no InstanceVisit in process_layer - a
    // zero-extrusion lead-in slice with no coinciding support - and the band would then
    // be silently dropped.  Register the brim filament on every layer that carries a
    // coincident band, in the same 1-based domain as the prologue push above, so a brim
    // pass always exists there.
    if (object.has_belt_brim()) {
        const unsigned int brim_filament = object.belt_brim_filament();
        const auto        &by_layer      = object.belt_brim_by_layer();
        const size_t       n             = std::min(by_layer.size(), object.layers().size());
        for (size_t i = 0; i < n; ++ i) {
            if (by_layer[i].empty())
                continue;
            LayerTools &layer_tools = this->tools_for_layer(object.layers()[i]->print_z);
            layer_tools.extruders.push_back(brim_filament);
        }
    }
 
    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::append(), Slic3r::PrintRegion::config(), EPSILON, Slic3r::PrintRegion::gradient_volume_id(), layer_tools(), m_gradient_volume_layers, m_layer_tools, m_mixed_object_layers, m_object_all_layer_indices, m_print_config_ptr, Slic3r::parse_mixed_components(), Slic3r::PrintRegionConfig, Slic3r::region_filament(), tools_for_layer(), and Slic3r::ObjectID::valid().

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

{ return m_layer_tools.empty(); }

References m_layer_tools.

Referenced by ToolOrdering(), generate_first_layer_tool_order(), generate_first_layer_tool_order(), and Slic3r::OozePrevention::pre_toolchange().

Here is the caller graph for this function:

end()

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

inline

{ return m_layer_tools.end(); }

References m_layer_tools.

enforce_mixed_component_order()

void Slic3r::ToolOrdering::enforce_mixed_component_order ( )

private

{
    for (LayerTools &lt : m_layer_tools) {
        if (lt.mixed_sub_layer_groups.empty())
            continue;
 
        // Build a set of extruders present in lt.extruders for fast lookup.
        std::set<unsigned int> ext_set(lt.extruders.begin(), lt.extruders.end());
 
        // 1. Build DAG from mixed group constraints.
        //    For each group [c0, c1, c2, ...], add edges c0->c1, c1->c2, ...
        //    Only between components that are both present in lt.extruders.
        //    Use an edge set to avoid duplicate edges inflating in-degree.
        std::map<unsigned int, std::vector<unsigned int>> adj;
        std::map<unsigned int, int> in_degree;
        std::set<std::pair<unsigned int, unsigned int>> edge_set;
 
        for (unsigned int ext : lt.extruders)
            in_degree[ext] = 0;
 
        for (const auto &grp : lt.mixed_sub_layer_groups) {
            for (size_t i = 0; i + 1 < grp.components_0based.size(); ++i) {
                unsigned int a = grp.components_0based[i];
                unsigned int b = grp.components_0based[i + 1];
                if (!ext_set.count(a) || !ext_set.count(b))
                    continue;
                if (edge_set.insert({a, b}).second) {
                    adj[a].push_back(b);
                    in_degree[b] += 1;
                }
            }
        }
 
        // 2. Record original position (from flush optimizer) as priority.
        std::map<unsigned int, size_t> orig_pos;
        for (size_t i = 0; i < lt.extruders.size(); ++i)
            orig_pos[lt.extruders[i]] = i;
 
        // 3. Kahn's topological sort with priority queue (prefer original position).
        auto cmp = [&orig_pos](unsigned int lhs, unsigned int rhs) {
            return orig_pos[lhs] > orig_pos[rhs]; // min-heap by orig_pos
        };
        std::priority_queue<unsigned int, std::vector<unsigned int>, decltype(cmp)> pq(cmp);
 
        for (unsigned int ext : lt.extruders) {
            if (in_degree[ext] == 0)
                pq.push(ext);
        }
 
        std::vector<unsigned int> ordered;
        ordered.reserve(lt.extruders.size());
        while (!pq.empty()) {
            unsigned int ext = pq.top();
            pq.pop();
            ordered.push_back(ext);
            if (auto it = adj.find(ext); it != adj.end()) {
                for (unsigned int next : it->second) {
                    if (--in_degree[next] == 0)
                        pq.push(next);
                }
            }
        }
 
        // Safety: if topological sort didn't produce all elements, keep original order.
        if (ordered.size() != lt.extruders.size())
            ordered = lt.extruders;
 
        // 4. Verify: every mixed group's component order is preserved as subsequence.
        for (const auto &grp : lt.mixed_sub_layer_groups) {
            size_t prev_pos = 0;
            bool valid = true;
            for (unsigned int c : grp.components_0based) {
                if (!ext_set.count(c))
                    continue;
                auto it = std::find(ordered.begin() + prev_pos, ordered.end(), c);
                if (it == ordered.end()) { valid = false; break; }
                prev_pos = (it - ordered.begin()) + 1;
            }
            assert(valid && "enforce_mixed_component_order: mixed group subsequence violated");
            (void)valid;
        }
 
        lt.extruders = ordered;
    }
}

References enforce_mixed_component_order(), and m_layer_tools.

Referenced by enforce_mixed_component_order(), sort_and_build_data(), and sort_and_build_data().

Here is the call graph for this function:

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);
 
 
    int wrapping_layer_nums = config.wrapping_detection_layers;
    for (size_t i = 0; i < wrapping_layer_nums; ++i) {
        if (i >= m_layer_tools.size())
            break;
        LayerTools &lt    = m_layer_tools[i];
        lt.has_wipe_tower = config.enable_wrapping_detection;
    }
 
    //FIXME this is a hack to get the ball rolling.
    // The `print_z < object_bottom_z` clause reads "below the object" as "raft
    // gap".  On a belt printer that is wrong: the brim apron legitimately prints
    // below the object's first layer, and treating those layers as raft would put a
    // wipe tower at negative Z.  A belt printer never prints the classic
    // prime tower (Print::has_wipe_tower()), so simply drop the clause there.
    //
    // Gate on config.belt_printer, NOT on has_belt_brim: every layer below the
    // object bottom on a belt printer is legitimately a sub-object stream - brim
    // apron, belt support printed below Z0, or the object's own lead-in - and none of
    // them is ever raft, because Print::validate() rejects raft_layers>0 on a belt
    // printer outright.  Narrowing this to has_belt_brim would reclassify
    // belt-support-below-floor layers as raft on brim-less belt prints and reintroduce
    // the negative-Z wipe tower, so the broad belt_printer gate is correct.
    const bool belt_no_raft_gap = config.belt_printer.value;
    for (LayerTools &lt : m_layer_tools)
        lt.has_wipe_tower |= ((lt.has_object || lt.has_support) && (config.timelapse_type == TimelapseType::tlSmooth || lt.wipe_tower_partitions > 0))
            || (! belt_no_raft_gap && lt.print_z < object_bottom_z + EPSILON);
 
    // Test for a raft, insert additional wipe tower layer to fill in the raft separation gap.
    // Skipped on belt printers for the same reason as the clause above: layers
    // below the object are brim apron, not raft.
    for (size_t i = 0; ! belt_no_raft_gap && 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;
        }
    }
 
    // Ensure wipe tower vertical continuity:
    //
    // (1) Any existing LayerTools sandwiched between two has_wipe_tower layers must itself be a
    //     wipe-tower layer. The LayerTools entry already exists, but it has neither object nor
    //     support geometry (has_object == false && has_support == false), so the marking pass
    //     above leaves has_wipe_tower == false. Happens e.g. when one object is fully floating
    //     above another and the support_top_z_distance / support_bottom_z_distance gap leaves an
    //     interior layer with no object and no support (e.g. B top z=20.4, A first layer z=20.8,
    //     the z=20.6 LayerTools entry exists but stays unmarked).
    //
    // (2) When two adjacent has_wipe_tower layers are farther apart than max_layer_height and no
    //     LayerTools entry exists between them, insert virtual wipe-tower-only layers to bridge
    //     the gap. Happens with raft: BambuStudio's raft contact layer can be thicker than
    //     max_layer_height (e.g. raft base top z=0.2, raft contact top z=0.5 — gap 0.3 > 0.28),
    //     and there is no LayerTools entry between those two z values.
    //
    // wipe_tower_partitions has already been max-propagated downward above, so partition counts
    // on the filled-in / inserted layers stay consistent.
    {
        int first_wt_idx = -1;
        int last_wt_idx  = -1;
        for (int i = 0; i < (int)m_layer_tools.size(); ++i)
            if (m_layer_tools[i].has_wipe_tower) {
                if (first_wt_idx < 0) first_wt_idx = i;
                last_wt_idx = i;
            }
        for (int i = first_wt_idx + 1; i < last_wt_idx; ++i) {
            LayerTools &lt = m_layer_tools[i];
            lt.has_wipe_tower = true;
            // GCode::process_layer emits wipe-tower G-code inside `for (extruder_id : layer_tools.extruders)`.
            // An empty extruders vector here would silently skip wipe tower output, leaving the tower
            // physically floating. Seed from the nearest non-empty neighbor so the loop actually runs.
            if (lt.extruders.empty()) {
                unsigned int seed_extruder = 0;
                bool         found_seed    = false;
                for (int j = i - 1; j >= 0; --j)
                    if (!m_layer_tools[j].extruders.empty()) {
                        seed_extruder = m_layer_tools[j].extruders.back();
                        found_seed = true;
                        break;
                    }
                if (!found_seed)
                    for (int j = i + 1; j < (int)m_layer_tools.size(); ++j)
                        if (!m_layer_tools[j].extruders.empty()) {
                            seed_extruder = m_layer_tools[j].extruders.front();
                            found_seed = true;
                            break;
                        }
                if (found_seed)
                    lt.extruders.push_back(seed_extruder);
            }
        }
 
        // Walk adjacent has_wipe_tower pairs and split oversized gaps. Re-evaluate the same i
        // after each insertion so very large gaps get split into multiple layers.
        for (int i = 0; i + 1 < (int)m_layer_tools.size(); ) {
            LayerTools &lt      = m_layer_tools[i];
            LayerTools &lt_next = m_layer_tools[i + 1];
            if (!lt.has_wipe_tower || !lt_next.has_wipe_tower) {
                ++i;
                continue;
            }
            coordf_t gap = lt_next.print_z - lt.print_z;
            if (gap <= max_layer_height + EPSILON) {
                ++i;
                continue;
            }
            LayerTools lt_new(0.5 * (lt.print_z + lt_next.print_z));
            lt_new.has_wipe_tower = true;
            if (!lt_next.extruders.empty())
                lt_new.extruders.push_back(lt_next.extruders.front());
            else if (!lt.extruders.empty())
                lt_new.extruders.push_back(lt.extruders.back());
            lt_new.wipe_tower_partitions = lt_next.wipe_tower_partitions;
            m_layer_tools.insert(m_layer_tools.begin() + i + 1, lt_new);
        }
    }
 
    // 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) {
                if (!config.enable_wrapping_detection)
                    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, fill_wipe_tower_partitions(), Slic3r::LayerTools::has_wipe_tower, has_wipe_tower(), last_extruder(), m_layer_tools, Slic3r::LayerTools::print_z, Slic3r::tlSmooth, and Slic3r::LayerTools::wipe_tower_partitions.

Referenced by fill_wipe_tower_partitions(), sort_and_build_data(), and sort_and_build_data().

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

{ return m_first_printing_extruder; }

References m_first_printing_extruder.

Referenced by ToolOrdering(), ToolOrdering(), ToolOrdering(), Slic3r::GCode::_do_export(), Slic3r::CLI::run(), sort_and_build_data(), and sort_and_build_data().

Here is the caller graph for this function:

front()

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

inline

{ return m_layer_tools.front(); }

References m_layer_tools.

Referenced by sort_and_build_data().

Here is the caller graph for this function:

generate_first_layer_tool_order() [1/2]

std::vector< unsigned int > Slic3r::ToolOrdering::generate_first_layer_tool_order ( const Print & print )

private

{
    std::vector<unsigned int> tool_order;
    int initial_extruder_id = -1;
    std::map<int, double> min_areas_per_extruder;
 
    for (auto object : print.objects()) {
        const Layer* target_layer = nullptr;
        for(auto layer : object->layers()){
            for(auto layerm : layer->regions()){
                for(auto& expoly : layerm->raw_slices){
                    if (!offset_ex(expoly, -0.2 * scale_(print.config().initial_layer_line_width)).empty()) {
                        target_layer = layer;
                        break;
                    }
                }
                if(target_layer)
                    break;
            }
            if(target_layer)
                break;
        }
 
        if(!target_layer)
            return tool_order;
 
        for (auto layerm : target_layer->regions()) {
            int extruder_id = layerm->region().config().option("outer_wall_filament_id")->getInt();
 
            for (auto expoly : layerm->raw_slices) {
                const double nozzle_diameter = print.config().nozzle_diameter.get_at(0);
                const coordf_t initial_layer_line_width = print.config().get_abs_value("initial_layer_line_width", nozzle_diameter);
 
                if (offset_ex(expoly, -0.2 * scale_(initial_layer_line_width)).empty())
                    continue;
 
                double contour_area = expoly.contour.area();
                auto iter = min_areas_per_extruder.find(extruder_id);
                if (iter == min_areas_per_extruder.end()) {
                    min_areas_per_extruder.insert({ extruder_id, contour_area });
                }
                else {
                    if (contour_area < min_areas_per_extruder.at(extruder_id)) {
                        min_areas_per_extruder[extruder_id] = contour_area;
                    }
                }
            }
        }
    }
 
    double max_minimal_area = 0.;
    for (auto ape : min_areas_per_extruder) {
        auto iter = tool_order.begin();
        for (; iter != tool_order.end(); iter++) {
            if (min_areas_per_extruder.at(*iter) < min_areas_per_extruder.at(ape.first))
                break;
        }
 
        tool_order.insert(iter, ape.first);
    }
 
    apply_first_layer_order(m_print_full_config, tool_order);
 
    return tool_order;
}

References Slic3r::apply_first_layer_order(), Slic3r::Print::config(), empty(), m_print_full_config, Slic3r::nozzle_diameter(), Slic3r::Print::objects(), Slic3r::offset_ex(), Slic3r::Layer::regions(), and scale_.

Referenced by ToolOrdering(), and ToolOrdering().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_first_layer_tool_order() [2/2]

std::vector< unsigned int > Slic3r::ToolOrdering::generate_first_layer_tool_order ( const PrintObject & object )

private

{
    std::vector<unsigned int> tool_order;
    int initial_extruder_id = -1;
    std::map<int, double> min_areas_per_extruder;
    const Layer* target_layer = nullptr;
    for(auto layer : object.layers()){
        for(auto layerm : layer->regions()){
            for(auto& expoly : layerm->raw_slices){
                if (!offset_ex(expoly, -0.2 * scale_(object.config().line_width)).empty()) {
                    target_layer = layer;
                    break;
                }
            }
            if(target_layer)
                break;
        }
        if(target_layer)
            break;
    }
 
    if(!target_layer)
        return tool_order;
 
    for (auto layerm : target_layer->regions()) {
        int extruder_id = layerm->region().config().option("outer_wall_filament_id")->getInt();
        for (auto expoly : layerm->raw_slices) {
            const double nozzle_diameter = object.print()->config().nozzle_diameter.get_at(0);
            const coordf_t line_width = object.config().get_abs_value("line_width", nozzle_diameter);
 
            if (offset_ex(expoly, -0.2 * scale_(line_width)).empty())
                continue;
 
            double contour_area = expoly.contour.area();
            auto iter = min_areas_per_extruder.find(extruder_id);
            if (iter == min_areas_per_extruder.end()) {
                min_areas_per_extruder.insert({ extruder_id, contour_area });
            }
            else {
                if (contour_area < min_areas_per_extruder.at(extruder_id)) {
                    min_areas_per_extruder[extruder_id] = contour_area;
                }
            }
        }
    }
 
    double max_minimal_area = 0.;
    for (auto ape : min_areas_per_extruder) {
        auto iter = tool_order.begin();
        for (; iter != tool_order.end(); iter++) {
            if (min_areas_per_extruder.at(*iter) < min_areas_per_extruder.at(ape.first))
                break;
        }
 
        tool_order.insert(iter, ape.first);
    }
 
    apply_first_layer_order(m_print_full_config, tool_order);
 
    return tool_order;
}

References Slic3r::apply_first_layer_order(), empty(), m_print_full_config, Slic3r::nozzle_diameter(), Slic3r::offset_ex(), Slic3r::Layer::regions(), and scale_.

Here is the call graph for this function:

get_filament_change_stats()

FilamentChangeStats Slic3r::ToolOrdering::get_filament_change_stats

(

FilamentChangeMode

mode

)

{
    switch (mode)
    {
    case Slic3r::ToolOrdering::SingleExt:
        return m_stats_by_single_extruder;
    case Slic3r::ToolOrdering::MultiExtBest:
        return m_stats_by_multi_extruder_best;
    case Slic3r::ToolOrdering::MultiExtCurr:
        return m_stats_by_multi_extruder_curr;
    default:
        break;
    }
    return m_stats_by_single_extruder;
}

References get_filament_change_stats(), m_stats_by_multi_extruder_best, m_stats_by_multi_extruder_curr, m_stats_by_single_extruder, MultiExtBest, MultiExtCurr, and SingleExt.

Referenced by Slic3r::GCode::_do_export(), and get_filament_change_stats().

Here is the call graph for this function:

Here is the caller graph for this function:

get_layered_nozzle_group_result()

const MultiNozzleUtils::LayeredNozzleGroupResult & Slic3r::ToolOrdering::get_layered_nozzle_group_result ( ) const

inline

{ return m_nozzle_group_result; }

References m_nozzle_group_result.

get_most_used_extruder()

int Slic3r::ToolOrdering::get_most_used_extruder ( ) const

inline

{ return most_used_extruder; }

References most_used_extruder.

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

Here is the caller graph for this function:

get_nozzle_status()

const MultiNozzleUtils::NozzleStatusRecorder & Slic3r::ToolOrdering::get_nozzle_status ( ) const

inline

{ return m_nozzle_status; }

References m_nozzle_status.

get_recommended_filament_maps()

MultiNozzleUtils::LayeredNozzleGroupResult Slic3r::ToolOrdering::get_recommended_filament_maps ( const std::vector< std::vector< unsigned int > > & layer_filaments, const Print * print, const FilamentMapMode mode, const std::vector< std::set< int > > & physical_unprintables, const std::vector< std::set< int > > & geometric_unprintables, const std::map< int, std::set< NozzleVolumeType > > & unprintable_volumes = {}, const std::unordered_map< int, int > & nozzle_status = {} )

static

{
    using namespace MultiNozzleUtils;
 
    if (!print || layer_filaments.empty())
        return LayeredNozzleGroupResult();
 
    const auto&  print_config  = print->config();
    size_t       filament_nums = print_config.filament_colour.values.size();
    size_t       extruder_nums = print_config.nozzle_diameter.values.size();
    auto         used_filaments = collect_sorted_used_filaments(layer_filaments);
    bool         has_multiple_nozzle = std::any_of(print_config.extruder_max_nozzle_count.values.begin(), print_config.extruder_max_nozzle_count.values.end(),
                                                   [](int v) { return v > 1; });
    bool         has_multiple_extruder = extruder_nums > 1;
 
    auto nozzle_list = build_default_nozzle_list(print_config, extruder_nums);
 
    // Manual mode: build directly from the user's filament->extruder map.
    if (mode == FilamentMapMode::fmmManual && !has_multiple_nozzle) {
        auto manual_filament_map = print_config.filament_map.values;
        std::transform(manual_filament_map.begin(), manual_filament_map.end(), manual_filament_map.begin(), [](int v) { return v - 1; });
        auto result = LayeredNozzleGroupResult::create(manual_filament_map, nozzle_list, used_filaments);
        return result ? *result : LayeredNozzleGroupResult();
    }
 
    // Fully-manual mode: build the nozzle-granular result from the config nozzle map.
    if (mode == FilamentMapMode::fmmNozzleManual) {
        auto manual_filament_map = print_config.filament_map.values;
        std::transform(manual_filament_map.begin(), manual_filament_map.end(), manual_filament_map.begin(), [](int v) { return v - 1; });
        float diameter = print_config.nozzle_diameter.values.empty() ? 0.4f : (float)print_config.nozzle_diameter.values.front();
        // Orca: create() indexes the volume/nozzle maps per used filament with no bounds check, so
        // pass them only when a producer sized them to the filament count (mis-sized maps can
        // arrive from stale projects or CLI runs until the per-filament synthesis lands there).
        // Without valid maps the fully-manual request cannot be honoured; return the empty result,
        // the same failure an unsatisfiable create() yields.
        std::optional<LayeredNozzleGroupResult> nozzle_result;
        if (print_config.filament_volume_map.values.size() == filament_nums &&
            print_config.filament_nozzle_map.values.size() == filament_nums)
            nozzle_result = LayeredNozzleGroupResult::create(used_filaments, manual_filament_map, print_config.filament_volume_map.values, print_config.filament_nozzle_map.values, get_extruder_nozzle_stats(print_config.extruder_nozzle_stats.values), diameter);
        if (!nozzle_result)
            BOOST_LOG_TRIVIAL(error) << "Failed to build nozzle group result from filament nozzle map!";
        return nozzle_result ? *nozzle_result : LayeredNozzleGroupResult();
    }
 
    int              master_extruder_id = print_config.master_extruder_id.value - 1;
    std::vector<int> ret(filament_nums, master_extruder_id);
 
    // Non-BBL multi-extruder printers do not support filament grouping: filament id == extruder id.
    if (has_multiple_extruder && !print->is_BBL_printer()) {
        for (size_t i = 0; i < filament_nums && i < extruder_nums; i++)
            ret[i] = (int)i;
        auto result_opt = LayeredNozzleGroupResult::create(ret, nozzle_list, used_filaments);
        return result_opt ? *result_opt : LayeredNozzleGroupResult();
    }
 
    if (has_multiple_extruder || has_multiple_nozzle) {
        auto context = build_filament_group_context(print, layer_filaments, physical_unprintables, geometric_unprintables, unprintable_volumes, mode, nozzle_status);
 
        // other_layers_seq custom-sequence lambda (1-based layer/extruder). Only threaded for the
        // single-nozzle-per-extruder engine.
        std::vector<LayerPrintSequence> other_layers_seqs = get_other_layers_print_sequence(print_config.other_layers_print_sequence_nums.value, print_config.other_layers_print_sequence.values);
        auto get_custom_seq = [other_layers_seqs](int layer_idx, std::vector<int>& out_seq) -> bool {
            for (size_t idx = other_layers_seqs.size() - 1; idx != size_t(-1); --idx) {
                const auto& other_layers_seq = other_layers_seqs[idx];
                if (layer_idx + 1 >= other_layers_seq.first.first && layer_idx + 1 <= other_layers_seq.first.second) {
                    out_seq = other_layers_seq.second;
                    return true;
                }
            }
            return false;
        };
 
        if (has_multiple_nozzle && mode == FilamentMapMode::fmmManual) {
            auto manual_filament_map = print_config.filament_map.values;
            std::transform(manual_filament_map.begin(), manual_filament_map.end(), manual_filament_map.begin(), [](int v) { return v - 1; });
            ret = calc_filament_group_for_manual_multi_nozzle(manual_filament_map, context);
        } else if (has_multiple_nozzle && mode == FilamentMapMode::fmmAutoForMatch) {
            ret = calc_filament_group_for_match_multi_nozzle(context);
        } else {
            // TPU: keep the dedicated TPU split for single-nozzle-per-extruder printers.
            auto tpu_filaments = get_filament_by_type(used_filaments, &print_config, "TPU");
            if (!has_multiple_nozzle && !tpu_filaments.empty()) {
                ret = std::vector<int>(context.group_info.total_filament_num, context.machine_info.master_extruder_id);
                for (size_t fidx = 0; fidx < (size_t)context.group_info.total_filament_num; ++fidx)
                    ret[fidx] = tpu_filaments.count((int)fidx) ? context.machine_info.master_extruder_id : (1 - context.machine_info.master_extruder_id);
            } else {
                FilamentGroup fg(context);
                if (!has_multiple_nozzle)
                    fg.get_custom_seq = get_custom_seq;
                ret = fg.calc_filament_group();
                // Flush-mode auto grouping: restore the master-extruder preference
                // (optimize_group_for_master_extruder). Match mode assigns by AMS colour and never had
                // it. Kept out of the FilamentGroup engine so the test harness is unaffected.
                if (context.group_info.mode == FGMode::FlushMode)
                    ret = apply_master_extruder_preference(context, used_filaments, ret);
            }
        }
 
        if (has_multiple_nozzle) {
            auto result_opt = LayeredNozzleGroupResult::create(ret, context.nozzle_info.nozzle_list, used_filaments);
            if (!result_opt)
                return LayeredNozzleGroupResult();
            auto result = *result_opt;
            if (mode == FilamentMapMode::fmmManual) {
                // Manual grouping must reproduce the user's filament->extruder map exactly; a
                // deviation means the requested assignment cannot be satisfied by the nozzle
                // inventory, which must surface as a slicing error instead of silently regrouping.
                auto result_map = result.get_extruder_map();
                for (auto fid : used_filaments) {
                    if (result_map[fid] != print_config.filament_map.values[fid] - 1) {
                        throw Slic3r::RuntimeError(_L("Group error in manual mode. Please check nozzle count or regroup."));
                    }
                }
            }
            return result;
        }
    }
 
    auto result_opt = LayeredNozzleGroupResult::create(ret, nozzle_list, used_filaments);
    return result_opt ? *result_opt : LayeredNozzleGroupResult();
}

References _L, Slic3r::apply_master_extruder_preference(), Slic3r::build_default_nozzle_list(), Slic3r::build_filament_group_context(), Slic3r::FilamentGroup::calc_filament_group(), Slic3r::calc_filament_group_for_manual_multi_nozzle(), Slic3r::calc_filament_group_for_match_multi_nozzle(), Slic3r::collect_sorted_used_filaments(), Slic3r::Print::config(), Slic3r::Print::empty(), Slic3r::FlushMode, Slic3r::fmmAutoForMatch, Slic3r::fmmManual, Slic3r::fmmNozzleManual, Slic3r::FilamentGroup::get_custom_seq, Slic3r::get_extruder_nozzle_stats(), Slic3r::get_filament_by_type(), Slic3r::get_other_layers_print_sequence(), get_recommended_filament_maps(), Slic3r::Print::is_BBL_printer(), and Slic3r::master_extruder_id().

Referenced by get_recommended_filament_maps(), and Slic3r::plan_filament_mapping_and_order_by_combo_ranges().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_dontcare_extruder() [1/2]

void Slic3r::ToolOrdering::handle_dontcare_extruder

(

const std::vector< unsigned int > &

first_layer_tool_order

)

{
    const PrintConfig* print_config = m_print_config_ptr;
    if (!print_config && m_print_object_ptr)
        print_config = &m_print_object_ptr->print()->config();
 
    if(m_layer_tools.empty() || tool_order_layer0.empty())
        return;
 
    // Reorder the extruders of first layer
    {
        LayerTools& lt = m_layer_tools[0];
        std::vector<unsigned int> layer0_extruders = lt.extruders;
        lt.extruders.clear();
        for (unsigned int extruder_id : tool_order_layer0) {
            auto iter = std::find(layer0_extruders.begin(), layer0_extruders.end(), extruder_id);
            if (iter != layer0_extruders.end()) {
                lt.extruders.push_back(extruder_id);
                *iter = (unsigned int)-1;
            }
        }
 
        for (unsigned int extruder_id : layer0_extruders) {
            if (extruder_id == 0)
                continue;
 
            if (extruder_id != (unsigned int)-1)
                lt.extruders.push_back(extruder_id);
        }
 
        // all extruders are zero
        if (lt.extruders.empty()) {
            lt.extruders.push_back(tool_order_layer0[0]);
        }
    }
 
    int last_extruder_id = m_layer_tools[0].extruders.back();
    for (int i = 1; i < m_layer_tools.size(); i++) {
        LayerTools& lt = m_layer_tools[i];
 
        // Extruders in lt.extruders are already sorted.
 
        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());
 
            if (print_config == nullptr
                || print_config->toolchange_ordering == ToolChangeOrderingType::Default)
            {
                // 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.
                        std::rotate(
                            lt.extruders.begin(),
                            lt.extruders.begin() + i,
                            lt.extruders.begin() + i + 1
                        );
                        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::Default, Slic3r::LayerTools::extruders, m_layer_tools, m_print_config_ptr, and m_print_object_ptr.

Referenced by ToolOrdering(), and ToolOrdering().

Here is the caller graph for this function:

handle_dontcare_extruder() [2/2]

void Slic3r::ToolOrdering::handle_dontcare_extruder

(

unsigned int

first_extruder

)

{
    const PrintConfig* print_config = m_print_config_ptr;
    if (!print_config && m_print_object_ptr)
        print_config = &m_print_object_ptr->print()->config();
 
    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 idx
        ++ last_extruder_id;
    }
 
    for (LayerTools &lt : m_layer_tools) {
        // Extruders in lt.extruders are already sorted.
 
        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());
 
            if (print_config == nullptr
                || print_config->toolchange_ordering == ToolChangeOrderingType::Default)
            {
                // 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.
                        std::rotate(
                            lt.extruders.begin(),
                            lt.extruders.begin() + i,
                            lt.extruders.begin() + i + 1
                        );
                        break;
                    }
                }
            }
 
            if (lt == m_layer_tools[0]) {
                // On first layer with wipe tower, prefer a soluble extruder
                // at the beginning, so it is not wiped on the first layer.
                if (print_config && print_config->enable_prime_tower) {
                    for (size_t i = 0; i<lt.extruders.size(); ++i)
                        if (print_config->filament_soluble.get_at(lt.extruders[i]-1)) { // 1-based...
                            std::swap(lt.extruders[i], lt.extruders.front());
                            break;
                        }
                }
 
                // Then, if we specified the tool order, apply it now
                apply_first_layer_order(m_print_full_config, lt.extruders);
            }
 
        }
        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::apply_first_layer_order(), Slic3r::Default, Slic3r::LayerTools::extruders, m_layer_tools, m_print_config_ptr, m_print_full_config, and m_print_object_ptr.

Here is the call graph for this function:

has_non_support_filament()

bool Slic3r::ToolOrdering::has_non_support_filament

(

const PrintConfig &

config

)

                                                                     {
    for (const unsigned int &filament : m_all_printing_extruders) {
        if (!config.filament_is_support.get_at(filament)) {
            return true;
        }
    }
 
    return false;
}

References has_non_support_filament(), and m_all_printing_extruders.

Referenced by cal_non_support_filaments(), and has_non_support_filament().

Here is the call graph for this function:

Here is the caller graph for this function:

has_wipe_tower()

bool Slic3r::ToolOrdering::has_wipe_tower ( ) const

inline

{ return ! m_layer_tools.empty() && m_first_printing_extruder != (unsigned int)-1 && m_layer_tools.front().has_wipe_tower; }

References m_first_printing_extruder, and m_layer_tools.

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

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

{
    if (!m_print_config_ptr || !m_print_config_ptr->enable_prime_tower)
        return false;
    // Belt mode has no classic wipe tower; the dedicated wipe tower filament
    // must not inject extra toolchanges into the purge prism planning.
    if (m_print_config_ptr->belt_printer)
        return false;
    if (m_print_config_ptr->wipe_tower_filament == 0)
        return false;
 
    bool changed = false;
    const unsigned int wipe_extruder = (unsigned int)(m_print_config_ptr->wipe_tower_filament - 1);
    for (LayerTools &lt : m_layer_tools) {
        if (lt.wipe_tower_partitions > 0) {
            if (std::find(lt.extruders.begin(), lt.extruders.end(), wipe_extruder) == lt.extruders.end()) {
                lt.extruders.emplace_back(wipe_extruder);
                changed = true;
            }
        }
    }
    return changed;
}

References m_layer_tools, and m_print_config_ptr.

Referenced by sort_and_build_data(), and sort_and_build_data().

Here is the caller graph for this function:

is_last_extrusion_layer()

bool Slic3r::ToolOrdering::is_last_extrusion_layer	(	coordf_t	print_z,
		unsigned int	extruder_id ) const

{
    auto it = m_last_layer_per_extruder.find(extruder_id);
    if (it == m_last_layer_per_extruder.end())
        return true;
    return print_z >= it->second - EPSILON;
}

References EPSILON, is_last_extrusion_layer(), and m_last_layer_per_extruder.

Referenced by is_last_extrusion_layer().

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

{ return m_last_printing_extruder; }

References m_last_printing_extruder.

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

Here is the caller graph for this function:

layer_tools()

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

inline

{ return m_layer_tools; }

References m_layer_tools.

Referenced by Slic3r::GCode::_do_export(), cal_max_additional_fan(), cal_most_used_extruder(), 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, Slic3r::has_skirt(), m_layer_tools, and mark_skirt_layers().

Referenced by ToolOrdering(), ToolOrdering(), and mark_skirt_layers().

Here is the call graph for this function:

Here is the caller graph for this function:

reorder_extruders_for_minimum_flush_volume()

void Slic3r::ToolOrdering::reorder_extruders_for_minimum_flush_volume ( bool reorder_first_layer )

private

{
    const PrintConfig* print_config = m_print_config_ptr;
    if (!print_config && m_print_object_ptr) {
        print_config = &(m_print_object_ptr->print()->config());
    }
 
    if (!print_config || m_layer_tools.empty())
        return;
 
    const unsigned int number_of_extruders = (unsigned int)(print_config->filament_colour.values.size() + EPSILON);
 
    using FlushMatrix = std::vector<std::vector<float>>;
    size_t             nozzle_nums = print_config->nozzle_diameter.values.size();
    const auto wipe_tower_type = m_print->wipe_tower_type();
 
    std::vector<FlushMatrix> nozzle_flush_mtx;
    for (size_t nozzle_id = 0; nozzle_id < nozzle_nums; ++nozzle_id) {
        std::vector<float> flush_matrix(cast<float>(get_flush_volumes_matrix(print_config->flush_volumes_matrix.values, nozzle_id, nozzle_nums)));
        std::vector<std::vector<float>> wipe_volumes;
        if ((print_config->purge_in_prime_tower && print_config->single_extruder_multi_material) || wipe_tower_type == WipeTowerType::Type1) {
            for (unsigned int i = 0; i < number_of_extruders; ++i)
                wipe_volumes.push_back(std::vector<float>(flush_matrix.begin() + i * number_of_extruders, flush_matrix.begin() + (i + 1) * number_of_extruders));
        } else {
            // populate wipe_volumes with prime_volume
            for (unsigned int i = 0; i < number_of_extruders; ++i)
                wipe_volumes.push_back(std::vector<float>(number_of_extruders, print_config->prime_volume));
        }
        nozzle_flush_mtx.emplace_back(wipe_volumes);
    }
 
    // Fast purge mode uses flush_multiplier_fast; Default is inert.
    auto flush_multiplies = (print_config->prime_volume_mode == PrimeVolumeMode::pvmFast) ? print_config->flush_multiplier_fast.values
                                                                                          : print_config->flush_multiplier.values;
    flush_multiplies.resize(nozzle_nums, 1);
    for (size_t nozzle_id = 0; nozzle_id < nozzle_nums; ++nozzle_id) {
        for (auto& vec : nozzle_flush_mtx[nozzle_id]) {
            for (auto& v : vec)
                v *= flush_multiplies[nozzle_id];
        }
    }
 
    std::vector<int>filament_maps(number_of_extruders, 0);
    FilamentMapMode map_mode = FilamentMapMode::fmmAutoForFlush;
 
    std::vector<std::vector<unsigned int>> layer_filaments;
    for (auto& lt : m_layer_tools) {
        layer_filaments.emplace_back(lt.extruders);
    }
 
    std::vector<unsigned int> used_filaments = collect_sorted_used_filaments(layer_filaments);
 
    std::vector<std::set<int>>geometric_unprintables = m_print->get_geometric_unprintable_filaments();
 
    // Unprintable sets are keyed by filament id, but a mixed-color slot is virtual: what actually
    // reaches the nozzle are its components. Expand the slot to those components so a geometric
    // restriction is applied to the filaments really being printed. No-op without mixed filaments.
    {
        const auto &is_mixed  = m_print->config().filament_is_mixed.values;
        const auto &comp_strs = m_print->config().filament_mixed_components.values;
        if (has_any_mixed_filament(is_mixed))
            expand_mixed_slots_in_unprintables(geometric_unprintables, is_mixed, comp_strs);
    }
 
    std::vector<std::set<int>>physical_unprintables = m_print->get_physical_unprintable_filaments(used_filaments);
    auto filament_unprintable_volumes = m_print->get_filament_unprintable_flow(used_filaments);
 
    filament_maps = m_print->get_filament_maps();
    map_mode = m_print->get_filament_map_mode();
 
    // Grouping now yields a nozzle-aware LayeredNozzleGroupResult; the
    // extruder-level filament_maps that feeds the ordering/stats below is derived from it.
    MultiNozzleUtils::LayeredNozzleGroupResult grouping_result;
 
    // The custom-sequence machinery is built before the grouping decision so both the static reorder
    // and the dynamic per-layer plan can share it. Pure local setup (no dependency on the
    // grouping result), so hoisting it above the branch does not change the static path's output.
    std::vector<std::vector<unsigned int>>filament_sequences;
    std::vector<unsigned int>filament_lists(number_of_extruders);
    std::iota(filament_lists.begin(), filament_lists.end(), 0);
 
    std::vector<LayerPrintSequence> other_layers_seqs;
    const ConfigOptionInts* other_layers_print_sequence_op = print_config->option<ConfigOptionInts>("other_layers_print_sequence");
    const ConfigOptionInt* other_layers_print_sequence_nums_op = print_config->option<ConfigOptionInt>("other_layers_print_sequence_nums");
    if (other_layers_print_sequence_op && other_layers_print_sequence_nums_op) {
        const std::vector<int>& print_sequence = other_layers_print_sequence_op->values;
        int                     sequence_nums = other_layers_print_sequence_nums_op->value;
        other_layers_seqs = get_other_layers_print_sequence(sequence_nums, print_sequence);
    }
 
    std::vector<unsigned int>first_layer_filaments;
    if (!m_layer_tools.empty())
        first_layer_filaments = m_layer_tools[0].extruders;
 
    const bool use_cyclic_ordering =
        (print_config->toolchange_ordering == ToolChangeOrderingType::Cyclic);
 
    // By default the first layer keeps its adhesion-optimized order (and any custom first layer
    // sequence); the cyclic sequence is only forced onto it when the user opts in.
    const bool cyclic_first_layer = use_cyclic_ordering && print_config->toolchange_cyclic_first_layer.value;
 
    // Optional user defined cyclic sequence, given as 1-based filament numbers ("3,2,1,4"). Filaments
    // missing from it keep their ascending order after the listed ones, so a partial or bogus entry
    // still yields the default cyclic order.
    const std::vector<unsigned int> cyclic_order =
        use_cyclic_ordering ? parse_cyclic_order(print_config->toolchange_cyclic_order.value, number_of_extruders)
                            : std::vector<unsigned int>();
 
    // Reorder a layer's filaments (0-based) for cyclic ordering: ascending by default, or following the
    // user defined sequence when one was given. Filaments absent from the sequence keep ascending order
    // after the listed ones.
    auto apply_cyclic_order = [&cyclic_order](std::vector<unsigned int>& filaments) {
        std::sort(filaments.begin(), filaments.end());
        if (!cyclic_order.empty())
            std::stable_sort(filaments.begin(), filaments.end(), [&cyclic_order](unsigned int lhs, unsigned int rhs) {
                auto rank = [&cyclic_order](unsigned int filament) {
                    return size_t(std::find(cyclic_order.begin(), cyclic_order.end(), filament) - cyclic_order.begin());
                };
                return rank(lhs) < rank(rhs);
            });
    };
 
    // other_layers_seq: the layer_idx and extruder_idx are base on 1
    auto get_custom_seq = [&other_layers_seqs, &reorder_first_layer, &first_layer_filaments, &layer_filaments, use_cyclic_ordering, cyclic_first_layer, &apply_cyclic_order](int layer_idx, std::vector<int>& out_seq) -> bool {
        if (!reorder_first_layer && layer_idx == 0) {
            // The first layer tool order is already decided (adhesion-optimized, plus any custom first
            // layer sequence). Only override it with the cyclic sequence when the user opted in.
            std::vector<unsigned int> ordered = first_layer_filaments;
            if (cyclic_first_layer)
                apply_cyclic_order(ordered);
            out_seq.resize(ordered.size());
            std::transform(ordered.begin(), ordered.end(), out_seq.begin(), [](auto item) {return int(item) + 1; });
            return true;
        }
        for (size_t idx = other_layers_seqs.size() - 1; idx != size_t(-1); --idx) {
            const auto& other_layers_seq = other_layers_seqs[idx];
            if (layer_idx + 1 >= other_layers_seq.first.first && layer_idx + 1 <= other_layers_seq.first.second) {
                out_seq = other_layers_seq.second;
                return true;
            }
        }
 
        // Skip the first layer here (layer_idx == 0 only reaches this point on the reorder_first_layer
        // path) unless the user asked for cyclic order on it, so it keeps the default flush ordering.
        if (use_cyclic_ordering && layer_idx >= 0 && (layer_idx != 0 || cyclic_first_layer)
            && size_t(layer_idx) < layer_filaments.size()) {
            std::vector<unsigned int> ordered = layer_filaments[size_t(layer_idx)];
            apply_cyclic_order(ordered);
            out_seq.resize(ordered.size());
            std::transform(ordered.begin(), ordered.end(), out_seq.begin(), [](auto item) { return int(item) + 1; });
            return true;
        }
 
        return false;
        };
 
    // Dynamic (per-layer filament-selector) regroup. is_dynamic_group_reorder()
    // gates on enable_filament_dynamic_map (unset on every current profile), so this is closed for the
    // whole shipping fleet AND H2C static mode — the static branch below is the only one they take, so
    // their g-code is byte-identical. Only an H2C profile that enables the selector opens this branch.
    const bool dynamic_reorder = m_print && m_print->is_dynamic_group_reorder();
    // Orca: there is no is_sequential_print() helper, so the not-sequential check is mirrored with
    // the same predicate the static by-object gate below uses. Sequential prints (with more than
    // one object) publish and write back from the by-object branch in Print::process instead of
    // from each per-object ordering.
    const bool not_sequential = print_config->print_sequence != PrintSequence::ByObject ||
                                (m_print && m_print->objects().size() == 1);
 
    if (dynamic_reorder) {
        // Build the grouping context, plan per-combo-range nozzle maps + filament orders, then wrap the
        // per-layer maps in a selector (4-arg create) result — which sets support_dynamic_nozzle_map and
        // lights the GCode per-layer hotend/nozzle placeholders. filament_sequences is produced here, so
        // the static reorder below is skipped for this branch.
        auto grouping_context = build_filament_group_context(m_print, layer_filaments, physical_unprintables, geometric_unprintables, filament_unprintable_volumes, FilamentMapMode::fmmAutoForFlush,
                                                             m_initial_nozzle_status.get_nozzle_filament_map());
        // The time estimator's per-extruder print times are global and do not apply to per-range
        // grouping.
        grouping_context.speed_info.group_with_time = false;
 
        m_nozzle_status = m_initial_nozzle_status;
        auto dynamic_plan_res = plan_filament_mapping_and_order_by_combo_ranges(m_print, grouping_context, get_custom_seq, FilamentMapMode::fmmAutoForFlush,
                                                                                physical_unprintables, geometric_unprintables, filament_unprintable_volumes, &m_nozzle_status);
 
        std::vector<std::vector<int>> nozzle_map_per_layer;
        for (auto& res : dynamic_plan_res) {
            filament_sequences.emplace_back(cast<unsigned int>(res.fil_order));
            nozzle_map_per_layer.emplace_back(res.fil_nozzle_match);
        }
 
        auto result   = MultiNozzleUtils::LayeredNozzleGroupResult::create(nozzle_map_per_layer, grouping_context.nozzle_info.nozzle_list, used_filaments, filament_sequences);
        grouping_result = result ? *result : MultiNozzleUtils::LayeredNozzleGroupResult();
 
        // Derive the extruder-level map for the stats path; the write-back resolves the
        // per-variant slots from the full grouping result itself.
        std::vector<int> derived_maps = grouping_result.get_extruder_map(false); // 1-based
        if (!derived_maps.empty()) {
            filament_maps = derived_maps;
            // A sequential per-object plan must not write its own map: the objects' plans are
            // stitched print-wide afterwards and written back once from there.
            if (not_sequential)
                m_print->update_to_config_by_nozzle_group_result(grouping_result);
        }
        std::transform(filament_maps.begin(), filament_maps.end(), filament_maps.begin(), [](int value) { return value - 1; });
    }
    // only check and map in sequence mode, in by object mode, we check the map in print.cpp
    else if (print_config->print_sequence != PrintSequence::ByObject || m_print->objects().size() == 1) {
        grouping_result = ToolOrdering::get_recommended_filament_maps(layer_filaments, m_print, map_mode, physical_unprintables, geometric_unprintables, filament_unprintable_volumes);
        std::vector<int> derived_maps = grouping_result.get_extruder_map(false); // 1-based extruder map
 
        if (map_mode < FilamentMapMode::fmmManual) {
            if (derived_maps.empty())
                return;
            filament_maps = derived_maps;
        } else if (!derived_maps.empty()) {
            // Manual modes: the result mirrors the user's config map; adopt it for consistency.
            filament_maps = derived_maps;
        }
        // Write the maps back for every mode: used filaments adopt the engine's extruder/nozzle
        // choice, unused ones keep their config assignment. In manual modes the extruder map
        // mirrors the user's map (a deviation throws in get_recommended_filament_maps).
        if (!derived_maps.empty()) {
            // Orca: the config maps are the merge base; fall back to a synthesized base when no
            // producer sized them to the filament count (CLI runs until the per-filament
            // synthesis lands there), where indexing per filament would run out of bounds.
            std::vector<int> base_filament_map = print_config->filament_map.values;
            if (base_filament_map.size() != derived_maps.size())
                base_filament_map.assign(derived_maps.size(), 1);
            std::vector<int> base_volume_map = print_config->filament_volume_map.values;
            if (base_volume_map.size() != derived_maps.size())
                base_volume_map.assign(derived_maps.size(), (int)nvtStandard);
            m_print->update_filament_maps_to_config(FilamentGroupUtils::update_used_filament_values(base_filament_map, derived_maps, used_filaments),
                                                    FilamentGroupUtils::update_used_filament_values(base_volume_map, grouping_result.get_volume_map(), used_filaments),
                                                    grouping_result.get_nozzle_map());
        }
        std::transform(filament_maps.begin(), filament_maps.end(), filament_maps.begin(), [](int value) { return value - 1; });
 
        if (m_print->is_BBL_printer())
        check_filament_printable_after_group(used_filaments, filament_maps, print_config);
    }
    else {
        // by-object: grouping was decided in Print.cpp; just wrap the (0-based) config map.
        std::transform(filament_maps.begin(), filament_maps.end(), filament_maps.begin(), [](int value) {return value - 1; });
        grouping_result = build_group_result_from_map(*print_config, filament_maps, used_filaments);
    }
 
    // The grouping result comes from the nozzle-centric engine. For single-nozzle-per-extruder printers
    // (incl. H2D) each filament resolves to nozzle_id == extruder_id, so GCode's static hotend/nozzle
    // placeholders are unchanged; H2C/A2L resolve to a nozzle-granular result (dynamic mode
    // resolves per-layer). GCode consumes this via Print::get_layered_nozzle_group_result().
    m_nozzle_group_result = grouping_result;
    // Orca: the ToolOrdering member is stored unconditionally, but the Print-level store is gated
    // behind the not-sequential check hoisted above.
    if (m_print != nullptr && not_sequential)
        m_print->set_nozzle_group_result(std::make_shared<MultiNozzleUtils::LayeredNozzleGroupResult>(m_nozzle_group_result));
 
    auto maps_without_group = filament_maps;
    for (auto& item : maps_without_group)
        item = 0;
 
    // The dynamic branch produced filament_sequences itself (per-layer selector plan); only the static
    // path needs the extruder-map flush reorder here.
    if (!dynamic_reorder) {
        reorder_filaments_for_minimum_flush_volume(
            filament_lists,
            m_print->is_BBL_printer() ? filament_maps : maps_without_group, // non-bbl printers do not support filament group yet
            layer_filaments,
            nozzle_flush_mtx,
            get_custom_seq,
            &filament_sequences
        );
    }
 
    // The three-mode flush-stat caches are now computed from the nozzle-aware grouping result via the
    // nozzle-aware calc_filament_change_info_by_toolorder. Stats are GUI-only (surfaced by
    // get_filament_change_stats for the mode comparison); they never feed g-code, so this block is
    // byte-inert. For single-nozzle-per-extruder printers (H2D/X1/...) nozzle_id == extruder_id, so
    // every cached value equals the extruder-level stats.
    auto curr_flush_info = calc_filament_change_info_by_toolorder(print_config, grouping_result, nozzle_flush_mtx, filament_sequences);
    if (nozzle_nums <= 1)
        m_stats_by_single_extruder = curr_flush_info;
    else {
        m_stats_by_multi_extruder_curr = curr_flush_info;
        if (map_mode == fmmAutoForFlush)
            m_stats_by_multi_extruder_best = curr_flush_info;
    }
 
    // in multi extruder mode, collect data under the other modes (for the GUI mode comparison)
    if (nozzle_nums > 1) {
        // always calculate the info as if a single extruder were used
        {
            std::vector<std::vector<unsigned int>> single_extruder_sequences;
            reorder_filaments_for_minimum_flush_volume(
                filament_lists,
                maps_without_group,
                layer_filaments,
                nozzle_flush_mtx,
                get_custom_seq,
                &single_extruder_sequences
            );
            // One logical nozzle (extruder 0, nozzle 0); every filament resolves to it.
            // diameter/volume_type are unused by the stat calc.
            MultiNozzleUtils::NozzleInfo single_nozzle;
            single_nozzle.volume_type = NozzleVolumeType::nvtStandard;
            single_nozzle.extruder_id = 0;
            single_nozzle.group_id    = 0;
            auto single_result = MultiNozzleUtils::LayeredNozzleGroupResult::create(maps_without_group, {single_nozzle}, used_filaments);
            if (single_result)
                m_stats_by_single_extruder = calc_filament_change_info_by_toolorder(print_config, *single_result, nozzle_flush_mtx, single_extruder_sequences);
        }
        // if not already in best-for-flush mode, also calculate the info under best-for-flush grouping
        if (map_mode != fmmAutoForFlush)
        {
            std::vector<std::vector<unsigned int>> best_sequences;
            if (dynamic_reorder) {
                // When the filament selector is active the "best" plan
                // is the per-combo-range dynamic regroup, computed over a *copy* of the initial nozzle
                // status so it cannot perturb the chosen m_nozzle_status / primary result. NOTE:
                // is_dynamic_group_reorder() implies filament_map_mode == fmmAutoForFlush, contradicting
                // this map_mode != fmmAutoForFlush guard, so this sub-branch is unreachable under the
                // current predicate. It is provably inert.
                auto best_context = build_filament_group_context(m_print, layer_filaments, physical_unprintables, geometric_unprintables, filament_unprintable_volumes, FilamentMapMode::fmmAutoForFlush,
                                                                 m_initial_nozzle_status.get_nozzle_filament_map());
                best_context.speed_info.group_with_time = false;
                MultiNozzleUtils::NozzleStatusRecorder best_nozzle_status = m_initial_nozzle_status;
                auto best_plan = plan_filament_mapping_and_order_by_combo_ranges(m_print, best_context, get_custom_seq, FilamentMapMode::fmmAutoForFlush,
                                                                                 physical_unprintables, geometric_unprintables, filament_unprintable_volumes, &best_nozzle_status);
                std::vector<std::vector<int>> best_nozzle_map_per_layer;
                for (auto& res : best_plan) {
                    best_sequences.emplace_back(cast<unsigned int>(res.fil_order));
                    best_nozzle_map_per_layer.emplace_back(res.fil_nozzle_match);
                }
                auto best_result = MultiNozzleUtils::LayeredNozzleGroupResult::create(best_nozzle_map_per_layer, best_context.nozzle_info.nozzle_list, used_filaments, best_sequences);
                if (best_result)
                    m_stats_by_multi_extruder_best = calc_filament_change_info_by_toolorder(print_config, *best_result, nozzle_flush_mtx, best_sequences);
            }
            else {
                // Best-for-flush grouping (nozzle-aware result). The extruder-level map fed to the flush
                // reorder is derived exactly as before, so best_sequences (and the flush weight) are
                // identical; only flush_filament_change_count is now charged per physical nozzle.
                auto best_group_result = get_recommended_filament_maps(layer_filaments, m_print, fmmAutoForFlush, physical_unprintables, geometric_unprintables, filament_unprintable_volumes);
                std::vector<int> best_maps = best_group_result.get_extruder_map();
                reorder_filaments_for_minimum_flush_volume(
                    filament_lists,
                    best_maps,
                    layer_filaments,
                    nozzle_flush_mtx,
                    get_custom_seq,
                    &best_sequences
                );
                m_stats_by_multi_extruder_best = calc_filament_change_info_by_toolorder(print_config, best_group_result, nozzle_flush_mtx, best_sequences);
            }
        }
    }
 
    for (size_t i = 0; i < filament_sequences.size(); ++i)
        m_layer_tools[i].extruders = std::move(filament_sequences[i]);
}

References Slic3r::cast(), Slic3r::collect_sorted_used_filaments(), Slic3r::Cyclic, EPSILON, Slic3r::expand_mixed_slots_in_unprintables(), Slic3r::fmmAutoForFlush, Slic3r::get_flush_volumes_matrix(), Slic3r::get_other_layers_print_sequence(), Slic3r::has_any_mixed_filament(), m_layer_tools, m_print, m_print_config_ptr, m_print_object_ptr, Slic3r::parse_cyclic_order(), Slic3r::print_sequence(), Slic3r::pvmFast, reorder_extruders_for_minimum_flush_volume(), Slic3r::Type1, Slic3r::ConfigOptionVector< int >::values, and Slic3r::wipe_tower_type().

Referenced by reorder_extruders_for_minimum_flush_volume(), sort_and_build_data(), and sort_and_build_data().

Here is the call graph for this function:

Here is the caller graph for this function:

resolve_mixed_filaments()

void Slic3r::ToolOrdering::resolve_mixed_filaments ( const PrintConfig & config )

private

{
    const auto &is_mixed = config.filament_is_mixed.values;
    const auto &comp_strs = config.filament_mixed_components.values;
    const auto &ratio_strs = config.filament_mixed_sublayer_ratios.values;
 
    // Capture mixed slots that actually appear on layers before they are expanded to
    // physical components. Assigned-but-unused mixed slots never enter layer_tools.
    m_used_mixed_filaments.clear();
    if (has_any_mixed_filament(is_mixed)) {
        std::set<unsigned int> used;
        for (const LayerTools &lt : m_layer_tools)
            for (unsigned int ext : lt.extruders)
                if (ext < is_mixed.size() && is_mixed[ext])
                    used.insert(ext);
        m_used_mixed_filaments.assign(used.begin(), used.end());
    }
 
    if (!has_any_mixed_filament(is_mixed))
        return;
 
    const bool sublayer_enabled = config.enable_mixed_color_sublayer.value;
 
    struct SlotInfo {
        std::vector<unsigned int> components; // 1-based
        std::vector<double>       ratios;
        std::vector<long long>    accum;     // deficit accumulator (integer, unit: 1e-6 mm)
    };
    std::vector<SlotInfo> slots(is_mixed.size());
    for (size_t i = 0; i < is_mixed.size(); ++i) {
        if (!is_mixed[i])
            continue;
        slots[i].components = parse_mixed_components(i < comp_strs.size() ? comp_strs[i] : "");
        if (slots[i].components.size() < 2) {
            slots[i].components.clear();
            continue;
        }
        for (unsigned int cid : slots[i].components) {
            unsigned int idx0 = cid - 1;
            if (idx0 >= is_mixed.size() || (idx0 < is_mixed.size() && is_mixed[idx0])) {
                slots[i].components.clear();
                break;
            }
        }
        if (slots[i].components.empty())
            continue;
        slots[i].ratios = parse_mixed_ratios(
            i < ratio_strs.size() ? ratio_strs[i] : "", slots[i].components.size());
        if (!sublayer_enabled) {
            for (double &r : slots[i].ratios)
                r = snap_to_simple_fraction(r);
            double sum = 0;
            for (double r : slots[i].ratios) sum += r;
            if (sum > 0)
                for (double &r : slots[i].ratios) r /= sum;
        }
        slots[i].accum.assign(slots[i].components.size(), 0LL);
    }
 
    // Parse gradient settings per slot
    const auto &gradient_flags = config.filament_mixed_gradient.values;
    const auto &gradient_range_strs = config.filament_mixed_gradient_range.values;
    const auto &gradient_curve_strs = config.filament_mixed_gradient_curve.values;
    struct GradientInfo {
        double        start = 0.10;
        double        end_val = 0.90;
        GradientCurve curve;  // empty -> use linear (start, end_val); non-empty wins
    };
    std::vector<bool> is_gradient(is_mixed.size(), false);
    std::vector<GradientInfo> gradient_info(is_mixed.size());
    for (size_t i = 0; i < is_mixed.size(); ++i) {
        if (!is_mixed[i] || slots[i].components.size() != 2)
            continue;
        if (i >= gradient_flags.size() || !gradient_flags[i])
            continue;
        is_gradient[i] = true;
        if (i < gradient_range_strs.size() && !gradient_range_strs[i].empty()) {
            CNumericLocalesSetter c_locale_setter;
            float v0 = 0, v1 = 0;
            if (std::sscanf(gradient_range_strs[i].c_str(), "%f,%f", &v0, &v1) == 2 &&
                v0 > 0 && v0 < 1.0 && v1 > 0 && v1 < 1.0) {
                gradient_info[i].start   = v0;
                gradient_info[i].end_val = v1;
            }
        }
        if (i < gradient_curve_strs.size() && !gradient_curve_strs[i].empty())
            gradient_info[i].curve = parse_gradient_curve(gradient_curve_strs[i]);
    }
 
    // Pass 1: identify continuous runs for each gradient slot (Per-Run).
    // A "run" is a maximal sequence of consecutive layers where the slot appears.
    struct GradientRunInfo {
        std::vector<size_t> run_lengths;
        int                 current_run = -1;
        size_t              current_idx = 0;
        bool                prev_appeared = false;
        bool                last_absent_was_relevant = false;
    };
    std::map<unsigned int, GradientRunInfo> gradient_runs;
    for (size_t i = 0; i < is_mixed.size(); ++i)
        if (is_gradient[i]) gradient_runs[static_cast<unsigned int>(i)] = {};
 
    // Build per-slot sets of all layer indices where any slot-owning object has a
    // layer.  Used by gradient run detection (a gap is real only if the slot is
    // absent at a layer belonging to one of its own objects) and by calc_slot_lh
    // to keep prev_relevant_z_for_slot current even when a slot skips many layers.
    std::map<unsigned int, std::set<size_t>> slot_relevant_layers;
    for (auto &[slot_idx, obj_map] : m_mixed_object_layers) {
        for (auto &[obj, _] : obj_map) {
            auto it = m_object_all_layer_indices.find(obj);
            if (it != m_object_all_layer_indices.end())
                slot_relevant_layers[slot_idx].insert(it->second.begin(), it->second.end());
        }
    }
 
    if (!gradient_runs.empty()) {
        for (size_t li = 0; li < m_layer_tools.size(); ++li) {
            if (li == 0) continue;
            const auto &lt = m_layer_tools[li];
            for (auto &[slot, run] : gradient_runs) {
                bool here = std::find(lt.extruders.begin(), lt.extruders.end(), slot) != lt.extruders.end();
                if (here) {
                    bool real_gap = false;
                    if (!run.prev_appeared && !run.run_lengths.empty()) {
                        real_gap = run.last_absent_was_relevant;
                    }
                    if (run.run_lengths.empty() || real_gap)
                        run.run_lengths.push_back(0);
                    run.run_lengths.back()++;
                    run.last_absent_was_relevant = false;
                } else if (!run.run_lengths.empty()) {
                    auto rel_it = slot_relevant_layers.find(slot);
                    if (rel_it != slot_relevant_layers.end() && rel_it->second.count(li))
                        run.last_absent_was_relevant = true;
                }
                run.prev_appeared = here;
            }
        }
        for (auto &[slot, run] : gradient_runs) {
            run.current_run = -1;
            run.current_idx = 0;
            run.prev_appeared = false;
            run.last_absent_was_relevant = false;
        }
    }
 
    // Per-object gradient: pre-compute per-object runs (respecting Z gaps within each object).
    struct PerObjRunState {
        std::vector<size_t> run_start_offsets; // index into layer_indices where each run starts
        std::vector<size_t> run_lengths;
        int                 current_run = -1;
        size_t              current_idx = 0;
    };
 
    // Detect whether a gap between two consecutive gradient-slot appearances is a
    // real run break.  A gap is real only if the object has its own layer inside the
    // gap that does NOT use the gradient slot (i.e. the slot was genuinely absent).
    // Uses lower_bound to skip global indices that don't belong to the object.
    auto has_real_gap = [](size_t prev_idx, size_t cur_idx,
                           const std::set<size_t>& obj_set,
                           const std::set<size_t>& slot_set) -> bool {
        for (auto it = obj_set.lower_bound(prev_idx + 1);
             it != obj_set.end() && *it < cur_idx; ++it) {
            if (!slot_set.count(*it))
                return true;
        }
        return false;
    };
 
    // Segment a sorted list of layer indices into runs, using has_real_gap to decide
    // where to break.  Shared by the per-object and per-volume paths below.
    auto segment_runs = [&](const std::vector<size_t>& layer_indices,
                            const std::set<size_t>& obj_set,
                            const std::set<size_t>& slot_set) -> PerObjRunState {
        PerObjRunState st;
        for (size_t i = 0; i < layer_indices.size(); ++i) {
            bool new_run = (i == 0) ||
                           has_real_gap(layer_indices[i - 1], layer_indices[i], obj_set, slot_set);
            if (new_run) {
                st.run_start_offsets.push_back(i);
                st.run_lengths.push_back(0);
            }
            st.run_lengths.back()++;
        }
        return st;
    };
 
    std::map<unsigned int, std::map<const PrintObject*, PerObjRunState>> per_obj_runs;
    for (auto &[slot, obj_map] : m_mixed_object_layers) {
        if (slot >= is_gradient.size() || !is_gradient[slot])
            continue;
        for (auto &[obj, layer_indices] : obj_map) {
            sort_remove_duplicates(layer_indices);
            // Erase layer 0 — this mutation is also relied upon by the Pass 2 binary_search below.
            if (!layer_indices.empty() && layer_indices.front() == 0)
                layer_indices.erase(layer_indices.begin());
 
            const auto &all_obj_layers = m_object_all_layer_indices[obj];
            std::set<size_t> all_obj_set(all_obj_layers.begin(), all_obj_layers.end());
            std::set<size_t> grad_set(layer_indices.begin(), layer_indices.end());
 
            per_obj_runs[slot][obj] = segment_runs(layer_indices, all_obj_set, grad_set);
        }
    }
 
    // Per-volume gradient: mirror the per-object run-segmentation logic above for
    // m_gradient_volume_layers. When per_part_gradient is off (or no qualifying volume exists),
    // m_gradient_volume_layers is empty and per_vol_runs ends up empty too — so all subsequent
    // checks of `per_vol_runs.find(slot) != end()` will fail and the legacy per-object path
    // remains the only path taken.
    using VolumeKey = LayerTools::MixedSubLayerGroup::VolumeKey;
    std::map<unsigned int, std::map<VolumeKey, PerObjRunState>> per_vol_runs;
    for (auto &[slot, vol_map] : m_gradient_volume_layers) {
        if (slot >= is_gradient.size() || !is_gradient[slot])
            continue;
        for (auto &[vkey, layer_indices] : vol_map) {
            sort_remove_duplicates(layer_indices);
            if (!layer_indices.empty() && layer_indices.front() == 0)
                layer_indices.erase(layer_indices.begin());
 
            const auto &all_obj_layers = m_object_all_layer_indices[vkey.obj];
            std::set<size_t> all_obj_set(all_obj_layers.begin(), all_obj_layers.end());
            std::set<size_t> vol_grad_set(layer_indices.begin(), layer_indices.end());
 
            per_vol_runs[slot][vkey] = segment_runs(layer_indices, all_obj_set, vol_grad_set);
        }
    }
    // Pass 2: resolve per layer
    coordf_t prev_print_z = 0.;
    // Track last print_z per mixed slot so that layer height is computed from the
    // slot's own previous appearance, not from a global Z that may include layers
    // belonging only to other objects with different layer heights.
    std::map<unsigned int, coordf_t> prev_print_z_for_slot;
    // Track the last Z where a slot-owning object had ANY layer (regardless of
    // whether the slot was present). Used to detect genuine gaps: if the slot was
    // absent but its owner objects had layers, prev_relevant_z advances while
    // prev_print_z_for_slot stays stale. Taking the max of both gives correct lh.
    std::map<unsigned int, coordf_t> prev_relevant_z_for_slot;
 
    // Compute the effective layer height for a mixed slot by choosing the best
    // reference Z among: (1) the slot's own last Z, (2) the last Z where the
    // slot's owning object had any layer, (3) the global previous Z as fallback
    // when the slot appears for the first time.
    auto calc_slot_lh = [&](unsigned int ext, coordf_t print_z) -> double {
        auto slot_pz_it = prev_print_z_for_slot.find(ext);
        auto rel_pz_it  = prev_relevant_z_for_slot.find(ext);
        coordf_t base_z = prev_print_z;
        if (slot_pz_it != prev_print_z_for_slot.end()) {
            base_z = slot_pz_it->second;
            if (rel_pz_it != prev_relevant_z_for_slot.end())
                base_z = std::max(base_z, rel_pz_it->second);
        }
        double lh = print_z - base_z;
        return (lh > 0.) ? lh : 0.2;  // 0.2mm safety fallback; should not trigger in normal operation
    };
 
    for (LayerTools &lt : m_layer_tools) {
        size_t layer_idx = static_cast<size_t>(&lt - m_layer_tools.data());
 
        // Update gradient run state (skip first layer to match counting).
        if (layer_idx > 0) {
            for (auto &[slot, run] : gradient_runs) {
                bool here = std::find(lt.extruders.begin(), lt.extruders.end(), slot) != lt.extruders.end();
                if (here) {
                    if (!run.prev_appeared) {
                        if (run.last_absent_was_relevant || run.current_run < 0) {
                            run.current_run++;
                            run.current_idx = 0;
                        }
                    }
                    run.last_absent_was_relevant = false;
                } else {
                    auto rel_it = slot_relevant_layers.find(slot);
                    if (rel_it != slot_relevant_layers.end() && rel_it->second.count(layer_idx))
                        run.last_absent_was_relevant = true;
                }
                run.prev_appeared = here;
            }
        }
 
        std::vector<unsigned int> new_extruders;
        for (unsigned int ext : lt.extruders) {
            if (ext >= slots.size() || slots[ext].components.empty()) {
                new_extruders.push_back(ext);
                continue;
            }
            auto &s = slots[ext];
 
            // Skip sublayer splitting for the first layer to preserve bed adhesion.
            if (sublayer_enabled && layer_idx > 0) {
                double lh = calc_slot_lh(ext, lt.print_z);
                size_t n = s.components.size();
 
                std::vector<double> sub_heights;
                bool gradient_last_no_split = false;
                unsigned int gradient_last_dominant_0b = 0;
                if (is_gradient[ext] && n == 2) {
                    auto gr_it = gradient_runs.find(ext);
                    if (gr_it != gradient_runs.end() && gr_it->second.current_run >= 0 &&
                        static_cast<size_t>(gr_it->second.current_run) < gr_it->second.run_lengths.size()) {
                        auto &run  = gr_it->second;
                        size_t N   = run.run_lengths[run.current_run];
                        size_t idx = run.current_idx++;
                        double t   = (N > 0) ? (2.0 * idx + 1.0) / (2.0 * N) : 0.5;
                        // Custom curve wins over linear range when present; OFF path stays bit-identical.
                        double r1  = gradient_info[ext].curve.empty()
                                     ? (gradient_info[ext].start + (gradient_info[ext].end_val - gradient_info[ext].start) * t)
                                     : sample_gradient_curve(gradient_info[ext].curve, t);
                        double r2  = 1.0 - r1;
                        sub_heights.push_back(r1 * lh);
                        sub_heights.push_back(r2 * lh);
                        // The sublayer split path sorts components by physical ID ascending;
                        // the higher-ID component ends up on top (visible surface). If the
                        // gradient's dominant component has the lower physical ID, splitting
                        // would put the non-dominant color on the visible top surface. In
                        // that case, skip the split and print this final run-layer as pure
                        // dominant color to preserve the gradient appearance.
                        if (idx == N - 1) {
                            // When r1 == r2 (exactly 50/50), component[0] is treated as dominant.
                            size_t dominant = (r1 >= r2) ? 0 : 1;
                            unsigned int dom_0b = s.components[dominant] - 1;
                            unsigned int oth_0b = s.components[1 - dominant] - 1;
                            if (dom_0b < oth_0b) {
                                gradient_last_no_split = true;
                                gradient_last_dominant_0b = dom_0b;
                            }
                        }
                    } else {
                        for (double r : s.ratios)
                            sub_heights.push_back(r * lh);
                    }
                } else {
                    for (double r : s.ratios)
                        sub_heights.push_back(r * lh);
                }
 
                // Per-part gradient: when this slot has any qualifying volume, the global
                // no-split short-circuit must NOT bypass MixedSubLayerGroup creation — each
                // volume needs its own no-split decision in GCode.cpp (a per-volume "last
                // run-layer" can occur on a different layer index than the per-object one). We
                // still keep the per-object short-circuit when per_vol_runs[ext] is empty, which
                // covers the legacy path bit-identically.
                bool per_vol_active_for_slot = per_vol_runs.find(ext) != per_vol_runs.end()
                                                && !per_vol_runs[ext].empty();
 
                if (gradient_last_no_split && !per_vol_active_for_slot) {
                    lt.mixed_filament_resolution[ext] = gradient_last_dominant_0b;
                    new_extruders.push_back(gradient_last_dominant_0b);
                    prev_print_z_for_slot[ext] = lt.print_z;
                    continue;
                }
 
                LayerTools::MixedSubLayerGroup grp;
                grp.mixed_slot_0based = ext;
                grp.layer_height = lh;
                grp.is_gradient = is_gradient[ext];
                for (size_t k = 0; k < s.components.size(); ++k) {
                    unsigned int comp_0based = s.components[k] - 1;
                    grp.components_0based.push_back(comp_0based);
                }
                grp.sub_heights = sub_heights;
 
                // Write gradient metadata (run-aware). Both per_object_gradient and
                // per_volume_gradient are populated independently from their own run-state
                // machines; the GCode emitter chooses per-region:
                //  - tagged region (gradient_volume_id valid)  -> per_volume_gradient[{obj, vol}]
                //  - untagged region (modifier / painted / etc.) -> per_object_gradient[obj]
                // Populating both keeps the per-object run state correct even when per-volume
                // takes over for the same (slot, obj), and lets untagged geometry (which is
                // never split per-volume) keep its per-object gradient ratios.
                if (grp.is_gradient) {
                    auto vol_runs_slot_it = per_vol_runs.find(ext);
                    if (vol_runs_slot_it != per_vol_runs.end()) {
                        auto vol_slot_it = m_gradient_volume_layers.find(ext);
                        for (auto &[vkey, st] : vol_runs_slot_it->second) {
                            auto &layer_indices = vol_slot_it->second[vkey];
                            if (!std::binary_search(layer_indices.begin(), layer_indices.end(), layer_idx))
                                continue;
                            if (st.current_run < 0 ||
                                st.current_idx >= st.run_lengths[st.current_run]) {
                                st.current_run++;
                                st.current_idx = 0;
                            }
                            size_t run_N   = st.run_lengths[st.current_run];
                            size_t run_idx = st.current_idx++;
                            grp.per_volume_gradient[vkey] = {
                                run_N,
                                run_idx,
                                gradient_info[ext].start,
                                gradient_info[ext].end_val,
                                gradient_info[ext].curve,
                            };
                        }
                    }
 
                    auto runs_slot_it = per_obj_runs.find(ext);
                    if (runs_slot_it != per_obj_runs.end()) {
                        auto slot_it = m_mixed_object_layers.find(ext);
                        for (auto &[obj, st] : runs_slot_it->second) {
                            auto &layer_indices = slot_it->second[obj];
                            if (!std::binary_search(layer_indices.begin(), layer_indices.end(), layer_idx))
                                continue;
                            if (st.current_run < 0 ||
                                st.current_idx >= st.run_lengths[st.current_run]) {
                                st.current_run++;
                                st.current_idx = 0;
                            }
                            size_t run_N  = st.run_lengths[st.current_run];
                            size_t run_idx = st.current_idx++;
                            grp.per_object_gradient[obj] = {
                                run_N,
                                run_idx,
                                gradient_info[ext].start,
                                gradient_info[ext].end_val,
                                gradient_info[ext].curve,
                            };
                        }
                    }
                }
 
                if (grp.components_0based.size() > 1) {
                    unsigned int first_comp_0based = s.components[0] - 1;
                    std::vector<size_t> idx(grp.components_0based.size());
                    std::iota(idx.begin(), idx.end(), 0);
                    std::sort(idx.begin(), idx.end(), [&](size_t a, size_t b) {
                        return grp.components_0based[a] < grp.components_0based[b];
                    });
                    std::vector<unsigned int> sorted_comps;
                    std::vector<double> sorted_heights;
                    for (size_t i : idx) {
                        sorted_comps.push_back(grp.components_0based[i]);
                        sorted_heights.push_back(grp.sub_heights[i]);
                    }
                    grp.components_0based = std::move(sorted_comps);
                    grp.sub_heights = std::move(sorted_heights);
                    if (grp.is_gradient) {
                        for (size_t i = 0; i < grp.components_0based.size(); ++i) {
                            if (grp.components_0based[i] == first_comp_0based) {
                                grp.gradient_first_sorted_idx = static_cast<int>(i);
                                break;
                            }
                        }
                    }
                }
 
                for (unsigned int comp : grp.components_0based)
                    new_extruders.push_back(comp);
                lt.mixed_sub_layer_groups.push_back(std::move(grp));
                prev_print_z_for_slot[ext] = lt.print_z;
            } else {
                // Deficit Round-Robin: pick one component per layer.
                // Weight by layer height so volume ratios stay accurate
                // even with adaptive layer heights.
                double lh = calc_slot_lh(ext, lt.print_z);
                long long lh_i = std::llround(lh * 1e6);
 
                // For 2-component gradient on the first layer, use the gradient's
                // starting ratio instead of the configured mixing ratio so the
                // selected filament matches the gradient's "from" end.
                // Only affects the first layer; when sublayer splitting is enabled
                // (required for gradient), layers 1+ take the sublayer path and
                // do not touch the DRR accumulator.
                if (layer_idx == 0 && is_gradient[ext] && s.components.size() == 2) {
                    double r0 = gradient_info[ext].start;
                    s.accum[0] += std::llround(r0 * lh_i);
                    s.accum[1] += std::llround((1.0 - r0) * lh_i);
                } else {
                    for (size_t k = 0; k < s.ratios.size(); ++k)
                        s.accum[k] += std::llround(s.ratios[k] * lh_i);
                }
                size_t sel = 0;
                for (size_t k = 1; k < s.accum.size(); ++k)
                    if (s.accum[k] > s.accum[sel])
                        sel = k;
                s.accum[sel] -= lh_i;
                unsigned int resolved = s.components[sel] - 1;
                lt.mixed_filament_resolution[ext] = resolved;
                new_extruders.push_back(resolved);
                prev_print_z_for_slot[ext] = lt.print_z;
            }
        }
        lt.extruders = new_extruders;
        sort_remove_duplicates(lt.extruders);
 
        // Update prev_relevant_z: for each slot that has relevant-layer tracking,
        // advance if the current layer belongs to a slot-owning object.
        for (auto &[slot, rel_set] : slot_relevant_layers) {
            if (rel_set.count(layer_idx))
                prev_relevant_z_for_slot[slot] = lt.print_z;
        }
 
        prev_print_z = lt.print_z;
    }
}

References _, Slic3r::LayerTools::MixedSubLayerGroup::components_0based, Slic3r::LayerTools::MixedSubLayerGroup::gradient_first_sorted_idx, Slic3r::has_any_mixed_filament(), Slic3r::LayerTools::MixedSubLayerGroup::is_gradient, Slic3r::LayerTools::MixedSubLayerGroup::layer_height, m_gradient_volume_layers, m_layer_tools, m_mixed_object_layers, m_object_all_layer_indices, m_used_mixed_filaments, Slic3r::LayerTools::MixedSubLayerGroup::mixed_slot_0based, Slic3r::parse_gradient_curve(), Slic3r::parse_mixed_components(), Slic3r::parse_mixed_ratios(), Slic3r::LayerTools::MixedSubLayerGroup::per_object_gradient, Slic3r::LayerTools::MixedSubLayerGroup::per_volume_gradient, resolve_mixed_filaments(), Slic3r::sample_gradient_curve(), Slic3r::snap_to_simple_fraction(), Slic3r::sort_remove_duplicates(), and Slic3r::LayerTools::MixedSubLayerGroup::sub_heights.

Referenced by resolve_mixed_filaments(), sort_and_build_data(), and sort_and_build_data().

Here is the call graph for this function:

Here is the caller graph for this function:

set_nozzle_status()

void Slic3r::ToolOrdering::set_nozzle_status ( const MultiNozzleUtils::NozzleStatusRecorder & status )

inline

{ m_initial_nozzle_status = status; m_nozzle_status = status; }

References m_initial_nozzle_status, and m_nozzle_status.

sort_and_build_data() [1/2]

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

{
    // if first extruder is -1, we can decide the first layer tool order before doing reorder function
    // so we shouldn't reorder first layer in reorder function
    bool reorder_first_layer = (first_extruder != (unsigned int)(-1));
    this->resolve_mixed_filaments(print.config());
    reorder_extruders_for_minimum_flush_volume(reorder_first_layer);
    this->enforce_mixed_component_order();
    m_sorted = true;
 
    double max_layer_height = 0.;
    double object_bottom_z = 0.;
    for (const auto& object : print.objects()) {
        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);
    }
 
    max_layer_height = calc_max_layer_height(print.config(), max_layer_height);
 
    this->fill_wipe_tower_partitions(print.config(), object_bottom_z, max_layer_height);
    if (this->insert_wipe_tower_extruder()) {
        reorder_extruders_for_minimum_flush_volume(reorder_first_layer);
        // Orca reorders a second time here (BBS has no such path); re-enforce so the
        // mixed sub-layer component order survives the extra pass.
        this->enforce_mixed_component_order();
        this->fill_wipe_tower_partitions(print.config(), object_bottom_z, max_layer_height);
    }
 
    this->collect_extruder_statistics(prime_multi_material);
}

References Slic3r::calc_max_layer_height(), collect_extruder_statistics(), Slic3r::Print::config(), enforce_mixed_component_order(), fill_wipe_tower_partitions(), first_extruder(), insert_wipe_tower_extruder(), m_sorted, Slic3r::Print::objects(), reorder_extruders_for_minimum_flush_volume(), and resolve_mixed_filaments().

Here is the call graph for this function:

sort_and_build_data() [2/2]

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

{
    // if first extruder is -1, we can decide the first layer tool order before doing reorder function
    // so we shouldn't reorder first layer in reorder function
    bool reorder_first_layer = (first_extruder != (unsigned int)(-1));
    this->resolve_mixed_filaments(object.print()->config());
    reorder_extruders_for_minimum_flush_volume(reorder_first_layer);
    this->enforce_mixed_component_order();
    m_sorted = true;
 
    double max_layer_height = calc_max_layer_height(object.print()->config(), object.config().layer_height);
 
    this->fill_wipe_tower_partitions(object.print()->config(), object.layers().front()->print_z - object.layers().front()->height, max_layer_height);
    if (this->insert_wipe_tower_extruder()) {
        reorder_extruders_for_minimum_flush_volume(reorder_first_layer);
        // Orca reorders a second time here (BBS has no such path); re-enforce so the
        // mixed sub-layer component order survives the extra pass.
        this->enforce_mixed_component_order();
        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);
}

References Slic3r::calc_max_layer_height(), collect_extruder_statistics(), enforce_mixed_component_order(), fill_wipe_tower_partitions(), first_extruder(), front(), insert_wipe_tower_extruder(), Slic3r::layer_height(), m_sorted, reorder_extruders_for_minimum_flush_volume(), and resolve_mixed_filaments().

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

Here is the call graph for this function:

Here is the caller graph for this function:

tools_for_layer() [1/2]

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

inline

{ 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, m_layer_tools, and tools_for_layer().

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

Here is the call graph for this function:

Here is the caller graph for this function:

used_mixed_filaments()

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

inline

{ return m_used_mixed_filaments; }

References m_used_mixed_filaments.

Member Data Documentation

m_all_printing_extruders

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

private

Referenced by all_extruders(), collect_extruder_statistics(), and has_non_support_filament().

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_gradient_volume_layers

std::map<unsigned int, std::map<LayerTools::MixedSubLayerGroup::VolumeKey, std::vector<size_t> > > Slic3r::ToolOrdering::m_gradient_volume_layers

private

Referenced by collect_extruders(), and resolve_mixed_filaments().

m_initial_nozzle_status

MultiNozzleUtils::NozzleStatusRecorder Slic3r::ToolOrdering::m_initial_nozzle_status

private

Referenced by set_nozzle_status().

m_last_layer_per_extruder

std::map<unsigned int, coordf_t> Slic3r::ToolOrdering::m_last_layer_per_extruder

private

Referenced by collect_extruder_statistics(), and is_last_extrusion_layer().

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(), cal_max_additional_fan(), cal_most_used_extruder(), cal_non_support_filaments(), clear(), collect_extruder_statistics(), collect_extruders(), empty(), end(), enforce_mixed_component_order(), fill_wipe_tower_partitions(), front(), handle_dontcare_extruder(), handle_dontcare_extruder(), has_wipe_tower(), initialize_layers(), insert_wipe_tower_extruder(), layer_tools(), mark_skirt_layers(), reorder_extruders_for_minimum_flush_volume(), resolve_mixed_filaments(), and tools_for_layer().

m_mixed_object_layers

std::map<unsigned int, std::map<const PrintObject*, std::vector<size_t> > > Slic3r::ToolOrdering::m_mixed_object_layers

private

Referenced by collect_extruders(), and resolve_mixed_filaments().

m_nozzle_group_result

MultiNozzleUtils::LayeredNozzleGroupResult Slic3r::ToolOrdering::m_nozzle_group_result

private

Referenced by cal_non_support_filaments(), and get_layered_nozzle_group_result().

m_nozzle_status

MultiNozzleUtils::NozzleStatusRecorder Slic3r::ToolOrdering::m_nozzle_status

private

Referenced by get_nozzle_status(), and set_nozzle_status().

m_object_all_layer_indices

std::map<const PrintObject*, std::vector<size_t> > Slic3r::ToolOrdering::m_object_all_layer_indices

private

Referenced by collect_extruders(), and resolve_mixed_filaments().

m_print

Print* Slic3r::ToolOrdering::m_print

private

Referenced by ToolOrdering(), ToolOrdering(), and reorder_extruders_for_minimum_flush_volume().

m_print_config_ptr

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

private

Referenced by ToolOrdering(), ToolOrdering(), collect_extruders(), handle_dontcare_extruder(), handle_dontcare_extruder(), insert_wipe_tower_extruder(), and reorder_extruders_for_minimum_flush_volume().

m_print_full_config

const DynamicPrintConfig* Slic3r::ToolOrdering::m_print_full_config = nullptr

private

Referenced by ToolOrdering(), ToolOrdering(), generate_first_layer_tool_order(), generate_first_layer_tool_order(), and handle_dontcare_extruder().

m_print_object_ptr

const PrintObject* Slic3r::ToolOrdering::m_print_object_ptr = nullptr

private

Referenced by ToolOrdering(), handle_dontcare_extruder(), handle_dontcare_extruder(), and reorder_extruders_for_minimum_flush_volume().

m_sorted

bool Slic3r::ToolOrdering::m_sorted = false

private

Referenced by sort_and_build_data(), and sort_and_build_data().

m_stats_by_multi_extruder_best

FilamentChangeStats Slic3r::ToolOrdering::m_stats_by_multi_extruder_best

private

Referenced by clear(), and get_filament_change_stats().

m_stats_by_multi_extruder_curr

FilamentChangeStats Slic3r::ToolOrdering::m_stats_by_multi_extruder_curr

private

Referenced by clear(), and get_filament_change_stats().

m_stats_by_single_extruder

FilamentChangeStats Slic3r::ToolOrdering::m_stats_by_single_extruder

private

Referenced by clear(), and get_filament_change_stats().

m_used_mixed_filaments

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

private

Referenced by resolve_mixed_filaments(), and used_mixed_filaments().

most_used_extruder

int Slic3r::ToolOrdering::most_used_extruder

private

Referenced by cal_most_used_extruder(), and get_most_used_extruder().

---

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