Slic3r::FilamentGroup Class Reference

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

Collaboration diagram for Slic3r::FilamentGroup:

Public Member Functions
	FilamentGroup (const FilamentGroupContext &ctx_)
void	set_clustering_budget (const ClusteringBudget &budget)
std::vector< int >	calc_filament_group (int *cost=nullptr)
std::vector< std::vector< int > >	get_memoryed_groups () const
std::vector< int >	calc_filament_group_for_match (int *cost=nullptr)
std::vector< int >	calc_filament_group_for_flush (int *cost=nullptr)
std::vector< int >	calc_filament_group_for_tpu (int *cost=nullptr)

Public Attributes
std::optional< std::function< bool(int, std::vector< int > &)> >	get_custom_seq

Private Types
using	MemoryedGroup = FilamentGroupUtils::MemoryedGroup
using	MemoryedGroupHeap = FilamentGroupUtils::MemoryedGroupHeap

Private Member Functions
std::vector< int >	calc_min_flush_group (int *cost=nullptr)
std::vector< int >	calc_group_by_enum (int k, const std::vector< unsigned int > &used_filaments, const std::unordered_map< int, std::vector< int > > &unplaceable_limits, int *cost=nullptr)
std::vector< int >	calc_group_by_kmedoids (int k, const std::vector< unsigned int > &used_filaments, const std::unordered_map< int, std::vector< int > > &unplaceable_limits, int *cost=nullptr)
std::map< int, int >	rebuild_unprintables (const std::vector< unsigned int > &used_filaments, const std::map< int, int > &extruder_unprintables)
std::unordered_map< int, std::vector< int > >	rebuild_nozzle_unprintables (const std::vector< unsigned int > &used_filaments, const std::unordered_map< int, std::vector< int > > &extruder_unprintables, const std::vector< int > &filament_volume_map)
std::unordered_map< int, std::vector< int > >	try_merge_filaments ()
void	rebuild_context (const std::unordered_map< int, std::vector< int > > &merged_filaments)
std::vector< int >	seperate_merged_filaments (const std::vector< int > &filament_map, const std::unordered_map< int, std::vector< int > > &merged_filaments)

Private Attributes
FilamentGroupContext	ctx
MemoryedGroupHeap	m_memoryed_heap
std::vector< std::vector< int > >	m_memoryed_groups
ClusteringBudget	m_clustering_budget

Detailed Description

Member Typedef Documentation

MemoryedGroup

using Slic3r::FilamentGroup::MemoryedGroup = FilamentGroupUtils::MemoryedGroup

private

MemoryedGroupHeap

using Slic3r::FilamentGroup::MemoryedGroupHeap = FilamentGroupUtils::MemoryedGroupHeap

private

Constructor & Destructor Documentation

FilamentGroup()

Slic3r::FilamentGroup::FilamentGroup ( const FilamentGroupContext & ctx_ )

inlineexplicit

:ctx(ctx_) {}

References ctx.

Member Function Documentation

calc_filament_group()

std::vector< int > Slic3r::FilamentGroup::calc_filament_group

(

int *

cost = nullptr

)

    {
        /*auto extruder_variant_list = ctx.nozzle_info.extruder_nozzle_list;
        for (auto nozzle : ctx.nozzle_info.nozzle_list)
            if (nozzle.volume_type == NozzleVolumeType::nvtTPUHighFlow)
                return calc_filament_group_for_tpu(cost);*/
 
        try {
            if (FGMode::MatchMode == ctx.group_info.mode)
                return calc_filament_group_for_match(cost);
        }
        catch (const FilamentGroupException&) {
        }
 
        return calc_filament_group_for_flush(cost);
    }

References calc_filament_group_for_flush(), calc_filament_group_for_match(), ctx, and Slic3r::MatchMode.

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

Here is the call graph for this function:

Here is the caller graph for this function:

calc_filament_group_for_flush()

std::vector< int > Slic3r::FilamentGroup::calc_filament_group_for_flush

(

int *

cost = nullptr

)

    {
        auto used_filaments = collect_sorted_used_filaments(ctx.model_info.layer_filaments);
 
        std::vector<int> ret = calc_min_flush_group(cost);
        std::vector<std::vector<int>> memoryed_maps = this->m_memoryed_groups;
        memoryed_maps.insert(memoryed_maps.begin(), ret);
 
        std::vector<FilamentGroupUtils::FilamentInfo> used_filament_info;
        for (auto f : used_filaments) {
            used_filament_info.emplace_back(ctx.model_info.filament_info[f]);
        }
 
        ret = select_best_group_for_ams(memoryed_maps, ctx.nozzle_info.nozzle_list, used_filaments, used_filament_info, ctx.machine_info.machine_filament_info, ctx.group_info.has_filament_switcher);
        return ret;
    }

References calc_min_flush_group(), Slic3r::collect_sorted_used_filaments(), ctx, Slic3r::f(), m_memoryed_groups, and Slic3r::select_best_group_for_ams().

Referenced by calc_filament_group(), Slic3r::calc_filament_group_for_manual_multi_nozzle(), and Slic3r::calc_filament_group_for_match_multi_nozzle().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_filament_group_for_match()

std::vector< int > Slic3r::FilamentGroup::calc_filament_group_for_match

(

int *

cost = nullptr

)

    {
        using namespace FlushPredict;
        constexpr int SupportPreferScore = 3;
 
        auto used_filaments = collect_sorted_used_filaments(ctx.model_info.layer_filaments);
        std::vector<FilamentGroupUtils::FilamentInfo> used_filament_list;
        for (auto f : used_filaments)
            used_filament_list.emplace_back(ctx.model_info.filament_info[f]);
 
        std::vector<MachineFilamentInfo> machine_filament_list;
        std::map<MachineFilamentInfo, std::set<int>> machine_filament_set;
        for (size_t eid = 0; eid < ctx.machine_info.machine_filament_info.size();++eid) {
            for (auto& filament : ctx.machine_info.machine_filament_info[eid]) {
                machine_filament_set[filament].insert(machine_filament_list.size());
                machine_filament_list.emplace_back(filament);
            }
        }
 
        if (machine_filament_list.empty())
            throw FilamentGroupException(FilamentGroupException::EmptyAmsFilaments,"Empty ams filament in For-Match mode.");
 
        std::map<int, int> unprintable_limit_indices; // key stores filament idx in used_filament, value stores unprintable extruder
        extract_unprintable_limit_indices(ctx.model_info.unprintable_filaments, used_filaments, unprintable_limit_indices);
        unprintable_limit_indices = rebuild_unprintables(used_filaments, unprintable_limit_indices);
 
        std::vector<std::vector<float>> color_dist_matrix(used_filament_list.size(), std::vector<float>(machine_filament_list.size()));
        for (size_t i = 0; i < used_filament_list.size(); ++i) {
            for (size_t j = 0; j < machine_filament_list.size(); ++j) {
                color_dist_matrix[i][j] = calc_color_distance(
                    RGBColor(used_filament_list[i].color.r, used_filament_list[i].color.g, used_filament_list[i].color.b),
                    RGBColor(machine_filament_list[j].color.r, machine_filament_list[j].color.g, machine_filament_list[j].color.b)
                );
            }
        }
 
        std::vector<int>l_nodes(used_filaments.size());
        std::iota(l_nodes.begin(), l_nodes.end(), 0);
        std::vector<int>r_nodes(machine_filament_list.size());
        std::iota(r_nodes.begin(), r_nodes.end(), 0);
        std::vector<int>machine_filament_capacity(machine_filament_list.size(),l_nodes.size());
        std::vector<int>extruder_filament_count(2, 0);
 
        auto is_extruder_filament_compatible = [&unprintable_limit_indices](int filament_idx, int extruder_id) {
            auto iter = unprintable_limit_indices.find(filament_idx);
            if (iter != unprintable_limit_indices.end() && iter->second == extruder_id)
                return false;
            return true;
            };
 
        auto build_unlink_limits = [](const std::vector<int>& l_nodes, const std::vector<int>& r_nodes, const std::function<bool(int, int)>& can_link) {
            std::unordered_map<int, std::vector<int>> unlink_limits;
            for (size_t i = 0; i < l_nodes.size(); ++i) {
                std::vector<int> unlink_filaments;
                for (size_t j = 0; j < r_nodes.size(); ++j) {
                    if (!can_link(l_nodes[i], r_nodes[j]))
                        unlink_filaments.emplace_back(j);
                }
                if (!unlink_filaments.empty())
                    unlink_limits.emplace(i, std::move(unlink_filaments));
            }
            return unlink_limits;
            };
 
        auto optimize_map_to_machine_filament = [&](const std::vector<int>& map_to_machine_filament, const std::vector<int>& l_nodes, const std::vector<int>& r_nodes, std::vector<int>& filament_map) {
            std::vector<int> ungrouped_filaments;
            std::vector<int> filaments_to_optimize;
 
            auto map_filament_to_machine_filament = [&](int filament_idx, int machine_filament_idx) {
                auto& machine_filament = machine_filament_list[machine_filament_idx];
                filament_map[used_filaments[filament_idx]] = machine_filament.extruder_id;  // set extruder id to filament map
                extruder_filament_count[machine_filament.extruder_id] += 1; // increase filament count in extruder
                };
            auto unmap_filament_to_machine_filament = [&](int filament_idx, int machine_filament_idx) {
                auto& machine_filament = machine_filament_list[machine_filament_idx];
                extruder_filament_count[machine_filament.extruder_id] -= 1; // increase filament count in extruder
                };
 
            for (size_t idx = 0; idx < map_to_machine_filament.size(); ++idx) {
                if (map_to_machine_filament[idx] == MaxFlowGraph::INVALID_ID) {
                    ungrouped_filaments.emplace_back(l_nodes[idx]);
                    continue;
                }
                int used_filament_idx = l_nodes[idx];
                int machine_filament_idx = r_nodes[map_to_machine_filament[idx]];
                auto& machine_filament = machine_filament_list[machine_filament_idx];
                if (machine_filament_set[machine_filament].size() > 1 && unprintable_limit_indices.count(used_filament_idx) == 0)
                    filaments_to_optimize.emplace_back(idx);
 
                map_filament_to_machine_filament(used_filament_idx, machine_filament_idx);
            }
            // try to optimize the result
            for (auto idx : filaments_to_optimize) {
                int filament_idx = l_nodes[idx];
                bool is_support_filament = used_filament_list[filament_idx].usage_type == FilamentUsageType::SupportOnly;
                int old_machine_filament_idx = r_nodes[map_to_machine_filament[idx]];
                auto& old_machine_filament = machine_filament_list[old_machine_filament_idx];
 
                unmap_filament_to_machine_filament(filament_idx, old_machine_filament_idx);
 
                auto optional_filaments = machine_filament_set[old_machine_filament];
 
                // Phase 1: collect all candidates and compute their preference scores
                std::vector<std::pair<int, int>> valid_candidates; // available machine-filament idx and its score
                for (auto machine_filament : optional_filaments) {
                    int new_extruder_id = machine_filament_list[machine_filament].extruder_id;
 
                    // preference score for this assignment
                    int preference_score = 0;
                    bool new_extruder_prefer_support = ctx.machine_info.prefer_non_model_filament[new_extruder_id];
 
                    // reward a support filament assigned to a support-preferring nozzle
                    if (is_support_filament && new_extruder_prefer_support) {
                        preference_score += SupportPreferScore;
                    }
 
                    valid_candidates.emplace_back(machine_filament, preference_score);
                }
                // Phase 2: determine the best preference score
                int best_preference_score = 0;
                for (const auto& candidate : valid_candidates) {
                    if (candidate.second >= best_preference_score) {
                        best_preference_score = candidate.second;
                    }
                }
 
                // Phase 3: among candidates with the best preference score, pick the most load-balanced one
                int best_candidate = -1;
                int best_gap = std::numeric_limits<int>::max();
 
                for (const auto& candidate : valid_candidates) {
                    // only consider candidates with the best preference score
                    int machine_filament = candidate.first;
                    int score = candidate.second;
                    if (score == best_preference_score) {
                        int new_extruder_id = machine_filament_list[machine_filament].extruder_id;
                        int new_gap = std::abs(extruder_filament_count[new_extruder_id] + 1 - extruder_filament_count[1 - new_extruder_id]);
 
                        // among equal-preference candidates, pick the one giving the most balanced load
                        if (new_gap < best_gap) {
                            best_gap = new_gap;
                            best_candidate = machine_filament;
                        }
                    }
                }
                // apply the best choice
                if (best_candidate != -1) {
                    map_filament_to_machine_filament(filament_idx, best_candidate);
                } else {
                    map_filament_to_machine_filament(filament_idx, old_machine_filament_idx);
                }
            }
            return ungrouped_filaments;
            };
 
        std::vector<int> group(ctx.group_info.total_filament_num, ctx.machine_info.master_extruder_id);
        std::vector<int> ungrouped_filaments;
 
        auto unlink_limits_full = build_unlink_limits(l_nodes, r_nodes, [&used_filament_list, &machine_filament_list, is_extruder_filament_compatible](int used_filament_idx, int machine_filament_idx) {
            return used_filament_list[used_filament_idx].type == machine_filament_list[machine_filament_idx].type &&
                used_filament_list[used_filament_idx].is_support == machine_filament_list[machine_filament_idx].is_support &&
                is_extruder_filament_compatible(used_filament_idx, machine_filament_list[machine_filament_idx].extruder_id);
            });
 
        {
            MatchModeGroupSolver s(color_dist_matrix, l_nodes, r_nodes, machine_filament_capacity, unlink_limits_full);
            ungrouped_filaments = optimize_map_to_machine_filament(s.solve(), l_nodes, r_nodes,group);
            if (ungrouped_filaments.empty())
                return group;
        }
 
        // additionally remove type limits
        {
            l_nodes = ungrouped_filaments;
            auto unlink_limits = build_unlink_limits(l_nodes, r_nodes, [&machine_filament_list, is_extruder_filament_compatible](int used_filament_idx, int machine_filament_idx) {
                return is_extruder_filament_compatible(used_filament_idx, machine_filament_list[machine_filament_idx].extruder_id);
                });
 
            MatchModeGroupSolver s(color_dist_matrix, l_nodes, r_nodes, machine_filament_capacity, unlink_limits);
            ungrouped_filaments = optimize_map_to_machine_filament(s.solve(), l_nodes, r_nodes, group);
            if (ungrouped_filaments.empty())
                return group;
        }
 
        // remove all limits
        {
            l_nodes = ungrouped_filaments;
            MatchModeGroupSolver s(color_dist_matrix, l_nodes, r_nodes, machine_filament_capacity, {});
            auto ret = optimize_map_to_machine_filament(s.solve(), l_nodes, r_nodes, group);
            for (size_t idx = 0; idx < ret.size(); ++idx) {
                if (ret[idx] == MaxFlowGraph::INVALID_ID)
                    assert(false);
                else
                    group[used_filaments[l_nodes[idx]]] = machine_filament_list[r_nodes[ret[idx]]].extruder_id;
            }
        }
 
        return group;
    }

References FlushPredict::calc_color_distance(), Slic3r::collect_sorted_used_filaments(), ctx, Slic3r::FilamentGroupUtils::FilamentGroupException::EmptyAmsFilaments, Slic3r::FilamentGroupUtils::extract_unprintable_limit_indices(), Slic3r::f(), Slic3r::filament_map(), Slic3r::MaxFlowGraph::INVALID_ID, rebuild_unprintables(), Slic3r::MatchModeGroupSolver::solve(), and Slic3r::SupportOnly.

Referenced by calc_filament_group(), and Slic3r::calc_filament_group_for_match_multi_nozzle().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_filament_group_for_tpu()

std::vector< int > Slic3r::FilamentGroup::calc_filament_group_for_tpu

(

int *

cost = nullptr

)

                                                                       {
 
        auto used_filaments = collect_sorted_used_filaments(ctx.model_info.layer_filaments);
        std::vector<FilamentGroupUtils::FilamentInfo> used_filament_list;
        for (auto f : used_filaments)
            used_filament_list.emplace_back(ctx.model_info.filament_info[f]);
 
        std::vector<std::vector<float>> print_time_matrix(used_filaments.size(), std::vector<float>(ctx.nozzle_info.extruder_nozzle_list.size()));
        for (int i = 0; i < used_filaments.size(); ++i){
            for (int j = 0; j < ctx.nozzle_info.extruder_nozzle_list.size(); ++j){
                print_time_matrix[i][j] = ctx.speed_info.filament_print_time[used_filaments[i]][j];
                if (ctx.nozzle_info.nozzle_list[j].volume_type == nvtTPUHighFlow)   // when both TPU High Flow and other nozzle types exist, prefer assigning filament to the TPU High Flow nozzle
                    print_time_matrix[i][j] *= 0.9;
            }
        }
 
        std::vector<int> l_nodes(used_filaments.size());
        std::iota(l_nodes.begin(), l_nodes.end(), 0);
        std::vector<int> r_nodes(ctx.nozzle_info.extruder_nozzle_list.size());
        std::iota(r_nodes.begin(), r_nodes.end(), 0);
        std::vector<int> machine_filament_capacity({int(used_filaments.size()), int(used_filaments.size())});
 
        std::map<int, int> unprintable_limit_indices; // key stores filament idx in used_filament, value stores unprintable extruder
        extract_unprintable_limit_indices(ctx.model_info.unprintable_filaments, used_filaments, unprintable_limit_indices);
        unprintable_limit_indices = rebuild_unprintables(used_filaments, unprintable_limit_indices);
 
        std::unordered_map<int, std::vector<int>> unlink_limits(used_filaments.size());
        for (int i = 0; i < used_filaments.size(); i++) {
            auto iter = unprintable_limit_indices.find(i);
            if (iter == unprintable_limit_indices.end() || iter->second < 0 || iter->second >= 2) continue;
            unlink_limits[i].emplace_back(iter->second);
        }
 
        MatchModeGroupSolver s(print_time_matrix, l_nodes, r_nodes, machine_filament_capacity, unlink_limits);
        auto ret = s.solve();
        for (size_t idx = 0; idx < ret.size(); ++idx) {
            if (ret[idx] == MaxFlowGraph::INVALID_ID) {
                assert(false);
                ret[idx] = 1;
            }
        }
        std::vector<int> group(ctx.group_info.total_filament_num, ctx.machine_info.master_extruder_id);
        for (int i = 0; i < ret.size(); ++i) group[used_filaments[i]] = ret[i];
        return group;
    }

References Slic3r::collect_sorted_used_filaments(), ctx, Slic3r::FilamentGroupUtils::extract_unprintable_limit_indices(), Slic3r::f(), Slic3r::MaxFlowGraph::INVALID_ID, Slic3r::nvtTPUHighFlow, rebuild_unprintables(), and Slic3r::MatchModeGroupSolver::solve().

Here is the call graph for this function:

calc_group_by_enum()

std::vector< int > Slic3r::FilamentGroup::calc_group_by_enum ( int k, const std::vector< unsigned int > & used_filaments, const std::unordered_map< int, std::vector< int > > & unplaceable_limits, int * cost = nullptr )

private

    {
        static constexpr int UNPLACEABLE_LIMIT_REWARD = 10000;
        static constexpr int MAX_SIZE_LIMIT_REWARD = 5000;
        static constexpr int SUPPORT_PREFER_REWARD = 100;
        static constexpr int BEST_FIT_LIMIT_REWARD = 10;
 
        int n = (int)used_filaments.size();
 
        std::vector<std::vector<int>> candidates(n);
        for (int i = 0; i < n; i++) {
            std::unordered_set<int> group_set;
            if (auto it = unplaceable_limits.find(i); it != unplaceable_limits.end()) {
                for (int g = 0; g < k; g++) group_set.insert(g);
                for (int g : it->second) group_set.erase(g);
            } else {
                for (int g = 0; g < k; g++) group_set.insert(g);
            }
            candidates[i].assign(group_set.begin(), group_set.end());
        }
 
        auto vector_equal = [](const std::vector<uint64_t>& a, const std::vector<uint64_t>& b) -> bool {
            if (a.size() != b.size()) return false;
            for (size_t i = 0; i < a.size(); i++) {
                if (a[i] != b[i]) return false;
            }
            return true;
        };
        auto vector_hash = [](const std::vector<uint64_t>& v) -> size_t {
            size_t h = 0;
            for (auto val : v) { h ^= val + GOLDEN_RATIO_32 + (h << 6) + (h >> 2); }
            return h;
        };
        std::unordered_set<std::vector<uint64_t>, decltype(vector_hash), decltype(vector_equal)> group_set(0, vector_hash, vector_equal);
        std::vector<uint64_t> group_hashs;
 
        std::vector<size_t> nozzles_hash(k);
        for (const auto& nozzle : ctx.nozzle_info.nozzle_list) {
            if (nozzle.group_id < k) {
                auto it = ctx.nozzle_info.nozzle_status.find(nozzle.group_id);
                int loaded_filament = (it != ctx.nozzle_info.nozzle_status.end()) ? it->second : -1;
                nozzles_hash[nozzle.group_id] = fnv_hash_nozzle(nozzle.volume_type, nozzle.group_id > 0, loaded_filament);
            }
        }
 
        std::vector<int> best_full_map(ctx.group_info.total_filament_num, ctx.machine_info.master_extruder_id);
        double best_score = std::numeric_limits<double>::max();
        int best_prefer_level = 0;
        int best_flush = 0;
 
        const long long total = (long long)std::pow(k, n);
        for (long long mask = 0; mask < total; mask++) {
            long long num = mask;
            std::unordered_map<int, std::vector<int>> nozzles_filaments;
            std::vector<int> groups_count(k, 0);
            std::vector<int> used_labels(n, 0);
 
            for (int i = 0; i < n; i++) {
                int g_id = num % k;
                num /= k;
                used_labels[i] = g_id;
                nozzles_filaments[g_id].emplace_back(i);
                groups_count[g_id]++;
            }
 
            // Hash dedup
            group_hashs.clear();
            for (auto& nf : nozzles_filaments) {
                uint64_t filament_mask = 0;
                for (int filament : nf.second) filament_mask |= (1ULL << filament);
                size_t gh = nozzles_hash[nf.first];
                gh ^= (std::hash<uint64_t>{}(filament_mask) + GOLDEN_RATIO_32 + (gh << 6) + (gh >> 2));
                group_hashs.emplace_back(gh);
            }
            std::sort(group_hashs.begin(), group_hashs.end());
            if (group_set.find(group_hashs) != group_set.end()) continue;
            group_set.insert(group_hashs);
 
            // Prefer level
            int prefer_level = 0;
            int placeable_count = 0;
            for (int i = 0; i < n; i++) {
                if (std::find(candidates[i].begin(), candidates[i].end(), used_labels[i]) != candidates[i].end())
                    placeable_count++;
            }
            prefer_level += placeable_count * UNPLACEABLE_LIMIT_REWARD;
 
            bool size_ok = true;
            for (int g = 0; g < k; g++) {
                if (g < (int)ctx.machine_info.max_group_size.size() && groups_count[g] > ctx.machine_info.max_group_size[g])
                    size_ok = false;
            }
            if (size_ok)
                prefer_level += MAX_SIZE_LIMIT_REWARD;
 
            if (ctx.group_info.strategy == FGStrategy::BestFit) {
                bool all_full = true;
                for (int g = 0; g < k; g++) {
                    if (g < (int)ctx.machine_info.max_group_size.size() && groups_count[g] < ctx.machine_info.max_group_size[g])
                        all_full = false;
                }
                if (all_full)
                    prefer_level += BEST_FIT_LIMIT_REWARD;
            }
 
            for (int g = 0; g < k; g++) {
                if (g < (int)ctx.machine_info.prefer_non_model_filament.size() && ctx.machine_info.prefer_non_model_filament[g]) {
                    for (int fidx : nozzles_filaments[g]) {
                        if (ctx.model_info.filament_info[used_filaments[fidx]].usage_type == SupportOnly)
                            prefer_level += SUPPORT_PREFER_REWARD;
                    }
                }
            }
 
            // Build full map and evaluate
            std::vector<int> full_map(ctx.group_info.total_filament_num, ctx.machine_info.master_extruder_id);
            for (int i = 0; i < n; ++i)
                full_map[used_filaments[i]] = used_labels[i];
 
            int flush_vol = 0;
            double score = full_evaluate(used_filaments, full_map, ctx, get_custom_seq, &flush_vol);
 
            int master_ex_id = ctx.machine_info.master_extruder_id;
            if (master_ex_id < k && groups_count[master_ex_id] < (int)(used_filaments.size() + 1) / 2)
                score += ABSOLUTE_FLUSH_GAP_TOLERANCE;
 
            if (prefer_level > best_prefer_level || (prefer_level == best_prefer_level && score < best_score)) {
                best_score = score;
                best_prefer_level = prefer_level;
                best_full_map = full_map;
                best_flush = flush_vol;
            }
 
            MemoryedGroup mg(used_labels, score, prefer_level);
            update_memoryed_groups(mg, ctx.group_info.max_gap_threshold, m_memoryed_heap);
        }
 
        if (cost) *cost = best_flush;
        return best_full_map;
    }

References ABSOLUTE_FLUSH_GAP_TOLERANCE, Slic3r::BestFit, ctx, Slic3r::fnv_hash_nozzle(), Slic3r::full_evaluate(), get_custom_seq, Slic3r::GOLDEN_RATIO_32, m_memoryed_heap, Slic3r::SupportOnly, and Slic3r::FilamentGroupUtils::update_memoryed_groups().

Referenced by calc_min_flush_group().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_group_by_kmedoids()

std::vector< int > Slic3r::FilamentGroup::calc_group_by_kmedoids ( int k, const std::vector< unsigned int > & used_filaments, const std::unordered_map< int, std::vector< int > > & unplaceable_limits, int * cost = nullptr )

private

    {
        auto distance_evaluator = std::make_shared<FlushDistanceEvaluator>(ctx.model_info.flush_matrix, used_filaments, ctx.model_info.layer_filaments);
        KMediods PAM(k, (int)used_filaments.size(), distance_evaluator, ctx.machine_info.master_extruder_id);
        PAM.set_unplacable_limits(unplaceable_limits);
        PAM.set_memory_threshold(ctx.group_info.max_gap_threshold);
 
        std::vector<std::pair<std::set<int>, int>> cluster_size_limit;
        for (auto& [extruder_id, nozzles] : ctx.nozzle_info.extruder_nozzle_list) {
            std::pair<std::set<int>, int> clusters;
            clusters.first = std::set<int>(nozzles.begin(), nozzles.end());
            clusters.second = ctx.machine_info.max_group_size.at(extruder_id);
            cluster_size_limit.emplace_back(clusters);
        }
        PAM.set_cluster_group_size(cluster_size_limit);
 
        PAM.do_clustering(ctx, m_clustering_budget);
 
        m_memoryed_heap = PAM.get_memoryed_groups();
 
        auto labels = PAM.get_cluster_labels();
        std::vector<int> full_map(ctx.group_info.total_filament_num, ctx.machine_info.master_extruder_id);
        for (int i = 0; i < (int)labels.size(); ++i)
            full_map[used_filaments[i]] = labels[i];
 
        if (cost) {
            int flush_vol = 0;
            full_evaluate(used_filaments, full_map, ctx, get_custom_seq, &flush_vol);
            *cost = flush_vol;
        }
 
        return full_map;
    }

References ctx, Slic3r::KMediods::do_clustering(), Slic3r::full_evaluate(), Slic3r::KMediods::get_cluster_labels(), get_custom_seq, Slic3r::KMediods::get_memoryed_groups(), m_clustering_budget, m_memoryed_heap, Slic3r::KMediods::set_cluster_group_size(), Slic3r::KMediods::set_memory_threshold(), and Slic3r::KMediods::set_unplacable_limits().

Referenced by calc_min_flush_group().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_min_flush_group()

std::vector< int > Slic3r::FilamentGroup::calc_min_flush_group ( int * cost = nullptr )

private

    {
        auto used_filaments = collect_sorted_used_filaments(ctx.model_info.layer_filaments);
        int n = (int)used_filaments.size();
        int k = (int)ctx.nozzle_info.nozzle_list.size();
 
        std::unordered_map<int, std::vector<int>> unplaceable_limits;
        extract_unprintable_limit_indices(ctx.model_info.unprintable_filaments, used_filaments, unplaceable_limits);
        unplaceable_limits = rebuild_nozzle_unprintables(used_filaments, unplaceable_limits, ctx.group_info.filament_volume_map);
 
        m_memoryed_heap = MemoryedGroupHeap();
        std::vector<int> result;
 
        long long estimated = estimate_dedup_enum_count(k, n, ctx);
        if (estimated < ENUM_THRESHOLD)
            result = calc_group_by_enum(k, used_filaments, unplaceable_limits, cost);
        else
            result = calc_group_by_kmedoids(k, used_filaments, unplaceable_limits, cost);
 
        change_memoryed_heaps_to_arrays(m_memoryed_heap, ctx.group_info.total_filament_num, used_filaments, m_memoryed_groups);
 
        return result;
    }

References calc_group_by_enum(), calc_group_by_kmedoids(), Slic3r::change_memoryed_heaps_to_arrays(), Slic3r::collect_sorted_used_filaments(), ctx, Slic3r::ENUM_THRESHOLD, Slic3r::estimate_dedup_enum_count(), Slic3r::FilamentGroupUtils::extract_unprintable_limit_indices(), m_memoryed_groups, m_memoryed_heap, and rebuild_nozzle_unprintables().

Referenced by calc_filament_group_for_flush().

Here is the call graph for this function:

Here is the caller graph for this function:

get_memoryed_groups()

std::vector< std::vector< int > > Slic3r::FilamentGroup::get_memoryed_groups ( ) const

inline

{ return m_memoryed_groups; }

References m_memoryed_groups.

rebuild_context()

void Slic3r::FilamentGroup::rebuild_context ( const std::unordered_map< int, std::vector< int > > & merged_filaments )

private

    {
        if (merged_filaments.empty())
            return;
 
        FilamentGroupContext new_ctx = ctx;
 
        std::unordered_map<int, int> filament_merge_map = get_merged_filament_map(merged_filaments);
 
        // modify layer filaments
        for (auto& layer_filament : new_ctx.model_info.layer_filaments) {
            for (auto& f : layer_filament) {
                if (auto iter = filament_merge_map.find((int)(f)); iter != filament_merge_map.end()) {
                    f = iter->second;
                }
            }
        }
 
        for (auto& unprintables : new_ctx.model_info.unprintable_filaments) {
            std::set<int> new_unprintables;
            for (auto f : unprintables) {
                if (auto iter = filament_merge_map.find((int)(f)); iter != filament_merge_map.end()) {
                    new_unprintables.insert(iter->second);
                }
                else {
                    new_unprintables.insert(f);
                }
            }
        }
 
        ctx = new_ctx;
        return;
    }

References ctx, Slic3r::f(), Slic3r::get_merged_filament_map(), Slic3r::FilamentGroupContext::ModelInfo::layer_filaments, Slic3r::FilamentGroupContext::model_info, and Slic3r::FilamentGroupContext::ModelInfo::unprintable_filaments.

Here is the call graph for this function:

rebuild_nozzle_unprintables()

std::unordered_map< int, std::vector< int > > Slic3r::FilamentGroup::rebuild_nozzle_unprintables ( const std::vector< unsigned int > & used_filaments, const std::unordered_map< int, std::vector< int > > & extruder_unprintables, const std::vector< int > & filament_volume_map )

private

    {
        std::unordered_map<int, std::vector<int>> nozzle_unprintables;
 
        for(size_t fidx = 0 ;fidx<used_filaments.size(); ++fidx){
            NozzleVolumeType expected_volume = NozzleVolumeType(filament_volume_map[used_filaments[fidx]]);
            std::vector<int> unexpected_extruders;
            if(extruder_unprintables.find(fidx) != extruder_unprintables.end()){
                unexpected_extruders = extruder_unprintables.at(fidx);
            }
 
            auto unprintable_volumes = ctx.model_info.unprintable_volumes[used_filaments[fidx]];
 
            std::vector<int> unprintable_nozzles;
            for(size_t nozzle_idx =0 ;nozzle_idx < ctx.nozzle_info.nozzle_list.size(); ++nozzle_idx){
                auto nozzle_info = ctx.nozzle_info.nozzle_list[nozzle_idx];
 
                if(std::find(unexpected_extruders.begin(), unexpected_extruders.end(), nozzle_info.extruder_id)!= unexpected_extruders.end() || (expected_volume!=nvtHybrid && expected_volume != nozzle_info.volume_type) ||
                  (unprintable_volumes.count(nozzle_info.volume_type) != 0))
                    unprintable_nozzles.push_back(nozzle_idx);
            }
            if(unprintable_nozzles.empty())
                continue;
 
            sort_remove_duplicates(unprintable_nozzles);
            nozzle_unprintables[fidx] = unprintable_nozzles;
        }
 
        return nozzle_unprintables;
    }

References ctx, Slic3r::nvtHybrid, and Slic3r::sort_remove_duplicates().

Referenced by calc_min_flush_group().

Here is the call graph for this function:

Here is the caller graph for this function:

rebuild_unprintables()

std::map< int, int > Slic3r::FilamentGroup::rebuild_unprintables ( const std::vector< unsigned int > & used_filaments, const std::map< int, int > & extruder_unprintables )

private

    {
        std::map<int, int> ret;
        for (int f_idx = 0; f_idx < used_filaments.size(); f_idx++) {
            int unprintable_ext = -1;
            if (extruder_unprintables.find(f_idx) != extruder_unprintables.end()) {
                unprintable_ext = extruder_unprintables.at(f_idx);
            }
 
            bool multi_unprintable = false;
            auto unprintable_volumes = ctx.model_info.unprintable_volumes[used_filaments[f_idx]];
            for (int nozzle_idx = 0; nozzle_idx != ctx.nozzle_info.nozzle_list.size(); nozzle_idx++) {
                auto nozzle_info = ctx.nozzle_info.nozzle_list[nozzle_idx];
 
                if (unprintable_volumes.count(nozzle_info.volume_type)) {
                    if (unprintable_ext == -1)
                        unprintable_ext = nozzle_info.extruder_id;
                    else if (unprintable_ext != nozzle_info.extruder_id)
                        multi_unprintable = true;
                }
            }
 
            if (!multi_unprintable && unprintable_ext != -1) ret[f_idx] = unprintable_ext;
 
        }
        return ret;
    }

References ctx.

Referenced by calc_filament_group_for_match(), and calc_filament_group_for_tpu().

Here is the caller graph for this function:

seperate_merged_filaments()

std::vector< int > Slic3r::FilamentGroup::seperate_merged_filaments ( const std::vector< int > & filament_map, const std::unordered_map< int, std::vector< int > > & merged_filaments )

private

    {
        std::vector<int> ret_map = filament_map;
        for (auto& elem : merged_filaments) {
            int src = elem.first;
            for (auto f : elem.second) {
                ret_map[f] = ret_map[src];
            }
        }
        return ret_map;
    }

References Slic3r::f(), and Slic3r::filament_map().

Here is the call graph for this function:

set_clustering_budget()

void Slic3r::FilamentGroup::set_clustering_budget ( const ClusteringBudget & budget )

inline

{ m_clustering_budget = budget; }

References m_clustering_budget.

try_merge_filaments()

std::unordered_map< int, std::vector< int > > Slic3r::FilamentGroup::try_merge_filaments ( )

private

    {
        std::unordered_map<int, std::vector<int>>merged_filaments;
 
        std::unordered_map<std::string, std::vector<int>> merge_filament_map;
 
        auto unprintable_stat_to_str = [unprintable_filaments = this->ctx.model_info.unprintable_filaments](int idx) {
            std::string str;
            for (size_t eid = 0; eid < unprintable_filaments.size(); ++eid) {
                if (unprintable_filaments[eid].count(idx)) {
                    if (eid > 0)
                        str += ',';
                    str += std::to_string(idx);
                }
            }
            return str;
            };
 
        for (size_t idx = 0; idx < ctx.model_info.filament_ids.size(); ++idx) {
            std::string id = ctx.model_info.filament_ids[idx];
            Color color = ctx.model_info.filament_info[idx].color;
            std::string unprintable_str = unprintable_stat_to_str(idx);
 
            std::string key = id + "," + color.to_hex_str(true) + "," + unprintable_str;
            merge_filament_map[key].push_back(idx);
        }
 
        for (auto& elem : merge_filament_map) {
            if (elem.second.size() > 1) {
                merged_filaments[elem.second.front()] = elem.second;
            }
        }
        return merged_filaments;
    }

References count, ctx, Slic3r::FilamentGroupContext::model_info, Slic3r::FilamentGroupUtils::Color::to_hex_str(), and Slic3r::FilamentGroupContext::ModelInfo::unprintable_filaments.

Here is the call graph for this function:

Member Data Documentation

ctx

FilamentGroupContext Slic3r::FilamentGroup::ctx

private

Referenced by FilamentGroup(), calc_filament_group(), calc_filament_group_for_flush(), calc_filament_group_for_match(), calc_filament_group_for_tpu(), calc_group_by_enum(), calc_group_by_kmedoids(), calc_min_flush_group(), rebuild_context(), rebuild_nozzle_unprintables(), rebuild_unprintables(), and try_merge_filaments().

get_custom_seq

std::optional<std::function<bool(int, std::vector<int>&)> > Slic3r::FilamentGroup::get_custom_seq

Referenced by calc_group_by_enum(), calc_group_by_kmedoids(), and Slic3r::ToolOrdering::get_recommended_filament_maps().

m_clustering_budget

ClusteringBudget Slic3r::FilamentGroup::m_clustering_budget

private

Referenced by calc_group_by_kmedoids(), and set_clustering_budget().

m_memoryed_groups

std::vector<std::vector<int> > Slic3r::FilamentGroup::m_memoryed_groups

private

Referenced by calc_filament_group_for_flush(), calc_min_flush_group(), and get_memoryed_groups().

m_memoryed_heap

MemoryedGroupHeap Slic3r::FilamentGroup::m_memoryed_heap

private

Referenced by calc_group_by_enum(), calc_group_by_kmedoids(), and calc_min_flush_group().

---

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

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