Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult Class Reference

Layer-aware nozzle-grouping result. Used by the back-end slicing code; supports per-layer nozzle mapping. More...

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

Inheritance diagram for Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult:

Collaboration diagram for Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult:

Public Member Functions
	LayeredNozzleGroupResult (bool support_dynamic_map=false)
bool	are_filaments_same_extruder (int filament_id1, int filament_id2, int layer_id=-1) const
bool	are_filaments_same_nozzle (int filament_id1, int filament_id2, int layer_id=-1) const
int	get_extruder_count () const override
std::vector< NozzleInfo >	get_used_nozzles_in_extruder (int target_extruder_id=-1) const override
std::vector< NozzleInfo >	get_used_nozzles_in_extruder (int target_extruder_id, int layer_id) const
std::vector< int >	get_used_extruders () const override
std::vector< int >	get_used_extruders (int layer_id) const
std::vector< int >	get_extruder_map (bool zero_based=true, int layer_id=-1) const
std::vector< int >	get_nozzle_map (int layer_id=-1) const
std::vector< int >	get_volume_map (int layer_id=-1) const
std::vector< unsigned int >	get_used_filaments () const override
std::vector< unsigned int >	get_used_filaments (int layer_id) const
std::optional< NozzleInfo >	get_nozzle_for_filament (int filament_id, int layer_id=-1) const
std::vector< NozzleInfo >	get_nozzles_for_filament (int filament_id) const override
std::optional< NozzleInfo >	get_nozzle_from_id (int nozzle_id) const override
std::optional< NozzleInfo >	get_first_nozzle_for_filament (int filament_id) const override
int	get_extruder_id (int filament_id, int layer_id=-1) const
int	get_nozzle_id (int filament_id, int layer_id=-1) const
size_t	get_layer_count () const
const std::vector< int > &	get_layer_filament_nozzle_map (int layer_id) const
const std::vector< std::vector< int > > &	get_layer_filament_nozzle_maps () const
const std::vector< std::vector< unsigned int > > &	get_layer_filament_sequences () const
int	estimate_seq_flush_weight (const std::vector< std::vector< std::vector< float > > > &flush_matrix, const std::vector< int > &filament_change_seq) const
bool	is_support_dynamic_nozzle_map () const

Static Public Member Functions
static std::optional< LayeredNozzleGroupResult >	create (const std::vector< int > &filament_nozzle_map, const std::vector< NozzleInfo > &nozzle_list, const std::vector< unsigned int > &used_filaments)
static std::optional< LayeredNozzleGroupResult >	create (const std::vector< std::vector< int > > &layer_filament_nozzle_maps, const std::vector< NozzleInfo > &nozzle_list, const std::vector< unsigned int > &used_filaments, const std::vector< std::vector< unsigned int > > &layer_filament_sequences)
static std::optional< LayeredNozzleGroupResult >	create (const std::vector< unsigned int > &used_filaments, const std::vector< int > &filament_map, const std::vector< int > &filament_volume_map, const std::vector< int > &filament_nozzle_map, const std::vector< std::map< NozzleVolumeType, int > > &nozzle_count, float diameter)

Protected Attributes
bool	support_dynamic_nozzle_map {false}

Private Attributes
std::vector< std::vector< int > >	_layer_filament_nozzle_maps
std::vector< std::vector< unsigned int > >	_layer_filament_sequences
std::vector< int >	_default_filament_nozzle_map
std::vector< unsigned int >	_used_filaments
std::vector< NozzleInfo >	_nozzle_list

Detailed Description

Layer-aware nozzle-grouping result. Used by the back-end slicing code; supports per-layer nozzle mapping.

Constructor & Destructor Documentation

LayeredNozzleGroupResult()

Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::LayeredNozzleGroupResult ( bool support_dynamic_map = false )

inline

: NozzleGroupResultBase(support_dynamic_map) {}

References Slic3r::MultiNozzleUtils::NozzleGroupResultBase::NozzleGroupResultBase().

Referenced by create(), and create().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

are_filaments_same_extruder()

bool Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::are_filaments_same_extruder	(	int	filament_id1,
		int	filament_id2,
		int	layer_id = -1 ) const

{
    std::optional<NozzleInfo> nozzle_info1 = get_nozzle_for_filament(filament_id1, layer_id);
    std::optional<NozzleInfo> nozzle_info2 = get_nozzle_for_filament(filament_id2, layer_id);
 
    if (!nozzle_info1 || !nozzle_info2) return false;
 
    return nozzle_info1->extruder_id == nozzle_info2->extruder_id;
}

References get_nozzle_for_filament().

Here is the call graph for this function:

are_filaments_same_nozzle()

bool Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::are_filaments_same_nozzle	(	int	filament_id1,
		int	filament_id2,
		int	layer_id = -1 ) const

{
    std::optional<NozzleInfo> nozzle_info1 = get_nozzle_for_filament(filament_id1, layer_id);
    std::optional<NozzleInfo> nozzle_info2 = get_nozzle_for_filament(filament_id2, layer_id);
    if (!nozzle_info1 || !nozzle_info2) return false;
 
    return nozzle_info1->group_id == nozzle_info2->group_id;
}

References get_nozzle_for_filament().

Here is the call graph for this function:

create() [1/3]

std::optional< LayeredNozzleGroupResult > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::create ( const std::vector< int > & filament_nozzle_map, const std::vector< NozzleInfo > & nozzle_list, const std::vector< unsigned int > & used_filaments )

static

{
    if (filament_nozzle_map.empty() || nozzle_list.empty()) {
        return std::nullopt;
    }
 
    LayeredNozzleGroupResult result(false);
    result._default_filament_nozzle_map = filament_nozzle_map;
    result._nozzle_list = nozzle_list;
    result._used_filaments = used_filaments;
 
    return result;
}

References LayeredNozzleGroupResult(), _default_filament_nozzle_map, _nozzle_list, _used_filaments, and Slic3r::filament_nozzle_map().

Referenced by Slic3r::ToolOrdering::build_sequential_group_result(), create(), Slic3r::GCodeProcessor::ensure_nozzle_group_result(), Slic3r::full_evaluate(), and Slic3r::refine_groups_by_Nozzle_State().

Here is the call graph for this function:

Here is the caller graph for this function:

create() [2/3]

std::optional< LayeredNozzleGroupResult > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::create ( const std::vector< std::vector< int > > & layer_filament_nozzle_maps, const std::vector< NozzleInfo > & nozzle_list, const std::vector< unsigned int > & used_filaments, const std::vector< std::vector< unsigned int > > & layer_filament_sequences )

static

{
    if (layer_filament_nozzle_maps.empty() || nozzle_list.empty()) {
        return std::nullopt;
    }
 
    bool support_dynamic_nozzle_map = has_filament_mapped_to_multiple_nozzles(layer_filament_nozzle_maps, used_filaments);
    LayeredNozzleGroupResult result(support_dynamic_nozzle_map);
    result._layer_filament_nozzle_maps = layer_filament_nozzle_maps;
    result._layer_filament_sequences   = layer_filament_sequences;
    result._nozzle_list                = nozzle_list;
    result._used_filaments             = used_filaments;
 
    if (!layer_filament_nozzle_maps.empty()) {
        result._default_filament_nozzle_map = layer_filament_nozzle_maps[0];
    }
 
    return result;
}

References LayeredNozzleGroupResult(), _default_filament_nozzle_map, _layer_filament_nozzle_maps, _layer_filament_sequences, _nozzle_list, _used_filaments, Slic3r::MultiNozzleUtils::has_filament_mapped_to_multiple_nozzles(), and Slic3r::MultiNozzleUtils::NozzleGroupResultBase::support_dynamic_nozzle_map.

Here is the call graph for this function:

create() [3/3]

std::optional< LayeredNozzleGroupResult > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::create ( const std::vector< unsigned int > & used_filaments, const std::vector< int > & filament_map, const std::vector< int > & filament_volume_map, const std::vector< int > & filament_nozzle_map, const std::vector< std::map< NozzleVolumeType, int > > & nozzle_count, float diameter )

static

{
    std::vector<NozzleGroupInfo> nozzle_groups;
    for (size_t extruder_id = 0; extruder_id < nozzle_count.size(); ++extruder_id) {
        for (auto elem : nozzle_count[extruder_id]) {
            NozzleGroupInfo group_info;
            group_info.diameter     = format_diameter_to_str(diameter);
            group_info.volume_type  = elem.first;
            group_info.nozzle_count = elem.second;
            group_info.extruder_id  = static_cast<int>(extruder_id);
            nozzle_groups.emplace_back(group_info);
        }
    }
 
    auto               nozzle_list = build_nozzle_list(nozzle_groups);
    std::vector<bool>  used_nozzle(nozzle_list.size(), false);
    std::map<int, int> input_nozzle_id_to_output;
    std::vector<int>   output_nozzle_map(filament_nozzle_map.size(), 0);
 
    for (auto filament_idx : used_filaments) {
        NozzleVolumeType req_type         = NozzleVolumeType(filament_volume_map[filament_idx]);
        int              req_extruder     = filament_map[filament_idx];
        int              input_nozzle_idx = filament_nozzle_map[filament_idx];
 
        if (input_nozzle_id_to_output.find(input_nozzle_idx) != input_nozzle_id_to_output.end()) {
            output_nozzle_map[filament_idx] = input_nozzle_id_to_output[input_nozzle_idx];
            continue;
        }
 
        int output_nozzle_idx = -1;
        for (size_t nozzle_idx = 0; nozzle_idx < nozzle_list.size(); ++nozzle_idx) {
            if (used_nozzle[nozzle_idx]) continue;
 
            auto &nozzle_info = nozzle_list[nozzle_idx];
            if (!(nozzle_info.extruder_id == req_extruder && nozzle_info.volume_type == req_type)) continue;
 
            output_nozzle_idx                           = static_cast<int>(nozzle_idx);
            input_nozzle_id_to_output[input_nozzle_idx] = output_nozzle_idx;
            used_nozzle[nozzle_idx]                     = true;
            break;
        }
 
        if (output_nozzle_idx == -1) { return std::nullopt; }
        output_nozzle_map[filament_idx] = output_nozzle_idx;
    }
 
    return create(output_nozzle_map, nozzle_list, used_filaments);
}

References Slic3r::MultiNozzleUtils::build_nozzle_list(), create(), Slic3r::MultiNozzleUtils::NozzleGroupInfo::diameter, Slic3r::MultiNozzleUtils::NozzleGroupInfo::extruder_id, Slic3r::filament_map(), Slic3r::filament_nozzle_map(), Slic3r::format_diameter_to_str(), Slic3r::MultiNozzleUtils::NozzleGroupInfo::nozzle_count, and Slic3r::MultiNozzleUtils::NozzleGroupInfo::volume_type.

Here is the call graph for this function:

estimate_seq_flush_weight()

int Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::estimate_seq_flush_weight	(	const std::vector< std::vector< std::vector< float > > > &	flush_matrix,
		const std::vector< int > &	filament_change_seq ) const

{
    auto get_weight_from_volume = [](float volume){
        return static_cast<int>(volume * 1.26 * 0.01);
    };
 
    float total_flush_volume = 0;
    NozzleStatusRecorder recorder;
    for(auto filament: filament_change_seq){
        auto nozzle = get_nozzle_for_filament(filament, -1);
        if(!nozzle)
            continue;
 
        int extruder_id = nozzle->extruder_id;
        int nozzle_id = nozzle->group_id;
        int last_filament = recorder.get_filament_in_nozzle(nozzle_id);
 
        if(last_filament!= -1 && last_filament != filament){
            // bounds check to avoid out-of-range access
            if (extruder_id >= 0 && extruder_id < static_cast<int>(flush_matrix.size()) &&
                last_filament >= 0 && last_filament < static_cast<int>(flush_matrix[extruder_id].size()) &&
                filament >= 0 && filament < static_cast<int>(flush_matrix[extruder_id][last_filament].size())) {
                float flush_volume = flush_matrix[extruder_id][last_filament][filament];
                total_flush_volume += flush_volume;
            }
        }
        recorder.set_nozzle_status(nozzle_id, filament);
    }
 
    return get_weight_from_volume(total_flush_volume);
}

References Slic3r::MultiNozzleUtils::NozzleStatusRecorder::get_filament_in_nozzle(), get_nozzle_for_filament(), and Slic3r::MultiNozzleUtils::NozzleStatusRecorder::set_nozzle_status().

Here is the call graph for this function:

get_extruder_count()

int Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_extruder_count ( ) const

overridevirtual

Implements Slic3r::MultiNozzleUtils::NozzleGroupResultBase.

{
    std::set<int> extruder_ids;
    for (const auto &nozzle : _nozzle_list) { extruder_ids.insert(nozzle.extruder_id); }
    return static_cast<int>(extruder_ids.size());
}

References _nozzle_list.

get_extruder_id()

int Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_extruder_id	(	int	filament_id,
		int	layer_id = -1 ) const

{
    auto nozzle_info = get_nozzle_for_filament(filament_id, layer_id);
    return nozzle_info ? nozzle_info->extruder_id : -1;
}

References get_nozzle_for_filament().

Here is the call graph for this function:

get_extruder_map()

std::vector< int > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_extruder_map	(	bool	zero_based = true,
		int	layer_id = -1 ) const

{
    const std::vector<int> &filament_nozzle_map = get_layer_filament_nozzle_map(layer_id);
    std::vector<int>        extruder_map(filament_nozzle_map.size());
    for (size_t idx = 0; idx < filament_nozzle_map.size(); ++idx) {
        int nozzle_id = filament_nozzle_map[idx];
        if (nozzle_id >= 0 && nozzle_id < static_cast<int>(_nozzle_list.size())) {
            extruder_map[idx] = _nozzle_list[nozzle_id].extruder_id;
        } else {
            extruder_map[idx] = -1;
        }
    }
 
    if (zero_based) return extruder_map;
 
    auto new_filament_map = extruder_map;
    std::transform(new_filament_map.begin(), new_filament_map.end(), new_filament_map.begin(), [](int val) { return val + 1; });
    return new_filament_map;
}

References _nozzle_list, Slic3r::filament_nozzle_map(), and get_layer_filament_nozzle_map().

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_first_nozzle_for_filament()

std::optional< NozzleInfo > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_first_nozzle_for_filament ( int filament_id ) const

overridevirtual

Implements Slic3r::MultiNozzleUtils::NozzleGroupResultBase.

{
    if (filament_id < 0) return std::nullopt;
 
    if (!support_dynamic_nozzle_map) {
        if (filament_id >= static_cast<int>(_default_filament_nozzle_map.size())) return std::nullopt;
        return get_nozzle_from_id(_default_filament_nozzle_map[filament_id]);
    }
 
    for (size_t layer = 0; layer < _layer_filament_nozzle_maps.size(); ++layer) {
        auto layer_used_filaments = get_used_filaments(layer);
        if (std::find(layer_used_filaments.begin(), layer_used_filaments.end(), static_cast<unsigned int>(filament_id)) == layer_used_filaments.end()){
            continue;
        }
        const auto &map = _layer_filament_nozzle_maps[layer];
        if (filament_id >= 0 && filament_id < static_cast<int>(map.size())) {
            int nozzle_id = map[filament_id];
            auto nozzle = get_nozzle_from_id(nozzle_id);
            if (nozzle) return nozzle;
        }
    }
 
    return std::nullopt;
}

References _default_filament_nozzle_map, _layer_filament_nozzle_maps, get_nozzle_from_id(), get_used_filaments(), and Slic3r::MultiNozzleUtils::NozzleGroupResultBase::support_dynamic_nozzle_map.

Here is the call graph for this function:

get_layer_count()

size_t Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_layer_count ( ) const

inline

{ return _layer_filament_nozzle_maps.size(); }

References _layer_filament_nozzle_maps.

get_layer_filament_nozzle_map()

const std::vector< int > & Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_layer_filament_nozzle_map

(

int

layer_id

)

const

{
    if (layer_id >= 0 && layer_id < static_cast<int>(_layer_filament_nozzle_maps.size())) { return _layer_filament_nozzle_maps[layer_id]; }
    return _default_filament_nozzle_map;
}

References _default_filament_nozzle_map, and _layer_filament_nozzle_maps.

Referenced by get_extruder_map(), get_nozzle_for_filament(), get_nozzle_map(), get_volume_map(), and Slic3r::refine_groups_by_Nozzle_State().

Here is the caller graph for this function:

get_layer_filament_nozzle_maps()

const std::vector< std::vector< int > > & Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_layer_filament_nozzle_maps ( ) const

inline

{ return _layer_filament_nozzle_maps; }

References _layer_filament_nozzle_maps.

get_layer_filament_sequences()

const std::vector< std::vector< unsigned int > > & Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_layer_filament_sequences ( ) const

inline

{ return _layer_filament_sequences; }

References _layer_filament_sequences.

Referenced by Slic3r::FilamentGroupUtils::get_estimate_extruder_filament_change_count().

Here is the caller graph for this function:

get_nozzle_for_filament()

std::optional< NozzleInfo > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_nozzle_for_filament	(	int	filament_id,
		int	layer_id = -1 ) const

{
    const std::vector<int> &filament_nozzle_map = get_layer_filament_nozzle_map(layer_id);
 
    if (filament_id < 0 || filament_id >= static_cast<int>(filament_nozzle_map.size())) { return std::nullopt; }
 
    int nozzle_id = filament_nozzle_map[filament_id];
    return get_nozzle_from_id(nozzle_id);
}

References Slic3r::filament_nozzle_map(), get_layer_filament_nozzle_map(), and get_nozzle_from_id().

Referenced by Slic3r::Print::_make_wipe_tower(), are_filaments_same_extruder(), are_filaments_same_nozzle(), Slic3r::calc_filament_change_info_by_toolorder(), Slic3r::Print::collect_filament_variant_uses(), estimate_seq_flush_weight(), Slic3r::Print::get_config_index(), Slic3r::Print::get_config_index(), get_extruder_id(), get_nozzle_id(), get_used_extruders(), get_used_nozzles_in_extruder(), and Slic3r::reorder_filaments_for_multi_nozzle_extruder().

Here is the call graph for this function:

Here is the caller graph for this function:

get_nozzle_from_id()

std::optional< NozzleInfo > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_nozzle_from_id ( int nozzle_id ) const

overridevirtual

Implements Slic3r::MultiNozzleUtils::NozzleGroupResultBase.

{
    if (nozzle_id < 0 || nozzle_id >= static_cast<int>(_nozzle_list.size())) { return std::nullopt; }
    return _nozzle_list[nozzle_id];
}

References _nozzle_list.

Referenced by get_first_nozzle_for_filament(), and get_nozzle_for_filament().

Here is the caller graph for this function:

get_nozzle_id()

int Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_nozzle_id	(	int	filament_id,
		int	layer_id = -1 ) const

{
    auto nozzle_info = get_nozzle_for_filament(filament_id, layer_id);
    return nozzle_info ? nozzle_info->group_id : -1;
}

References get_nozzle_for_filament().

Here is the call graph for this function:

get_nozzle_map()

std::vector< int > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_nozzle_map

(

int

layer_id = -1

)

const

{
    const std::vector<int> &filament_nozzle_map = get_layer_filament_nozzle_map(layer_id);
    std::vector<int>        nozzle_map(filament_nozzle_map.size());
    for (size_t idx = 0; idx < filament_nozzle_map.size(); ++idx) {
        int nozzle_id = filament_nozzle_map[idx];
        if (nozzle_id >= 0 && nozzle_id < static_cast<int>(_nozzle_list.size())) {
            nozzle_map[idx] = _nozzle_list[nozzle_id].group_id;
        } else {
            nozzle_map[idx] = -1;
        }
    }
    return nozzle_map;
}

References _nozzle_list, Slic3r::filament_nozzle_map(), and get_layer_filament_nozzle_map().

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_nozzles_for_filament()

std::vector< NozzleInfo > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_nozzles_for_filament ( int filament_id ) const

overridevirtual

Implements Slic3r::MultiNozzleUtils::NozzleGroupResultBase.

{
    std::set<int> nozzle_ids;
 
    if (!support_dynamic_nozzle_map) {
        if (filament_id >= 0 && filament_id < static_cast<int>(_default_filament_nozzle_map.size())) {
            nozzle_ids.insert(_default_filament_nozzle_map[filament_id]);
        }
    } else {
        int start_layer = 0;
        int end_layer   = static_cast<int>(_layer_filament_nozzle_maps.size());
 
        for (int i = start_layer; i < end_layer; ++i) {
            const auto &map = _layer_filament_nozzle_maps[i];
            if (filament_id >= 0 && filament_id < static_cast<int>(map.size())) {
                nozzle_ids.insert(map[filament_id]);
            }
        }
    }
 
    std::vector<NozzleInfo> result;
    for (int id : nozzle_ids) {
        if (id >= 0 && id < static_cast<int>(_nozzle_list.size())) { result.push_back(_nozzle_list[id]); }
    }
    return result;
}

References _default_filament_nozzle_map, _layer_filament_nozzle_maps, _nozzle_list, and Slic3r::MultiNozzleUtils::NozzleGroupResultBase::support_dynamic_nozzle_map.

Referenced by Slic3r::Print::collect_filament_variant_uses(), get_used_extruders(), and get_used_nozzles_in_extruder().

Here is the caller graph for this function:

get_used_extruders() [1/2]

std::vector< int > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_used_extruders ( ) const

overridevirtual

Implements Slic3r::MultiNozzleUtils::NozzleGroupResultBase.

{
    return get_used_extruders(-1);
}

References get_used_extruders().

Referenced by Slic3r::FilamentGroupUtils::get_estimate_extruder_change_count(), Slic3r::FilamentGroupUtils::get_estimate_extruder_filament_change_count(), Slic3r::FilamentGroupUtils::get_estimate_nozzle_change_count(), and get_used_extruders().

Here is the call graph for this function:

Here is the caller graph for this function:

get_used_extruders() [2/2]

std::vector< int > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_used_extruders

(

int

layer_id

)

const

{
    std::set<int> used_extruders;
    // used filaments on the given layer (or globally)
    std::vector<unsigned int> target_filaments = get_used_filaments(layer_id);
    for (auto filament_id : target_filaments) {
        if (layer_id != -1) {
            // single-layer: nozzle used by this filament on this layer
            auto nozzle_opt = get_nozzle_for_filament(static_cast<int>(filament_id), layer_id);
            if (nozzle_opt) { used_extruders.insert(nozzle_opt->extruder_id); }
        } else {
            // global: every nozzle this filament uses across all layers
            auto nozzles = get_nozzles_for_filament(static_cast<int>(filament_id));
            for (const auto &nozzle : nozzles) { used_extruders.insert(nozzle.extruder_id); }
        }
    }
    return std::vector<int>(used_extruders.begin(), used_extruders.end());
}

References get_nozzle_for_filament(), get_nozzles_for_filament(), and get_used_filaments().

Here is the call graph for this function:

get_used_filaments() [1/2]

std::vector< unsigned int > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_used_filaments ( ) const

inlineoverridevirtual

Implements Slic3r::MultiNozzleUtils::NozzleGroupResultBase.

{ return _used_filaments; }

References _used_filaments.

Referenced by get_first_nozzle_for_filament(), get_used_extruders(), get_used_nozzles_in_extruder(), Slic3r::refine_groups_by_Nozzle_State(), and Slic3r::Print::update_to_config_by_nozzle_group_result().

Here is the caller graph for this function:

get_used_filaments() [2/2]

std::vector< unsigned int > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_used_filaments

(

int

layer_id

)

const

{
    if (layer_id < 0) { return _used_filaments; }
    if (layer_id >= static_cast<int>(_layer_filament_nozzle_maps.size())) { return _used_filaments; }
 
    if (!_layer_filament_sequences.empty() && layer_id < static_cast<int>(_layer_filament_sequences.size())) {
        return _layer_filament_sequences[layer_id];
    }
    return {};
}

References _layer_filament_nozzle_maps, _layer_filament_sequences, and _used_filaments.

get_used_nozzles_in_extruder() [1/2]

std::vector< NozzleInfo > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_used_nozzles_in_extruder	(	int	target_extruder_id,
		int	layer_id ) const

{
    std::set<int>           nozzle_ids;
    std::vector<NozzleInfo> result;
 
    std::vector<unsigned int> target_filaments = get_used_filaments(layer_id);
 
    for (unsigned int filament_id : target_filaments) {
        if (layer_id != -1) {
            auto nozzle_opt = get_nozzle_for_filament(static_cast<int>(filament_id), layer_id);
            if (nozzle_opt) {
                if (target_extruder_id == -1 || nozzle_opt->extruder_id == target_extruder_id) { nozzle_ids.insert(nozzle_opt->group_id); }
            }
        } else {
            auto nozzles = get_nozzles_for_filament(static_cast<int>(filament_id));
            for (const auto &nozzle : nozzles) {
                if (target_extruder_id == -1 || nozzle.extruder_id == target_extruder_id) { nozzle_ids.insert(nozzle.group_id); }
            }
        }
    }
    for (int nozzle_id : nozzle_ids) {
        if (nozzle_id >= 0 && nozzle_id < static_cast<int>(_nozzle_list.size())) { result.push_back(_nozzle_list[nozzle_id]); }
    }
    return result;
}

References _nozzle_list, get_nozzle_for_filament(), get_nozzles_for_filament(), and get_used_filaments().

Here is the call graph for this function:

get_used_nozzles_in_extruder() [2/2]

std::vector< NozzleInfo > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_used_nozzles_in_extruder ( int target_extruder_id = -1 ) const

overridevirtual

Implements Slic3r::MultiNozzleUtils::NozzleGroupResultBase.

{
    return get_used_nozzles_in_extruder(target_extruder_id, -1);
}

References get_used_nozzles_in_extruder().

Referenced by Slic3r::FilamentGroupUtils::get_estimate_extruder_filament_change_count(), Slic3r::FilamentGroupUtils::get_estimate_nozzle_change_count(), and get_used_nozzles_in_extruder().

Here is the call graph for this function:

Here is the caller graph for this function:

get_volume_map()

std::vector< int > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_volume_map

(

int

layer_id = -1

)

const

{
    const std::vector<int> &filament_nozzle_map = get_layer_filament_nozzle_map(layer_id);
    std::vector<int>        volume_map(filament_nozzle_map.size());
    for (size_t idx = 0; idx < filament_nozzle_map.size(); ++idx) {
        int nozzle_id = filament_nozzle_map[idx];
        if (nozzle_id >= 0 && nozzle_id < static_cast<int>(_nozzle_list.size())) {
            volume_map[idx] = _nozzle_list[nozzle_id].volume_type;
        } else {
            volume_map[idx] = -1;
        }
    }
    return volume_map;
}

References _nozzle_list, Slic3r::filament_nozzle_map(), and get_layer_filament_nozzle_map().

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

Here is the call graph for this function:

Here is the caller graph for this function:

is_support_dynamic_nozzle_map()

bool Slic3r::MultiNozzleUtils::NozzleGroupResultBase::is_support_dynamic_nozzle_map ( ) const

inlineinherited

{ return support_dynamic_nozzle_map; }

References support_dynamic_nozzle_map.

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

Here is the caller graph for this function:

Member Data Documentation

_default_filament_nozzle_map

std::vector<int> Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::_default_filament_nozzle_map

private

Referenced by create(), create(), get_first_nozzle_for_filament(), get_layer_filament_nozzle_map(), and get_nozzles_for_filament().

_layer_filament_nozzle_maps

std::vector<std::vector<int> > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::_layer_filament_nozzle_maps

private

Referenced by create(), get_first_nozzle_for_filament(), get_layer_count(), get_layer_filament_nozzle_map(), get_layer_filament_nozzle_maps(), get_nozzles_for_filament(), and get_used_filaments().

_layer_filament_sequences

std::vector<std::vector<unsigned int> > Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::_layer_filament_sequences

private

Referenced by create(), get_layer_filament_sequences(), and get_used_filaments().

_nozzle_list

std::vector<NozzleInfo> Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::_nozzle_list

private

Referenced by create(), create(), get_extruder_count(), get_extruder_map(), get_nozzle_from_id(), get_nozzle_map(), get_nozzles_for_filament(), get_used_nozzles_in_extruder(), and get_volume_map().

_used_filaments

std::vector<unsigned int> Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::_used_filaments

private

Referenced by create(), create(), get_used_filaments(), and get_used_filaments().

support_dynamic_nozzle_map

bool Slic3r::MultiNozzleUtils::NozzleGroupResultBase::support_dynamic_nozzle_map {false}

protectedinherited

{false}; // whether dynamic (selector) mapping is used

Referenced by NozzleGroupResultBase(), Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::create(), Slic3r::MultiNozzleUtils::StaticNozzleGroupResult::create(), Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_first_nozzle_for_filament(), Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_nozzles_for_filament(), and is_support_dynamic_nozzle_map().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/MultiNozzleUtils.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/MultiNozzleUtils.cpp