Slic3r::MultiNozzleUtils Namespace Reference

Classes
struct	NozzleInfo
struct	NozzleGroupInfo
struct	FilamentChangeTimeParams
class	NozzleGroupResultBase
	Abstract base for a nozzle-grouping result. More...
class	LayeredNozzleGroupResult
	Layer-aware nozzle-grouping result. Used by the back-end slicing code; supports per-layer nozzle mapping. More...
class	StaticNozzleGroupResult
	Layer-less nozzle-grouping result for the device side (static nozzle mapping only). Reconstructed from a loaded gcode.3mf together with the filament/nozzle change sequences. More...
class	NozzleStatusRecorder
struct	FilamentChangeSimResult

Functions
std::vector< NozzleInfo >	build_nozzle_list (std::vector< NozzleGroupInfo > nozzle_groups)
std::vector< NozzleInfo >	build_nozzle_list (double diameter, const std::vector< int > &filament_nozzle_map, const std::vector< int > &filament_volume_map, const std::vector< int > &filament_map)
void	normalize_nozzle_map_per_layer (std::vector< std::vector< int > > &layer_filament_nozzle_maps, const std::vector< std::vector< unsigned int > > &layer_filaments)
static bool	has_filament_mapped_to_multiple_nozzles (const std::vector< std::vector< int > > &layer_filament_nozzle_maps, const std::vector< unsigned int > &used_filaments)
FilamentChangeSimResult	simulate_filament_change_time (const std::vector< int > &logical_filaments, const std::vector< NozzleInfo > &nozzle_list, const std::vector< int > &filament_change_seq, const std::vector< int > &nozzle_change_seq, const std::vector< int > &group_of_filament, const FilamentChangeTimeParams &time_params, const std::vector< bool > &ams_preload_enabled, bool calc_sliced_time)
std::vector< NozzleInfo >	load_nozzle_infos_with_compatibility (const std::vector< NozzleInfo > &nozzle_infos, const std::vector< FilamentInfo > &filament_infos, const std::vector< int > &filament_map, const std::vector< NozzleVolumeType > &extruder_volume_types, const std::vector< double > &nozzle_diameter)

---

Class Documentation

Slic3r::MultiNozzleUtils::FilamentChangeTimeParams

struct Slic3r::MultiNozzleUtils::FilamentChangeTimeParams

Class Members
float	selector_load_time {0.0f}
float	selector_unload_time {0.0f}
float	standard_load_time {0.0f}
float	standard_unload_time {0.0f}

Slic3r::MultiNozzleUtils::FilamentChangeSimResult

struct Slic3r::MultiNozzleUtils::FilamentChangeSimResult

Class Members
double	actual_time = 0.0
double	sliced_time = 0.0

Function Documentation

build_nozzle_list() [1/2]

std::vector< NozzleInfo > Slic3r::MultiNozzleUtils::build_nozzle_list	(	double	diameter,
		const std::vector< int > &	filament_nozzle_map,
		const std::vector< int > &	filament_volume_map,
		const std::vector< int > &	filament_map )

{
    std::string diameter_str = format_diameter_to_str(diameter);
    std::map<int, std::vector<int>> nozzle_to_filaments;
    for(size_t idx = 0; idx < filament_nozzle_map.size(); ++idx){
        int nozzle_id = filament_nozzle_map[idx];
        nozzle_to_filaments[nozzle_id].emplace_back(static_cast<int>(idx));
    }
    std::vector<NozzleInfo> ret;
    for(auto& elem : nozzle_to_filaments){
        int nozzle_id = elem.first;
        auto& filaments = elem.second;
        NozzleInfo info;
        info.diameter = diameter_str;
        info.group_id = nozzle_id;
        info.extruder_id = filament_map[filaments.front()];
        info.volume_type = NozzleVolumeType(filament_volume_map[filaments.front()]);
        ret.emplace_back(std::move(info));
    }
    return ret;
}

References Slic3r::MultiNozzleUtils::NozzleInfo::diameter, Slic3r::MultiNozzleUtils::NozzleInfo::extruder_id, Slic3r::filament_map(), Slic3r::filament_nozzle_map(), Slic3r::format_diameter_to_str(), Slic3r::MultiNozzleUtils::NozzleInfo::group_id, and Slic3r::MultiNozzleUtils::NozzleInfo::volume_type.

Here is the call graph for this function:

build_nozzle_list() [2/2]

std::vector< NozzleInfo > Slic3r::MultiNozzleUtils::build_nozzle_list

(

std::vector< NozzleGroupInfo >

nozzle_groups

)

{
    std::vector<NozzleInfo> ret;
    std::sort(nozzle_groups.begin(), nozzle_groups.end());
    int nozzle_id = 0;
    for (auto& group : nozzle_groups) {
        for (int i = 0; i < group.nozzle_count; ++i) {
            NozzleInfo tmp;
            tmp.diameter = group.diameter;
            tmp.extruder_id = group.extruder_id;
            tmp.volume_type = group.volume_type;
            tmp.group_id = nozzle_id++;
            ret.emplace_back(std::move(tmp));
        }
    }
    return ret;
}

References Slic3r::MultiNozzleUtils::NozzleInfo::diameter, Slic3r::MultiNozzleUtils::NozzleInfo::extruder_id, Slic3r::MultiNozzleUtils::NozzleInfo::group_id, and Slic3r::MultiNozzleUtils::NozzleInfo::volume_type.

Referenced by Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::create().

Here is the caller graph for this function:

has_filament_mapped_to_multiple_nozzles()

bool Slic3r::MultiNozzleUtils::has_filament_mapped_to_multiple_nozzles ( const std::vector< std::vector< int > > & layer_filament_nozzle_maps, const std::vector< unsigned int > & used_filaments )

static

{
    if (layer_filament_nozzle_maps.empty() || used_filaments.empty())
        return false;
 
    for (auto filament_id_u : used_filaments) {
        int filament_id = static_cast<int>(filament_id_u);
        std::set<int> nozzle_ids;
 
        for (size_t layer_id = 0; layer_id < layer_filament_nozzle_maps.size(); ++layer_id) {
            const auto &map = layer_filament_nozzle_maps[layer_id];
            if (filament_id < 0 || filament_id >= static_cast<int>(map.size()))
                continue;
 
            int nozzle_id = map[filament_id];
            if (nozzle_id < 0)
                continue;
 
            nozzle_ids.insert(nozzle_id);
            if (nozzle_ids.size() > 1)
                return true;
        }
    }
 
    return false;
}

Referenced by Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::create().

Here is the caller graph for this function:

load_nozzle_infos_with_compatibility()

std::vector< NozzleInfo > Slic3r::MultiNozzleUtils::load_nozzle_infos_with_compatibility	(	const std::vector< NozzleInfo > &	nozzle_infos,
		const std::vector< FilamentInfo > &	filament_infos,
		const std::vector< int > &	filament_map,
		const std::vector< NozzleVolumeType > &	extruder_volume_types,
		const std::vector< double > &	nozzle_diameter )

{
    bool has_nozzle_info = !nozzle_infos.empty();
    bool has_valid_filament_info = !filament_infos.empty() && std::all_of(filament_infos.begin(), filament_infos.end(), [](const FilamentInfo& info){
        return info.group_id.size() == 1;
    });
 
    if(!has_nozzle_info && !has_valid_filament_info){
        BOOST_LOG_TRIVIAL(warning)<<__FUNCTION__ << ": building nozzle list from filament map and volume types";
 
        // Backward compatibility for older gcode.3mf:
        // - nozzle_diameter is always present and its size defines extruder count.
        // - filament_map may be missing; treat it as [0, 0, ...] for each extruder.
        // - extruder_volume_types may be missing; treat it as all Standard.
        const size_t extruder_count = nozzle_diameter.size();
 
        std::vector<NozzleVolumeType> volume_types_fixed = extruder_volume_types;
        volume_types_fixed.resize(extruder_count, NozzleVolumeType::nvtStandard);
 
        std::vector<NozzleInfo> result;
        result.reserve(extruder_count);
        for (size_t extruder_id = 0; extruder_id < extruder_count; ++extruder_id) {
            NozzleInfo info;
            info.diameter    = format_diameter_to_str(nozzle_diameter[extruder_id]);
            info.group_id    = static_cast<int>(extruder_id);
            info.extruder_id = static_cast<int>(extruder_id);
            info.volume_type = volume_types_fixed[extruder_id];
            result.emplace_back(std::move(info));
        }
        return result;
    }
 
    if(!has_nozzle_info){
        BOOST_LOG_TRIVIAL(info)<<__FUNCTION__ << ": building nozzle list from filament info";
        std::map<int, NozzleInfo> nozzle_map; // group_id -> NozzleInfo
        for(auto& filament : filament_infos){
            int group_id = filament.group_id.front();
            if(group_id < 0 || nozzle_map.find(group_id) != nozzle_map.end()){
                continue;
            }
 
            auto volume_type_str_to_enum = ConfigOptionEnum<NozzleVolumeType>::get_enum_values();
 
            NozzleInfo info;
            info.diameter = format_diameter_to_str(filament.nozzle_diameter);
            info.group_id = group_id;
            // Orca: bounds-check filament_map[filament.id] so a malformed 3mf (filament id
            // beyond the map) degrades to extruder 0 instead of dereferencing out of range.
            info.extruder_id = (filament.id >= 0 && filament.id < static_cast<int>(filament_map.size()))
                                   ? filament_map[filament.id] - 1
                                   : 0; // to 0-based
 
            if (volume_type_str_to_enum.count(filament.nozzle_volume_type))
                info.volume_type = NozzleVolumeType(volume_type_str_to_enum.at(filament.nozzle_volume_type));
            else {
                info.volume_type = NozzleVolumeType::nvtStandard;
            }
 
            nozzle_map[group_id] = std::move(info);
        }
 
        std::vector<NozzleInfo> ret;
        for(auto& elem : nozzle_map){
            ret.emplace_back(elem.second);
        }
        return ret;
    }
 
    auto result = nozzle_infos;
    std::sort(result.begin(), result.end());
    BOOST_LOG_TRIVIAL(info)<<__FUNCTION__ << ": using new 3mf format with " << result.size() << " nozzle infos.";
    return result;
}

References Slic3r::MultiNozzleUtils::NozzleInfo::diameter, Slic3r::MultiNozzleUtils::NozzleInfo::extruder_id, Slic3r::filament_map(), Slic3r::format_diameter_to_str(), Slic3r::ConfigOptionEnum< T >::get_enum_values(), Slic3r::group_id(), Slic3r::MultiNozzleUtils::NozzleInfo::group_id, Slic3r::nozzle_diameter(), Slic3r::nvtStandard, and Slic3r::MultiNozzleUtils::NozzleInfo::volume_type.

Referenced by Slic3r::GUI::PartPlateList::load_from_3mf_structure().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_nozzle_map_per_layer()

void Slic3r::MultiNozzleUtils::normalize_nozzle_map_per_layer	(	std::vector< std::vector< int > > &	layer_filament_nozzle_maps,
		const std::vector< std::vector< unsigned int > > &	layer_filaments )

{
    if (layer_filament_nozzle_maps.empty())
        return;
 
    const int total_layers = static_cast<int>(layer_filament_nozzle_maps.size());
    int filament_count = 0;
    for (const auto &layer_map : layer_filament_nozzle_maps)
        filament_count = std::max(filament_count, static_cast<int>(layer_map.size()));
 
    auto layer_uses_filament = [](const std::vector<unsigned int> &filaments, int filament_id) {
        return std::find(filaments.begin(), filaments.end(), static_cast<unsigned int>(filament_id)) != filaments.end();
    };
 
    std::vector<int>             last_used_nozzle(filament_count, -1);
    std::unordered_map<int, int> first_used_nozzle;
    std::unordered_map<int, int> first_used_layer;
 
    // Forward pass: layers that extrude a filament define its nozzle; layers that don't inherit
    // the nozzle it last used (carry-forward), remembering the first-ever nozzle for the back-fill.
    for (int layer_id = 0; layer_id < total_layers; ++layer_id) {
        auto &layer_map = layer_filament_nozzle_maps[layer_id];
        const auto &used = layer_id < static_cast<int>(layer_filaments.size()) ? layer_filaments[layer_id] : std::vector<unsigned int>();
 
        for (int filament_id = 0; filament_id < static_cast<int>(layer_map.size()); ++filament_id) {
            if (layer_uses_filament(used, filament_id)) {
                last_used_nozzle[filament_id] = layer_map[filament_id];
                if (first_used_nozzle.count(filament_id) == 0) {
                    first_used_nozzle[filament_id] = layer_map[filament_id];
                    first_used_layer[filament_id]  = layer_id;
                }
            } else if (last_used_nozzle[filament_id] >= 0) {
                layer_map[filament_id] = last_used_nozzle[filament_id];
            }
        }
    }
 
    // Back-fill pass: layers before a filament's first use inherit the first nozzle it ever uses.
    for (int layer_id = 0; layer_id < total_layers; ++layer_id) {
        auto &layer_map = layer_filament_nozzle_maps[layer_id];
        for (int filament_id = 0; filament_id < static_cast<int>(layer_map.size()); ++filament_id) {
            if (first_used_layer.count(filament_id) != 0 && layer_id < first_used_layer[filament_id])
                layer_map[filament_id] = first_used_nozzle[filament_id];
        }
    }
}

Referenced by Slic3r::ToolOrdering::build_sequential_group_result().

Here is the caller graph for this function:

simulate_filament_change_time()

FilamentChangeSimResult Slic3r::MultiNozzleUtils::simulate_filament_change_time	(	const std::vector< int > &	logical_filaments,
		const std::vector< NozzleInfo > &	nozzle_list,
		const std::vector< int > &	filament_change_seq,
		const std::vector< int > &	nozzle_change_seq,
		const std::vector< int > &	group_of_filament,
		const FilamentChangeTimeParams &	time_params,
		const std::vector< bool > &	ams_preload_enabled,
		bool	calc_sliced_time )

{
    FilamentChangeSimResult result;
    if (logical_filaments.empty() || nozzle_list.empty() || filament_change_seq.empty() || nozzle_change_seq.empty())
        return result;
 
    // Re-map the parameter semantics:
    // standard = AMS -> selector -> extruder (full path), selector = selector -> extruder (short path)
    // so AMS -> selector = standard - selector
    const float load_ams_to_selector   = time_params.standard_load_time   - time_params.selector_load_time;
    const float unload_ams_to_selector = time_params.standard_unload_time - time_params.selector_unload_time;
    const float load_selector_to_ext   = time_params.selector_load_time;
    const float unload_ext_to_selector = time_params.selector_unload_time;
 
    // nozzle_id -> extruder_id
    std::unordered_map<int, int> nozzle_to_extruder;
    nozzle_to_extruder.reserve(nozzle_list.size());
    for (const auto& nozzle : nozzle_list)
        nozzle_to_extruder[nozzle.group_id] = nozzle.extruder_id;
 
    // filament_id -> AMS group
    std::unordered_map<int, int> filament_to_group;
    filament_to_group.reserve(logical_filaments.size());
    for (size_t i = 0; i < logical_filaments.size(); ++i)
        filament_to_group[logical_filaments[i]] = group_of_filament[i];
 
    const auto get_group = [&](int filament_id) -> int {
        auto it = filament_to_group.find(filament_id);
        return it != filament_to_group.end() ? it->second : -1;
    };
 
    const auto is_preload_enabled = [&](int group_id) -> bool {
        if (group_id < 0 || group_id >= static_cast<int>(ams_preload_enabled.size()))
            return false;
        return ams_preload_enabled[group_id];
    };
 
    // Filament location states
    enum class Location { IN_AMS, IN_SELECTOR, IN_EXTRUDER };
    std::unordered_map<int, Location> filament_location;  // filament_id -> current location
    std::unordered_map<int, int>      filament_extruder;  // filament_id -> extruder it sits in (only valid when IN_EXTRUDER)
    std::unordered_map<int, int>      extruder_filament;  // extruder_id -> currently loaded filament
     // group_id -> filaments currently occupying that AMS channel (IN_SELECTOR or IN_EXTRUDER)
    std::unordered_map<int, std::unordered_set<int>> ams_group_occupied;
 
    filament_location.reserve(logical_filaments.size());
    filament_extruder.reserve(logical_filaments.size());
 
    // Initial state: every filament is in the AMS, every extruder is empty
    for (int f : logical_filaments)
        filament_location[f] = Location::IN_AMS;
 
    // Slicer-estimate simulator: use NozzleStatusRecorder to track what each nozzle/extruder holds during slicing
    NozzleStatusRecorder sliced_recorder;
 
    const size_t seq_len = std::min(filament_change_seq.size(), nozzle_change_seq.size());
    double actual_time = 0.0;
    double sliced_time = 0.0;
 
    for (size_t i = 0; i < seq_len; ++i) {
        int B         = filament_change_seq[i];
        int nozzle_id = nozzle_change_seq[i];
 
        auto nozzle_iter = nozzle_to_extruder.find(nozzle_id);
        if (nozzle_iter == nozzle_to_extruder.end()) continue;
 
        int E = nozzle_iter->second; // target extruder
 
        // Step 0: compute the slicer-estimated time
        // Slicer estimate: simulate the slicer's view (no selector awareness);
        // count a load/unload when nozzle_in_extruder_change || filament_in_nozzle_change
        if (calc_sliced_time) {
            int old_nozzle_in_E        = sliced_recorder.get_nozzle_in_extruder(E);
            int old_filament_in_nozzle = sliced_recorder.get_filament_in_nozzle(nozzle_id);
            int old_filament_in_ext    = sliced_recorder.get_filament_in_nozzle(old_nozzle_in_E);
 
            bool nozzle_change   = (old_nozzle_in_E != nozzle_id);
            bool filament_change = (old_filament_in_nozzle != B);
 
            if (nozzle_change || filament_change) {
                if (old_filament_in_ext != -1)
                    sliced_time += time_params.standard_unload_time;
                sliced_time += time_params.standard_load_time;
            }
            sliced_recorder.set_nozzle_status(nozzle_id, B, E);
        }
 
        // Step 1: find the filament A currently loaded in the target extruder E
        int A = -1;
        {
            auto it = extruder_filament.find(E);
            if (it != extruder_filament.end())
                A = it->second;
        }
 
        int group_B = get_group(B);
        int group_A = (A != -1) ? get_group(A) : -1;
 
        // Step 2: clear B's AMS-channel occupancy
        auto group_it = ams_group_occupied.find(group_B);
        if (group_it != ams_group_occupied.end()) {
            for (int X : group_it->second) {
                if (X == B) continue;
                // X shares B's AMS channel, retreat it to the AMS to make way
                Location loc_X = filament_location[X];
                if (loc_X == Location::IN_EXTRUDER) {
                    actual_time += unload_ext_to_selector + unload_ams_to_selector;
                    int E2 = filament_extruder[X];
                    extruder_filament.erase(E2);
                    filament_extruder.erase(X);
                } else if (loc_X == Location::IN_SELECTOR) {
                    actual_time += unload_ams_to_selector;
                }
                filament_location[X] = Location::IN_AMS;
            }
            group_it->second.clear();
        }
 
        // Step 3: A exits E (while A is still in the extruder)
        // Step 3.5: pre-load B (in parallel with Step 3)
        // actual time = max(Step 3, Step 3.5)
        bool step3_executed = false;
        float step3_time = 0.0f;
        if (A != -1 && A != B && filament_location[A] == Location::IN_EXTRUDER) {
            if (is_preload_enabled(group_A) && group_A != group_B) {
                step3_time = unload_ext_to_selector;
                filament_location[A] = Location::IN_SELECTOR;
            } else {
                step3_time = unload_ext_to_selector + unload_ams_to_selector;
                filament_location[A] = Location::IN_AMS;
                ams_group_occupied[group_A].erase(A);
            }
            extruder_filament.erase(E);
            filament_extruder.erase(A);
            step3_executed = true;
        }
 
        float step3_5_time = 0.0f;
        if (step3_executed &&
            filament_location[B] == Location::IN_AMS &&
            group_A != group_B &&
            is_preload_enabled(group_B)) {
            step3_5_time = load_ams_to_selector;
            filament_location[B] = Location::IN_SELECTOR;
            ams_group_occupied[group_B].insert(B);
        }
 
        actual_time += std::max(step3_time, step3_5_time);
 
        // Step 4: push B into E
        // Step 6: pre-load the next filament C (in parallel with Step 4)
        // actual time = max(Step 4, Step 6)
        float step4_time = 0.0f;
        Location loc_B = filament_location[B];
        if (loc_B == Location::IN_AMS) {
            step4_time = load_ams_to_selector + load_selector_to_ext;
        } else if (loc_B == Location::IN_SELECTOR) {
            step4_time = load_selector_to_ext;
        }
 
        // Step 5: update state
        extruder_filament[E]  = B;
        filament_location[B]  = Location::IN_EXTRUDER;
        filament_extruder[B]  = E;
        ams_group_occupied[group_B].insert(B);
 
        float step6_time = 0.0f;
        if (i + 1 < seq_len) {
            int C = filament_change_seq[i + 1];
            int group_C = get_group(C);
            if (filament_location[C] == Location::IN_AMS &&
                group_C != group_B &&
                is_preload_enabled(group_C) &&
                ams_group_occupied[group_C].empty()) {
                step6_time = load_ams_to_selector;
                filament_location[C] = Location::IN_SELECTOR;
                ams_group_occupied[group_C].insert(C);
            }
        }
 
        actual_time += std::max(step4_time, step6_time);
    }
 
    result.actual_time = actual_time;
    result.sliced_time = sliced_time;
    return result;
}

References Slic3r::MultiNozzleUtils::FilamentChangeSimResult::actual_time, Slic3r::E, Slic3r::empty(), Slic3r::f(), Slic3r::MultiNozzleUtils::NozzleStatusRecorder::get_filament_in_nozzle(), Slic3r::MultiNozzleUtils::NozzleStatusRecorder::get_nozzle_in_extruder(), Slic3r::group_id(), Slic3r::MultiNozzleUtils::FilamentChangeTimeParams::selector_load_time, Slic3r::MultiNozzleUtils::FilamentChangeTimeParams::selector_unload_time, Slic3r::MultiNozzleUtils::NozzleStatusRecorder::set_nozzle_status(), Slic3r::MultiNozzleUtils::FilamentChangeSimResult::sliced_time, Slic3r::MultiNozzleUtils::FilamentChangeTimeParams::standard_load_time, Slic3r::MultiNozzleUtils::FilamentChangeTimeParams::standard_unload_time, and Slic3r::X.

Referenced by Slic3r::calc_change_time_for_group(), and Slic3r::GUI::SelectMachineDialog::get_filament_change_gap_time().

Here is the call graph for this function:

Here is the caller graph for this function: