Slic3r::FilamentGroupUtils Namespace Reference

Classes
struct	FlushTimeMachine
struct	MemoryedGroup
struct	Color
struct	FilamentInfo
struct	MachineFilamentInfo
class	FilamentGroupException

Typedefs
using	MemoryedGroupHeap = std::priority_queue<MemoryedGroup, std::vector<MemoryedGroup>, std::greater<MemoryedGroup>>

Functions
void	update_memoryed_groups (const MemoryedGroup &item, const double gap_threshold, MemoryedGroupHeap &groups)
std::vector< int >	calc_max_group_size (const std::vector< std::map< int, int > > &ams_counts, bool ignore_ext_filament)
static std::vector< std::vector< MachineFilamentInfo > >	build_full_machine_filaments (const std::vector< std::vector< DynamicPrintConfig > > &filament_configs)
std::vector< std::vector< MachineFilamentInfo > >	build_machine_filaments (const std::vector< std::vector< DynamicPrintConfig > > &filament_configs, const std::vector< std::map< int, int > > &ams_counts, bool ignore_ext_filament)
bool	collect_unprintable_limits (const std::vector< std::set< int > > &physical_unprintables, const std::vector< std::set< int > > &geometric_unprintables, std::vector< std::set< int > > &unprintable_limits)
bool	remove_intersection (std::set< int > &a, std::set< int > &b)
void	extract_indices (const std::vector< unsigned int > &used_filaments, const std::vector< std::set< int > > &unprintable_elems, std::vector< std::set< int > > &unprintable_idxs)
void	extract_unprintable_limit_indices (const std::vector< std::set< int > > &unprintable_elems, const std::vector< unsigned int > &used_filaments, std::map< int, int > &unplaceable_limits)
void	extract_unprintable_limit_indices (const std::vector< std::set< int > > &unprintable_elems, const std::vector< unsigned int > &used_filaments, std::unordered_map< int, std::vector< int > > &unplaceable_limits)
bool	check_printable (const std::vector< std::set< int > > &groups, const std::map< int, int > &unprintable)
int	get_estimate_extruder_change_count (const std::vector< std::vector< unsigned int > > &layer_filaments, const MultiNozzleUtils::LayeredNozzleGroupResult &extruder_nozzle_info)
int	get_estimate_nozzle_change_count (const std::vector< std::vector< unsigned int > > &layer_filaments, const MultiNozzleUtils::LayeredNozzleGroupResult &extruder_nozzle_info)
std::pair< int, int >	get_estimate_extruder_filament_change_count (const MultiNozzleUtils::LayeredNozzleGroupResult &extruder_nozzle_info)
std::map< int, std::vector< int > >	build_extruder_nozzle_list (const std::vector< MultiNozzleUtils::NozzleInfo > &nozzle_list)
std::vector< int >	update_used_filament_values (const std::vector< int > &old_values, const std::vector< int > &new_values, const std::vector< unsigned int > &used_filaments)

Typedef Documentation

MemoryedGroupHeap

using Slic3r::FilamentGroupUtils::MemoryedGroupHeap = std::priority_queue<MemoryedGroup, std::vector<MemoryedGroup>, std::greater<MemoryedGroup>>

Function Documentation

build_extruder_nozzle_list()

std::map< int, std::vector< int > > Slic3r::FilamentGroupUtils::build_extruder_nozzle_list

(

const std::vector< MultiNozzleUtils::NozzleInfo > &

nozzle_list

)

    {
        std::map<int, std::vector<int>> ret;
        for (auto& nozzle : nozzle_list) {
            ret[nozzle.extruder_id].emplace_back(nozzle.group_id);
        }
 
        for (auto& elem : ret)
            std::sort(elem.second.begin(), elem.second.end());
        return ret;
    }

Referenced by Slic3r::build_filament_group_context().

Here is the caller graph for this function:

build_full_machine_filaments()

std::vector< std::vector< MachineFilamentInfo > > Slic3r::FilamentGroupUtils::build_full_machine_filaments ( const std::vector< std::vector< DynamicPrintConfig > > & filament_configs )

static

    {
        auto extract_filament_type = [](const std::string& s)->std::string {
            std::regex r1(R"(^Sup.(\w+)$)");
            std::regex r2(R"(^(\w+)-S$)");
 
            std::smatch m;
            if (std::regex_match(s, m, r1))
                return m[1].str();
            if (std::regex_match(s, m, r2))
                return m[1].str();
            return s;
            };
 
        // change filament type to type format in preset
        // defualt size set to 2
        std::vector<std::vector<MachineFilamentInfo>> machine_filaments(2);
        for (size_t idx = 0; idx < filament_configs.size(); ++idx) {
            auto& arr = filament_configs[idx];
            for (auto& item : arr) {
                MachineFilamentInfo temp;
                std::string type;
                std::string color;
                std::string tray_name;
                bool is_support_filament = false;
 
                if (auto color_ptr = item.option<ConfigOptionStrings>("filament_colour"); color_ptr)
                    color = color_ptr->get_at(0);
                if (auto type_ptr = item.option<ConfigOptionStrings>("filament_type"); type_ptr) {
                    type = type_ptr->get_at(0);
                    type = extract_filament_type(type);
                }
                if (auto tray_ptr = item.option<ConfigOptionStrings>("tray_name"); tray_ptr)
                    tray_name = tray_ptr->get_at(0);
                if (auto support_ptr = item.option<ConfigOptionBools>("filament_is_support"); support_ptr)
                    is_support_filament = support_ptr->get_at(0);
 
                if (color.empty() || type.empty() || tray_name.empty())
                    continue;
 
                temp.color = Color(color);
                temp.type =type;
                temp.extruder_id = idx;
                temp.is_extended = tray_name == "Ext"; // hard-coded ext flag
                temp.is_support = is_support_filament;
                machine_filaments[idx].emplace_back(std::move(temp));
            }
        }
        return machine_filaments;
    }

References Slic3r::FilamentGroupUtils::FilamentInfo::color, Slic3r::FilamentGroupUtils::MachineFilamentInfo::extruder_id, Slic3r::FilamentGroupUtils::MachineFilamentInfo::is_extended, Slic3r::FilamentGroupUtils::FilamentInfo::is_support, and Slic3r::FilamentGroupUtils::FilamentInfo::type.

Referenced by build_machine_filaments().

Here is the caller graph for this function:

build_machine_filaments()

std::vector< std::vector< MachineFilamentInfo > > Slic3r::FilamentGroupUtils::build_machine_filaments	(	const std::vector< std::vector< DynamicPrintConfig > > &	filament_configs,
		const std::vector< std::map< int, int > > &	ams_counts,
		bool	ignore_ext_filament )

    {
        std::vector<std::vector<MachineFilamentInfo>> ret(2);
        std::vector<int> ams_size(2, 0);
        std::vector<std::vector<MachineFilamentInfo>> full_machine_filaments = build_full_machine_filaments(filament_configs);
        assert(full_machine_filaments.size() == 2);
        for (size_t idx = 0; idx < std::min(ams_counts.size(),ams_size.size()); ++idx) {
            const auto& ams_count = ams_counts[idx];
            for (auto iter = ams_count.begin(); iter != ams_count.end(); ++iter) {
                ams_size[idx] += iter->first * iter->second;
            }
        }
 
        assert(full_machine_filaments.size() == ams_size.size());
        for (size_t idx = 0; idx < std::min(ams_size.size(), full_machine_filaments.size()); ++idx) {
            std::vector<MachineFilamentInfo> tmp;
            for (size_t j = 0; j < full_machine_filaments[idx].size(); ++j) {
                auto& machine_filament = full_machine_filaments[idx][j];
                if (!machine_filament.is_extended)
                    tmp.emplace_back(machine_filament);
            }
 
            // if do not have valid ams filament, try to use ext filament
            if (tmp.empty() && !ignore_ext_filament) {
                for (size_t j = 0; j < full_machine_filaments[idx].size(); ++j) {
                    auto& machine_filament = full_machine_filaments[idx][j];
                    if (machine_filament.is_extended)
                        tmp.emplace_back(machine_filament);
                }
            }
 
            ret[idx] = std::move(tmp);
        }
        return ret;
    }

References build_full_machine_filaments().

Referenced by Slic3r::build_filament_group_context().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_max_group_size()

std::vector< int > Slic3r::FilamentGroupUtils::calc_max_group_size	(	const std::vector< std::map< int, int > > &	ams_counts,
		bool	ignore_ext_filament )

                                                                                                                {
        // add default value to 2
        std::vector<int>group_size(2, 0);
        for (size_t idx = 0; idx < ams_counts.size(); ++idx) {
            const auto& ams_count = ams_counts[idx];
            for (auto iter = ams_count.begin(); iter != ams_count.end(); ++iter) {
                group_size[idx] += iter->first * iter->second;
            }
        }
 
        for (size_t idx = 0; idx < group_size.size(); ++idx) {
            if (!ignore_ext_filament && group_size[idx] == 0)
                group_size[idx] = 1;
        }
        return group_size;
    }

Referenced by Slic3r::build_filament_group_context().

Here is the caller graph for this function:

check_printable()

bool Slic3r::FilamentGroupUtils::check_printable	(	const std::vector< std::set< int > > &	groups,
		const std::map< int, int > &	unprintable )

    {
        for (size_t i = 0; i < groups.size(); ++i) {
            auto& group = groups[i];
            for (auto& filament : group) {
                if (auto iter = unprintable.find(filament); iter != unprintable.end() && i == iter->second)
                    return false;
            }
        }
        return true;
    }

collect_unprintable_limits()

bool Slic3r::FilamentGroupUtils::collect_unprintable_limits	(	const std::vector< std::set< int > > &	physical_unprintables,
		const std::vector< std::set< int > > &	geometric_unprintables,
		std::vector< std::set< int > > &	unprintable_limits )

    {
        unprintable_limits.clear();
        unprintable_limits.resize(2);
        // resize unprintables to 2
        auto resized_physical_unprintables = physical_unprintables;
        resized_physical_unprintables.resize(2);
        auto resized_geometric_unprintables = geometric_unprintables;
        resized_geometric_unprintables.resize(2);
 
        bool conflict = false;
        conflict |= remove_intersection(resized_physical_unprintables[0], resized_physical_unprintables[1]);
        conflict |= remove_intersection(resized_geometric_unprintables[0], resized_geometric_unprintables[1]);
 
        std::map<int, int>filament_unprintable_exts;
        for (auto& ext_unprintables : { resized_physical_unprintables,resized_geometric_unprintables }) {
            for (int eid = 0; eid < ext_unprintables.size(); ++eid) {
                for (int fid : ext_unprintables[eid]) {
                    if (auto iter = filament_unprintable_exts.find(fid); iter != filament_unprintable_exts.end() && iter->second != eid)
                        conflict = true;
                    else
                        filament_unprintable_exts[fid] = eid;
                }
            }
        }
        for (auto& elem : filament_unprintable_exts)
            unprintable_limits[elem.second].insert(elem.first);
 
        return !conflict;
    }

References remove_intersection().

Referenced by Slic3r::build_filament_group_context().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_indices()

void Slic3r::FilamentGroupUtils::extract_indices	(	const std::vector< unsigned int > &	used_filaments,
		const std::vector< std::set< int > > &	unprintable_elems,
		std::vector< std::set< int > > &	unprintable_idxs )

    {
        std::vector<std::set<int>>(unprintable_elems.size()).swap(unprintable_idxs);
        for (size_t gid = 0; gid < unprintable_elems.size(); ++gid) {
            for (auto& f : unprintable_elems[gid]) {
                auto iter = std::find(used_filaments.begin(), used_filaments.end(), (unsigned)f);
                if (iter != used_filaments.end())
                    unprintable_idxs[gid].insert(iter - used_filaments.begin());
            }
        }
    }

References Slic3r::f().

Referenced by extract_unprintable_limit_indices(), and extract_unprintable_limit_indices().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_unprintable_limit_indices() [1/2]

void Slic3r::FilamentGroupUtils::extract_unprintable_limit_indices	(	const std::vector< std::set< int > > &	unprintable_elems,
		const std::vector< unsigned int > &	used_filaments,
		std::map< int, int > &	unplaceable_limits )

    {
        unplaceable_limits.clear();
        // map the unprintable filaments to idx of used filaments , if not used ,just ignore
        std::vector<std::set<int>> unprintable_idxs;
        extract_indices(used_filaments, unprintable_elems, unprintable_idxs);
        if (unprintable_idxs.size() > 1)
            remove_intersection(unprintable_idxs[0], unprintable_idxs[1]);
 
        for (size_t idx = 0; idx < unprintable_idxs.size(); ++idx) {
            for (auto f : unprintable_idxs[idx])
                if (unplaceable_limits.count(f) == 0)
                    unplaceable_limits[f] = idx;
        }
    }

References extract_indices(), Slic3r::f(), and remove_intersection().

Referenced by Slic3r::FilamentGroup::calc_filament_group_for_match(), Slic3r::FilamentGroup::calc_filament_group_for_tpu(), and Slic3r::FilamentGroup::calc_min_flush_group().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_unprintable_limit_indices() [2/2]

void Slic3r::FilamentGroupUtils::extract_unprintable_limit_indices	(	const std::vector< std::set< int > > &	unprintable_elems,
		const std::vector< unsigned int > &	used_filaments,
		std::unordered_map< int, std::vector< int > > &	unplaceable_limits )

    {
        unplaceable_limits.clear();
        std::vector<std::set<int>>unprintable_idxs;
        // map the unprintable filaments to idx of used filaments , if not used ,just ignore
        extract_indices(used_filaments, unprintable_elems, unprintable_idxs);
        // remove elems that cannot be printed in both extruder
        if (unprintable_idxs.size() > 1)
            remove_intersection(unprintable_idxs[0], unprintable_idxs[1]);
 
        for (size_t group_id = 0; group_id < unprintable_idxs.size(); ++group_id)
            for (auto f : unprintable_idxs[group_id])
                unplaceable_limits[f].emplace_back(group_id);
 
        for (auto& elem : unplaceable_limits)
            sort_remove_duplicates(elem.second);
    }

References extract_indices(), Slic3r::f(), Slic3r::group_id(), remove_intersection(), and Slic3r::sort_remove_duplicates().

Here is the call graph for this function:

get_estimate_extruder_change_count()

int Slic3r::FilamentGroupUtils::get_estimate_extruder_change_count	(	const std::vector< std::vector< unsigned int > > &	layer_filaments,
		const MultiNozzleUtils::LayeredNozzleGroupResult &	extruder_nozzle_info )

    {
        int ret = 0;
        for (size_t layer_id = 0; layer_id < layer_filaments.size(); ++layer_id) {
            int extruder_count = extruder_nozzle_info.get_used_extruders(layer_id).size();
            ret += (extruder_count - 1);
        }
        return ret;
    }

References Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_used_extruders().

Here is the call graph for this function:

get_estimate_extruder_filament_change_count()

std::pair< int, int > Slic3r::FilamentGroupUtils::get_estimate_extruder_filament_change_count

(

const MultiNozzleUtils::LayeredNozzleGroupResult &

extruder_nozzle_info

)

    {
        std::pair<int, int> ret{0,0};
        int                 layer_nums = extruder_nozzle_info.get_layer_filament_sequences().size();
        for (int layer_id = 0; layer_id < layer_nums; layer_id++) {
            std::vector<int> extruders = extruder_nozzle_info.get_used_extruders(layer_id);
            ret.first = extruders.size() - 1;
 
            for (auto ext_id : extruders) {
                int nozzles = extruder_nozzle_info.get_used_nozzles_in_extruder(ext_id, layer_id).size();
                ret.second += nozzles;
            }
            ret.second  = std::max(0, ret.second - ret.first);
        }
        return ret;
    }

References Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_layer_filament_sequences(), Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_used_extruders(), and Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_used_nozzles_in_extruder().

Here is the call graph for this function:

get_estimate_nozzle_change_count()

int Slic3r::FilamentGroupUtils::get_estimate_nozzle_change_count	(	const std::vector< std::vector< unsigned int > > &	layer_filaments,
		const MultiNozzleUtils::LayeredNozzleGroupResult &	extruder_nozzle_info )

    {
        int ret = 0;
        for (size_t layer_id = 0; layer_id < layer_filaments.size(); ++layer_id) {
            auto  extruder_list = extruder_nozzle_info.get_used_extruders(layer_id);
            for (auto extruder_id : extruder_list) {
                int nozzle_count = extruder_nozzle_info.get_used_nozzles_in_extruder(extruder_id, layer_id).size();
                if (nozzle_count > 1) ret += (nozzle_count - 1);
            }
        }
        return ret;
    }

References Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_used_extruders(), and Slic3r::MultiNozzleUtils::LayeredNozzleGroupResult::get_used_nozzles_in_extruder().

Here is the call graph for this function:

remove_intersection()

bool Slic3r::FilamentGroupUtils::remove_intersection	(	std::set< int > &	a,
		std::set< int > &	b )

                                                             {
        std::vector<int>intersection;
        std::set_intersection(a.begin(), a.end(), b.begin(), b.end(), std::back_inserter(intersection));
        bool have_intersection = !intersection.empty();
        for (auto& item : intersection) {
            a.erase(item);
            b.erase(item);
        }
        return have_intersection;
    }

References Slic3r::intersection().

Referenced by Slic3r::can_swap_extruder_groups(), collect_unprintable_limits(), extract_unprintable_limit_indices(), and extract_unprintable_limit_indices().

Here is the call graph for this function:

Here is the caller graph for this function:

update_memoryed_groups()

void Slic3r::FilamentGroupUtils::update_memoryed_groups	(	const MemoryedGroup &	item,
		const double	gap_threshold,
		MemoryedGroupHeap &	groups )

    {
        auto emplace_if_accepatle = [gap_threshold](MemoryedGroupHeap& heap, const MemoryedGroup& elem, const MemoryedGroup& best) {
            if (best.cost == 0) {
                if (std::abs(elem.cost - best.cost) <= ABSOLUTE_FLUSH_GAP_TOLERANCE)
                    heap.push(elem);
                return;
            }
            double gap_rate = (double)std::abs(elem.cost - best.cost) / (double)best.cost;
            if (gap_rate <= gap_threshold)
                heap.push(elem);
            };
 
        if (groups.empty()) {
            groups.push(item);
        }
        else {
            auto top = groups.top();
            // we only memory items with the highest prefer level
            if (top.prefer_level > item.prefer_level)
                return;
            else if (top.prefer_level == item.prefer_level) {
                if (top.cost <= item.cost) {
                    emplace_if_accepatle(groups, item, top);
                }
                // find a group with lower cost, rebuild the heap
                else {
                    MemoryedGroupHeap new_heap;
                    new_heap.push(item);
                    while (!groups.empty()) {
                        auto top = groups.top();
                        groups.pop();
                        emplace_if_accepatle(new_heap, top, item);
                    }
                    groups = std::move(new_heap);
                }
            }
            // find a group with the higher prefer level, rebuild the heap
            else {
                groups = MemoryedGroupHeap();
                groups.push(item);
            }
        }
    }

References ABSOLUTE_FLUSH_GAP_TOLERANCE, Slic3r::FilamentGroupUtils::MemoryedGroup::cost, and Slic3r::FilamentGroupUtils::MemoryedGroup::prefer_level.

Referenced by Slic3r::FilamentGroup::calc_group_by_enum(), and Slic3r::KMediods::do_clustering().

Here is the caller graph for this function:

update_used_filament_values()

std::vector< int > Slic3r::FilamentGroupUtils::update_used_filament_values	(	const std::vector< int > &	old_values,
		const std::vector< int > &	new_values,
		const std::vector< unsigned int > &	used_filaments )

    {
        std::vector<int> res = old_values;
        for (size_t i = 0; i < used_filaments.size(); ++i) {
            // Orca: guard against filament ids beyond the map sizes (possible with
            // mis-normalized per-filament arrays from CLI inputs); skip instead of UB.
            if (used_filaments[i] >= res.size() || used_filaments[i] >= new_values.size())
                continue;
            res[used_filaments[i]] = new_values[used_filaments[i]];
        }
        return res;
    }

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

Here is the caller graph for this function: