From 414a2105c9d77bbf7771bdf3fdec40d96dc949c2 Mon Sep 17 00:00:00 2001 From: "xun.zhang" Date: Wed, 27 Nov 2024 10:13:28 +0800 Subject: [PATCH] ENH: refactor filament group 1.Seperate min flush max flow solver 2.Add "best match" mode for filament map 3.Refine code strucuture jira:NONE Signed-off-by: xun.zhang Change-Id: If4ba09a0320366b862cec59f8ed1f22c392c53b9 --- src/libslic3r/CMakeLists.txt | 2 + src/libslic3r/FilamentGroup.cpp | 398 ++++++++++++++----------- src/libslic3r/FilamentGroup.hpp | 66 ++-- src/libslic3r/FilamentGroupUtils.cpp | 167 +++++++++++ src/libslic3r/FilamentGroupUtils.hpp | 80 +++++ src/libslic3r/GCode/ToolOrderUtils.cpp | 325 +++++++++++++------- src/libslic3r/GCode/ToolOrderUtils.hpp | 82 +++-- src/libslic3r/GCode/ToolOrdering.cpp | 91 +++--- 8 files changed, 829 insertions(+), 382 deletions(-) create mode 100644 src/libslic3r/FilamentGroupUtils.cpp create mode 100644 src/libslic3r/FilamentGroupUtils.hpp diff --git a/src/libslic3r/CMakeLists.txt b/src/libslic3r/CMakeLists.txt index e661c5bc9..33045824a 100644 --- a/src/libslic3r/CMakeLists.txt +++ b/src/libslic3r/CMakeLists.txt @@ -434,6 +434,8 @@ set(lisbslic3r_sources FlushVolPredictor.cpp FilamentGroup.hpp FilamentGroup.cpp + FilamentGroupUtils.hpp + FilamentGroupUtils.cpp GCode/ToolOrderUtils.hpp GCode/ToolOrderUtils.cpp FlushVolPredictor.hpp diff --git a/src/libslic3r/FilamentGroup.cpp b/src/libslic3r/FilamentGroup.cpp index 5a7d461ac..763da616f 100644 --- a/src/libslic3r/FilamentGroup.cpp +++ b/src/libslic3r/FilamentGroup.cpp @@ -8,54 +8,9 @@ namespace Slic3r { - static void remove_intersection(std::set& a, std::set& b) { - std::vectorintersection; - std::set_intersection(a.begin(), a.end(), b.begin(), b.end(), std::back_inserter(intersection)); - for (auto& item : intersection) { - a.erase(item); - b.erase(item); - } - } - - static bool extract_indices(const std::vector& used_filaments, const std::vector>& physical_unprintable_elems, const std::vector>& geometric_unprintable_elems, - std::vector>& physical_unprintable_idxs, std::vector>& geometric_unprintable_idxs) - { - assert(physical_unprintable_elems.size() == geometric_unprintable_elems.size()); - std::vector>(physical_unprintable_elems.size()).swap(physical_unprintable_idxs); - std::vector>(geometric_unprintable_elems.size()).swap(geometric_unprintable_idxs); - - for (size_t gid = 0; gid < physical_unprintable_elems.size(); ++gid) { - for (auto& f : physical_unprintable_elems[gid]) { - auto iter = std::find(used_filaments.begin(), used_filaments.end(), (unsigned)f); - if (iter != used_filaments.end()) - physical_unprintable_idxs[gid].insert(iter - used_filaments.begin()); - } - } - - for (size_t gid = 0; gid < geometric_unprintable_elems.size(); ++gid) { - for (auto& f : geometric_unprintable_elems[gid]) { - auto iter = std::find(used_filaments.begin(), used_filaments.end(), (unsigned)f); - if (iter != used_filaments.end()) - geometric_unprintable_idxs[gid].insert(iter - used_filaments.begin()); - } - } - return true; - } - - static bool check_printable(const std::vector>& groups, const std::map& 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; - } - + using namespace FilamentGroupUtils; // clear the array and heap,save the groups in heap to the array - static void change_memoryed_heaps_to_arrays(FilamentGroupUtils::MemoryedGroupHeap& heap,const int total_filament_num,const std::vector& used_filaments, std::vector>& arrs) + static void change_memoryed_heaps_to_arrays(MemoryedGroupHeap& heap,const int total_filament_num,const std::vector& used_filaments, std::vector>& arrs) { // switch the label idx arrs.clear(); @@ -69,49 +24,33 @@ namespace Slic3r } } - Color::Color(const std::string& hexstr) { - if (hexstr.empty() || (hexstr.length() != 9 && hexstr.length() != 7) || hexstr[0] != '#') - { - assert(false); - r = 0, g = 0, b = 0, a = 255; - return; + std::vector calc_filament_group_for_tpu(const std::set& tpu_filaments, const int filament_nums, const int master_extruder_id) + { + std::vector ret(filament_nums); + for (size_t fidx = 0; fidx < filament_nums; ++fidx) { + if (tpu_filaments.count(fidx)) + ret[fidx] = master_extruder_id; + else + ret[fidx] = 1 - master_extruder_id; } - - auto hexToByte = [](const std::string& hex)->unsigned char - { - unsigned int byte; - std::istringstream(hex) >> std::hex >> byte; - return static_cast(byte); - }; - r = hexToByte(hexstr.substr(1, 2)); - g = hexToByte(hexstr.substr(3, 2)); - b = hexToByte(hexstr.substr(5, 2)); - if (hexstr.size() == 9) - a = hexToByte(hexstr.substr(7, 2)); + return ret; } bool can_swap_groups(const int extruder_id_0, const std::set& group_0, const int extruder_id_1, const std::set& group_1, const FilamentGroupContext& ctx) { std::vector>extruder_unprintables(2); { - std::vector> physical_unprintables = ctx.physical_unprintables; - std::vector> geometric_unprintables = ctx.geometric_unprintables; - remove_intersection(physical_unprintables[0], physical_unprintables[1]); - remove_intersection(geometric_unprintables[0], geometric_unprintables[1]); - std::map>unplaceable_limts; - for (auto& unprintables : { physical_unprintables,geometric_unprintables }) { - for (auto& group_id : { extruder_id_0,extruder_id_1 }) { - for (auto f : unprintables[group_id]) { - // TODO: xcr: check whether group_id has been inside the vector ? - if (unplaceable_limts.count(f) == 0) - unplaceable_limts[f].emplace_back(group_id); - } - } - } + std::vector> unprintable_filaments = ctx.model_info.unprintable_filaments; + if (unprintable_filaments.size() > 1) + remove_intersection(unprintable_filaments[0], unprintable_filaments[1]); - for (auto& elem : unplaceable_limts) { + std::map>unplaceable_limts; + for (auto& group_id : { extruder_id_0,extruder_id_1 }) + for (auto f : unprintable_filaments[group_id]) + unplaceable_limts[f].emplace_back(group_id); + + for (auto& elem : unplaceable_limts) sort_remove_duplicates(elem.second); - } for (auto& elem : unplaceable_limts) { for (auto& eid : elem.second) { @@ -137,7 +76,7 @@ namespace Slic3r } // check extruder capacity ,if result before exchange meets the constraints and the result after exchange does not meet the constraints, return false - if (ctx.max_group_size[extruder_id_0] >= group_0.size() && ctx.max_group_size[extruder_id_1] >= group_1.size() && (ctx.max_group_size[extruder_id_0] < group_1.size() || ctx.max_group_size[extruder_id_1] < group_0.size())) + if (ctx.machine_info.max_group_size[extruder_id_0] >= group_0.size() && ctx.machine_info.max_group_size[extruder_id_1] >= group_1.size() && (ctx.machine_info.max_group_size[extruder_id_0] < group_1.size() || ctx.machine_info.max_group_size[extruder_id_1] < group_0.size())) return false; return true; @@ -154,14 +93,14 @@ namespace Slic3r groups[group_id].insert(filament_id); } - int none_master_extruder_id = 1 - ctx.master_extruder_id; + int none_master_extruder_id = 1 - ctx.machine_info.master_extruder_id; assert(0 <= none_master_extruder_id && none_master_extruder_id <= 1); - if (can_swap_groups(none_master_extruder_id, groups[none_master_extruder_id], ctx.master_extruder_id, groups[ctx.master_extruder_id], ctx) - && groups[none_master_extruder_id].size()>groups[ctx.master_extruder_id].size()) { + if (can_swap_groups(none_master_extruder_id, groups[none_master_extruder_id], ctx.machine_info.master_extruder_id, groups[ctx.machine_info.master_extruder_id], ctx) + && groups[none_master_extruder_id].size()>groups[ctx.machine_info.master_extruder_id].size()) { for (auto fid : groups[none_master_extruder_id]) - filament_map[fid] = ctx.master_extruder_id; - for (auto fid : groups[ctx.master_extruder_id]) + filament_map[fid] = ctx.machine_info.master_extruder_id; + for (auto fid : groups[ctx.machine_info.master_extruder_id]) filament_map[fid] = none_master_extruder_id; return true; } @@ -177,28 +116,25 @@ namespace Slic3r * * @param map_lists Group list with similar flush count * @param used_filaments Idx of used filaments - * @param used_filament_colors_str Colors of used filaments - * @param ams_filament_colors_str Colors of filaments in AMS,should have same size with extruder + * @param used_filament_colors_ Colors of used filaments + * @param ams_filament_colors_ colors of filaments in AMS,should have same size with extruder * @param color_threshold Threshold for considering colors to be similar * @return The group that best fits the filament distribution in AMS */ - std::vector select_best_group_for_ams(const std::vector>& map_lists, const std::vector& used_filaments, const std::vector& used_filament_colors_str, const std::vector>& ams_filament_colors_str,const double color_threshold) + std::vector select_best_group_for_ams(const std::vector>& map_lists, const std::vector& used_filaments, const std::vector& used_filament_colors_, const std::vector>& ams_filament_colors_,const double color_threshold) { using namespace FlushPredict; - // change the color str to real colors std::vectorused_filament_colors; std::vector>ams_filament_colors(2); - for (auto& item : used_filament_colors_str) - used_filament_colors.emplace_back(Color(item)); + for (auto& item : used_filament_colors_) + used_filament_colors.emplace_back(item); const double ams_color_dist_threshold = used_filaments.size() * color_threshold; - for (size_t idx = 0; idx < ams_filament_colors_str.size(); ++idx) { + for (size_t idx = 0; idx < ams_filament_colors_.size(); ++idx) { std::vector tmp; - for (auto& item : ams_filament_colors_str[idx]) { - if (!item.empty()) - tmp.emplace_back(Color(item)); - } + for (auto& item : ams_filament_colors_[idx]) + tmp.emplace_back(item); ams_filament_colors[idx] = std::move(tmp); } @@ -233,11 +169,11 @@ namespace Slic3r std::vectorl_nodes(group_colors[i].size()), r_nodes(ams_filament_colors[i].size()); std::iota(l_nodes.begin(), l_nodes.end(), 0); std::iota(r_nodes.begin(), r_nodes.end(), 0); - MinCostMaxFlow mcmf(distance_matrix, l_nodes, r_nodes); + GeneralMinCostSolver mcmf(distance_matrix, l_nodes, r_nodes); auto ams_map = mcmf.solve(); for (size_t idx = 0; idx < ams_map.size(); ++idx) { - if (ams_map[idx] == -1) + if (ams_map[idx] == MaxFlowGraph::INVALID_ID) continue; tmp_cost += distance_matrix[idx][ams_map[idx]]; } @@ -463,7 +399,7 @@ namespace Slic3r void KMediods2::do_clustering(const FGStrategy& g_strategy, int timeout_ms) { - FilamentGroupUtils::FlushTimeMachine T; + FlushTimeMachine T; T.time_machine_start(); if (m_elem_count < m_k) { @@ -515,30 +451,186 @@ namespace Slic3r this->m_cluster_labels = best_labels; } - FilamentGroup::FilamentGroup(const FilamentGroupContext& context) + std::vector FilamentGroup::calc_min_flush_group(int* cost) { - assert(context.flush_matrix.size() == 2); - assert(context.flush_matrix.size() == context.max_group_size.size()); - assert(context.max_group_size.size() == context.physical_unprintables.size()); - assert(context.physical_unprintables.size() == context.geometric_unprintables.size()); - - m_context = context; - } - - std::vector FilamentGroup::calc_filament_group(const std::vector>& layer_filaments, const FGStrategy& g_strategy, int* cost) - { - std::vector used_filaments = collect_sorted_used_filaments(layer_filaments); - + auto used_filaments = collect_sorted_used_filaments(ctx.model_info.layer_filaments); int used_filament_num = used_filaments.size(); if (used_filament_num < 10) - return calc_filament_group_by_enum(layer_filaments, used_filaments, g_strategy, cost); + return calc_min_flush_group_by_enum(used_filaments, cost); else - return calc_filament_group_by_pam2(layer_filaments, used_filaments, g_strategy, cost, 500); + return calc_min_flush_group_by_pam2(used_filaments, cost, 500); } + + std::vector FilamentGroup::calc_filament_group(int* cost) + { + try { + if (FGMode::MatchMode == ctx.group_info.mode) + return calc_filament_group_for_match(cost); + } + catch (const FilamentGroupException& e) { + } + return calc_filament_group_for_flush(cost); + } + + std::vector FilamentGroup::calc_filament_group_for_match(int* cost) + { + using namespace FlushPredict; + + auto used_filaments = collect_sorted_used_filaments(ctx.model_info.layer_filaments); + std::vector used_colors; + std::vector used_types; + + for (auto& f : used_filaments) { + used_colors.emplace_back(Color(ctx.model_info.filament_colors[f])); + used_types.emplace_back(ctx.model_info.filament_types[f]); + } + + std::vector machine_filaments; + + for (size_t eid = 0; eid < ctx.machine_info.machine_filament_info.size(); ++eid) { + for (auto& filament : ctx.machine_info.machine_filament_info[eid]) { + if (!ctx.group_info.ignore_ext_filament || !filament.is_extended) { + machine_filaments.emplace_back(filament); + } + } + } + + if (machine_filaments.empty()) + throw FilamentGroupException(FilamentGroupException::EmptyAmsFilaments,"Empty ams filament in For-Match mode."); + + std::map unprintable_limits; // key stores filament idx in used_filament, value stores unprintable extruder + extract_unprintable_limit_indices(ctx.model_info.unprintable_filaments, used_filaments, unprintable_limits); + + auto is_extruder_filament_compatible = [&unprintable_limits](int filament_idx, int extruder_id) { + auto iter = unprintable_limits.find(filament_idx); + if (iter != unprintable_limits.end() && iter->second == extruder_id) + return false; + return true; + }; + + + auto build_unlink_limits = [](const std::vector& l_nodes, const std::vector& r_nodes, const std::function& can_link) { + std::unordered_map> unlink_limits; + for (size_t i = 0; i < l_nodes.size(); ++i) { + std::vector unlink_filaments; + for (size_t j = 0; j < r_nodes.size(); ++j) { + if (!can_link(i, j)) + unlink_filaments.emplace_back(j); + } + if (!unlink_filaments.empty()) + unlink_limits.emplace(i, std::move(unlink_filaments)); + } + return unlink_limits; + }; + + + std::vector> color_dist_matrix(used_colors.size(), std::vector(machine_filaments.size())); + for (size_t i = 0; i < used_colors.size(); ++i) { + for (size_t j = 0; j < machine_filaments.size(); ++j) { + color_dist_matrix[i][j] = calc_color_distance( + RGBColor(used_colors[i].r, used_colors[i].g, used_colors[i].b), + RGBColor(machine_filaments[j].color.r, machine_filaments[j].color.g, machine_filaments[j].color.b) + ); + } + } + + std::vectorl_nodes(used_filaments.size()); + std::vectorr_nodes(machine_filaments.size()); + std::iota(r_nodes.begin(), r_nodes.end(), 0); + std::vectorr_node_capacity(machine_filaments.size(),l_nodes.size()); + + std::vector group(ctx.group_info.total_filament_num, ctx.machine_info.master_extruder_id); + std::vector ungrouped_filaments; + + { + std::iota(l_nodes.begin(), l_nodes.end(), 0); + auto unlink_limits = build_unlink_limits(l_nodes, r_nodes, [&](int lidx, int ridx) { + return used_types[l_nodes[lidx]] == machine_filaments[r_nodes[ridx]].type && + is_extruder_filament_compatible(l_nodes[lidx], machine_filaments[ridx].extruder_id); + }); + + MatchModeGroupSolver s(color_dist_matrix, l_nodes, r_nodes, r_node_capacity, unlink_limits); + auto ret = s.solve(); + for (size_t idx = 0; idx < ret.size(); ++idx) + if (ret[idx] == MaxFlowGraph::INVALID_ID) + ungrouped_filaments.emplace_back(l_nodes[idx]); + else + group[used_filaments[l_nodes[idx]]] = machine_filaments[r_nodes[ret[idx]]].extruder_id; + + for (size_t idx = 0; idx < std::min(ret.size(), l_nodes.size()); ++idx) + l_nodes[idx] = ret[idx]; + } + if (ungrouped_filaments.empty()) + return group; + + { + l_nodes = ungrouped_filaments; + ungrouped_filaments.clear(); + + auto unlink_limits = build_unlink_limits(l_nodes, r_nodes, [&](int lidx, int ridx) { + return is_extruder_filament_compatible(l_nodes[lidx], machine_filaments[ridx].extruder_id); + }); + + MatchModeGroupSolver s(color_dist_matrix, l_nodes, r_nodes, r_node_capacity, unlink_limits); + auto ret = s.solve(); + for (size_t idx = 0; idx < ret.size(); ++idx) { + if (ret[idx] == MaxFlowGraph::INVALID_ID) + ungrouped_filaments.emplace_back(l_nodes[idx]); + else + group[used_filaments[l_nodes[idx]]] = machine_filaments[r_nodes[ret[idx]]].extruder_id; + } + } + if (ungrouped_filaments.empty()) + return group; + + { + l_nodes = ungrouped_filaments; + ungrouped_filaments.clear(); + MatchModeGroupSolver s(color_dist_matrix, l_nodes, r_nodes, r_node_capacity, {}); + auto ret = s.solve(); + 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_filaments[r_nodes[ret[idx]]].extruder_id; + } + } + + return group; + } + + std::vector FilamentGroup::calc_filament_group_for_flush(int* cost) + { + auto used_filaments = collect_sorted_used_filaments(ctx.model_info.layer_filaments); + + std::vector ret = calc_min_flush_group(cost); + + optimize_group_for_master_extruder(used_filaments, ctx, ret); // ignore the return value + + std::vector> memoryed_maps = this->m_memoryed_groups; + memoryed_maps.insert(memoryed_maps.begin(), ret); + + std::vector used_colors; + for (const auto& f : used_filaments) + used_colors.push_back(Color(ctx.model_info.filament_colors[f])); + + std::vector> ams_colors; + for (const auto& filament_info : ctx.machine_info.machine_filament_info) { + ams_colors.emplace_back(); + for (const auto& info : filament_info) + if (!ctx.group_info.ignore_ext_filament || !info.is_extended) + ams_colors.back().push_back(info.color); + } + + ret = select_best_group_for_ams(memoryed_maps, used_filaments, used_colors, ams_colors); + return ret; + } + + // sorted used_filaments - std::vector FilamentGroup::calc_filament_group_by_enum(const std::vector>& layer_filaments, const std::vector& used_filaments, const FGStrategy& g_strategy,int*cost) + std::vector FilamentGroup::calc_min_flush_group_by_enum(const std::vector& used_filaments, int* cost) { static constexpr int UNPLACEABLE_LIMIT_REWARD = 100; // reward value if the group result follows the unprintable limit static constexpr int MAX_SIZE_LIMIT_REWARD = 10; // reward value if the group result follows the max size per extruder @@ -558,25 +650,7 @@ namespace Slic3r }; std::mapunplaceable_limits; - { - // if the filament cannot be placed in both extruder, we just ignore it - std::vector>physical_unprintables = m_context.physical_unprintables; - std::vector>geometric_unprintables = m_context.geometric_unprintables; - // TODO: should we instantly fail here later? - remove_intersection(physical_unprintables[0], physical_unprintables[1]); - remove_intersection(geometric_unprintables[0], geometric_unprintables[1]); - - for (auto& unprintables : { physical_unprintables, geometric_unprintables }) { - for (size_t group_id = 0; group_id < 2; ++group_id) { - for (size_t elem = 0; elem < used_filaments.size(); ++elem) { - for (auto f : unprintables[group_id]) { - if (unplaceable_limits.count(f) == 0) - unplaceable_limits[f] = group_id; - } - } - } - } - } + extract_unprintable_limit_indices(ctx.model_info.unprintable_filaments, used_filaments, unplaceable_limits); int used_filament_num = used_filaments.size(); uint64_t max_group_num = (static_cast(1) << used_filament_num); @@ -598,9 +672,9 @@ namespace Slic3r if (check_printable(groups, unplaceable_limits)) prefer_level += UNPLACEABLE_LIMIT_REWARD; - if (groups[0].size() <= m_context.max_group_size[0] && groups[1].size() <= m_context.max_group_size[1]) + if (groups[0].size() <= ctx.machine_info.max_group_size[0] && groups[1].size() <= ctx.machine_info.max_group_size[1]) prefer_level += MAX_SIZE_LIMIT_REWARD; - if (FGStrategy::BestFit == g_strategy && groups[0].size() >= m_context.max_group_size[0] && groups[1].size() >= m_context.max_group_size[1]) + if (FGStrategy::BestFit == ctx.group_info.strategy && groups[0].size() >= ctx.machine_info.max_group_size[0] && groups[1].size() >= ctx.machine_info.max_group_size[1]) prefer_level += BEST_FIT_LIMIT_REWARD; std::vectorfilament_maps(used_filament_num); @@ -614,8 +688,8 @@ namespace Slic3r int total_cost = reorder_filaments_for_minimum_flush_volume( used_filaments, filament_maps, - layer_filaments, - m_context.flush_matrix, + ctx.model_info.layer_filaments, + ctx.model_info.flush_matrix, get_custom_seq, nullptr ); @@ -627,62 +701,48 @@ namespace Slic3r } { - MemoryedGroup mg(filament_maps,total_cost,prefer_level); - update_memoryed_groups(mg, memory_threshold, memoryed_groups); + MemoryedGroup mg(filament_maps, total_cost, prefer_level); + update_memoryed_groups(mg, ctx.group_info.max_gap_threshold, memoryed_groups); } } if (cost) *cost = best_cost; - std::vector filament_labels(m_context.total_filament_num, 0); + std::vector filament_labels(ctx.group_info.total_filament_num, 0); for (size_t i = 0; i < best_label.size(); ++i) filament_labels[used_filaments[i]] = best_label[i]; - change_memoryed_heaps_to_arrays(memoryed_groups, m_context.total_filament_num, used_filaments, m_memoryed_groups); + change_memoryed_heaps_to_arrays(memoryed_groups, ctx.group_info.total_filament_num, used_filaments, m_memoryed_groups); return filament_labels; } // sorted used_filaments - std::vector FilamentGroup::calc_filament_group_by_pam2(const std::vector>& layer_filaments, const std::vector& used_filaments, const FGStrategy& g_strategy, int*cost,int timeout_ms) + std::vector FilamentGroup::calc_min_flush_group_by_pam2(const std::vector& used_filaments, int* cost, int timeout_ms) { - std::vectorfilament_labels_ret(m_context.total_filament_num, m_context.master_extruder_id); + std::vectorfilament_labels_ret(ctx.group_info.total_filament_num, ctx.machine_info.master_extruder_id); std::mapunplaceable_limits; - { - // map the unprintable filaments to idx of used filaments , if not used ,just ignore - std::vector> physical_unprintable_idxs, geometric_unprintable_idxs; - extract_indices(used_filaments, m_context.physical_unprintables, m_context.geometric_unprintables, physical_unprintable_idxs, geometric_unprintable_idxs); - remove_intersection(physical_unprintable_idxs[0], physical_unprintable_idxs[1]); - remove_intersection(geometric_unprintable_idxs[0], geometric_unprintable_idxs[1]); - for (auto& unprintables : { physical_unprintable_idxs, geometric_unprintable_idxs }) { - for (size_t group_id = 0; group_id < 2; ++group_id) { - for(auto f:unprintables[group_id]){ - if(unplaceable_limits.count(f)==0) - unplaceable_limits[f]=group_id; - } - } - } - } + extract_unprintable_limit_indices(ctx.model_info.unprintable_filaments, used_filaments, unplaceable_limits); - auto distance_evaluator = std::make_shared(m_context.flush_matrix[0], used_filaments, layer_filaments); - KMediods2 PAM((int)used_filaments.size(),distance_evaluator,m_context.master_extruder_id); - PAM.set_max_cluster_size(m_context.max_group_size); + auto distance_evaluator = std::make_shared(ctx.model_info.flush_matrix[0], used_filaments, ctx.model_info.layer_filaments); + KMediods2 PAM((int)used_filaments.size(), distance_evaluator, ctx.machine_info.master_extruder_id); + PAM.set_max_cluster_size(ctx.machine_info.max_group_size); PAM.set_unplaceable_limits(unplaceable_limits); - PAM.set_memory_threshold(memory_threshold); - PAM.do_clustering(g_strategy, timeout_ms); + PAM.set_memory_threshold(ctx.group_info.max_gap_threshold); + PAM.do_clustering(ctx.group_info.strategy, timeout_ms); std::vectorfilament_labels = PAM.get_cluster_labels(); { auto memoryed_groups = PAM.get_memoryed_groups(); - change_memoryed_heaps_to_arrays(memoryed_groups, m_context.total_filament_num, used_filaments, m_memoryed_groups); + change_memoryed_heaps_to_arrays(memoryed_groups, ctx.group_info.total_filament_num, used_filaments, m_memoryed_groups); } - if(cost) - *cost=reorder_filaments_for_minimum_flush_volume(used_filaments,filament_labels,layer_filaments,m_context.flush_matrix,std::nullopt,nullptr); + if (cost) + *cost = reorder_filaments_for_minimum_flush_volume(used_filaments, filament_labels, ctx.model_info.layer_filaments, ctx.model_info.flush_matrix, std::nullopt, nullptr); for (int i = 0; i < filament_labels.size(); ++i) filament_labels_ret[used_filaments[i]] = filament_labels[i]; diff --git a/src/libslic3r/FilamentGroup.hpp b/src/libslic3r/FilamentGroup.hpp index d3a520038..8dc61e64c 100644 --- a/src/libslic3r/FilamentGroup.hpp +++ b/src/libslic3r/FilamentGroup.hpp @@ -9,6 +9,7 @@ #include #include #include "GCode/ToolOrderUtils.hpp" +#include "FilamentGroupUtils.hpp" const static int DEFAULT_CLUSTER_SIZE = 16; @@ -23,14 +24,9 @@ namespace Slic3r BestFit }; - struct Color - { - unsigned char r = 0; - unsigned char g = 0; - unsigned char b = 0; - unsigned char a = 255; - Color(unsigned char r_ = 0, unsigned char g_ = 0, unsigned char b_ = 0, unsigned a_ = 255) :r(r_), g(g_), b(b_), a(a_) {} - Color(const std::string& hexstr); + enum FGMode { + FlushMode, + MatchMode }; namespace FilamentGroupUtils @@ -65,6 +61,7 @@ namespace Slic3r int prefer_level{ 0 }; std::vectorgroup; }; + using MemoryedGroupHeap = std::priority_queue, std::greater>; void update_memoryed_groups(const MemoryedGroup& item,const double gap_threshold, MemoryedGroupHeap& groups); @@ -72,20 +69,38 @@ namespace Slic3r struct FilamentGroupContext { - std::vector flush_matrix; - std::vector>physical_unprintables; - std::vector>geometric_unprintables; - std::vectormax_group_size; - int total_filament_num; - int master_extruder_id; + struct ModelInfo { + std::vector flush_matrix; + std::vector> layer_filaments; + std::vector filament_colors; + std::vector filament_types; + std::vector> unprintable_filaments; + } model_info; + + struct GroupInfo { + int total_filament_num; + double max_gap_threshold; + FGMode mode; + FGStrategy strategy; + bool ignore_ext_filament; //wai gua filament + } group_info; + + struct MachineInfo { + std::vector max_group_size; + std::vector> machine_filament_info; + std::vector, int>> extruder_group_size; + int master_extruder_id; + } machine_info; }; - std::vector select_best_group_for_ams(const std::vector>& map_lists, const std::vector& used_filaments, const std::vector& used_filament_colors, const std::vector>& ams_filament_colros,const double color_delta_threshold = 20); + std::vector select_best_group_for_ams(const std::vector>& map_lists, const std::vector& used_filaments, const std::vector& used_filament_colors_, const std::vector>& ams_filament_colros_,const double color_delta_threshold = 20); bool optimize_group_for_master_extruder(const std::vector& used_filaments, const FilamentGroupContext& ctx, std::vector& filament_map); bool can_swap_groups(const int extruder_id_0, const std::set& group_0, const int extruder_id_1, const std::set& group_1, const FilamentGroupContext& ctx); + std::vector calc_filament_group_for_tpu(const std::set& tpu_filaments, const int filament_nums, const int master_extruder_id); + class FlushDistanceEvaluator { public: @@ -99,19 +114,24 @@ namespace Slic3r class FilamentGroup { - using MemoryedGroupHeap = FilamentGroupUtils::MemoryedGroupHeap; using MemoryedGroup = FilamentGroupUtils::MemoryedGroup; + using MemoryedGroupHeap = FilamentGroupUtils::MemoryedGroupHeap; public: - FilamentGroup(const FilamentGroupContext& context); - std::vector calc_filament_group(const std::vector>& layer_filaments, const FGStrategy& g_strategy = FGStrategy::BestFit, int* cost = nullptr); + explicit FilamentGroup(const FilamentGroupContext& ctx_) :ctx(ctx_) {} public: - std::vector calc_filament_group_by_enum(const std::vector>& layer_filaments, const std::vector& used_filaments, const FGStrategy& g_strategy, int* cost = nullptr); - std::vector calc_filament_group_by_pam2(const std::vector>& layer_filaments, const std::vector& used_filaments, const FGStrategy& g_strategy, int* cost = nullptr, int timeout_ms = 300); - void set_memory_threshold(double threshold) { memory_threshold = threshold; } + std::vector calc_filament_group(int * cost = nullptr); std::vector> get_memoryed_groups()const { return m_memoryed_groups; } + + public: + std::vector calc_filament_group_for_match(int* cost = nullptr); + std::vector calc_filament_group_for_flush(int* cost = nullptr); + private: - FilamentGroupContext m_context; - double memory_threshold{ 0 }; + std::vector calc_min_flush_group(int* cost = nullptr); + std::vector calc_min_flush_group_by_enum(const std::vector& used_filaments, int* cost = nullptr); + std::vector calc_min_flush_group_by_pam2(const std::vector& used_filaments, int* cost = nullptr, int timeout_ms = 300); + private: + FilamentGroupContext ctx; std::vector> m_memoryed_groups; public: diff --git a/src/libslic3r/FilamentGroupUtils.cpp b/src/libslic3r/FilamentGroupUtils.cpp new file mode 100644 index 000000000..261e6908b --- /dev/null +++ b/src/libslic3r/FilamentGroupUtils.cpp @@ -0,0 +1,167 @@ +#include "FilamentGroupUtils.hpp" + + +namespace Slic3r +{ +namespace FilamentGroupUtils +{ + Color::Color(const std::string& hexstr) { + if (hexstr.empty() || (hexstr.length() != 9 && hexstr.length() != 7) || hexstr[0] != '#') + { + assert(false); + r = 0, g = 0, b = 0, a = 255; + return; + } + + auto hexToByte = [](const std::string& hex)->unsigned char + { + unsigned int byte; + std::istringstream(hex) >> std::hex >> byte; + return static_cast(byte); + }; + r = hexToByte(hexstr.substr(1, 2)); + g = hexToByte(hexstr.substr(3, 2)); + b = hexToByte(hexstr.substr(5, 2)); + if (hexstr.size() == 9) + a = hexToByte(hexstr.substr(7, 2)); + } + + // TODO: add explanation + std::vector calc_max_group_size(const std::vector>& ams_counts, bool ignore_ext_filament) { + // add default value to 2 + std::vectorgroup_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; + } + + + std::vector> build_machine_filaments(const std::vector>& filament_configs) + { + // defualt size set to 2 + std::vector> machine_filaments(2); + for (size_t idx = 0; idx < filament_configs.size(); ++idx) { + auto& arr = filament_configs[idx]; + for (auto& item : arr) { + FilamentInfo temp; + temp.color = Color(item.option("filament_colour")->get_at(0)); + temp.type = item.option("filament_type")->get_at(0); + temp.extruder_id = idx; + temp.is_extended = item.option("tray_name")->get_at(0) == "Ext"; // hard-coded ext flag + machine_filaments[idx].emplace_back(std::move(temp)); + } + } + return machine_filaments; + } + + bool collect_unprintable_limits(const std::vector>& physical_unprintables, const std::vector>& geometric_unprintables, std::vector>& 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::mapfilament_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; + } + + bool remove_intersection(std::set& a, std::set& b) { + std::vectorintersection; + 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; + } + + void extract_indices(const std::vector& used_filaments, const std::vector>& unprintable_elems, std::vector>& unprintable_idxs) + { + std::vector>(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()); + } + } + } + + void extract_unprintable_limit_indices(const std::vector>& unprintable_elems, const std::vector& used_filaments, std::map& unplaceable_limits) + { + unplaceable_limits.clear(); + // map the unprintable filaments to idx of used filaments , if not used ,just ignore + std::vector> 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; + } + } + + + void extract_unprintable_limit_indices(const std::vector>& unprintable_elems, const std::vector& used_filaments, std::unordered_map>& unplaceable_limits) + { + unplaceable_limits.clear(); + std::vector>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); + } + + bool check_printable(const std::vector>& groups, const std::map& 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; + } +} +} \ No newline at end of file diff --git a/src/libslic3r/FilamentGroupUtils.hpp b/src/libslic3r/FilamentGroupUtils.hpp new file mode 100644 index 000000000..be3a71601 --- /dev/null +++ b/src/libslic3r/FilamentGroupUtils.hpp @@ -0,0 +1,80 @@ +#ifndef FILAMENT_GROUP_UTILS_HPP +#define FILAMENT_GROUP_UTILS_HPP + +#include +#include +#include +#include + +#include "PrintConfig.hpp" + +namespace Slic3r +{ + namespace FilamentGroupUtils + { + struct Color + { + unsigned char r = 0; + unsigned char g = 0; + unsigned char b = 0; + unsigned char a = 255; + Color(unsigned char r_ = 0, unsigned char g_ = 0, unsigned char b_ = 0, unsigned a_ = 255) :r(r_), g(g_), b(b_), a(a_) {} + Color(const std::string& hexstr); + }; + + + struct FilamentInfo { + Color color; + std::string type; + int extruder_id; + bool is_extended; // TODO: rename + }; + + + class FilamentGroupException: public std::exception { + public: + enum ErrorCode { + EmptyAmsFilaments, + ConflictLimits, + Unknown + }; + + private: + ErrorCode code_; + std::string message_; + + public: + FilamentGroupException(ErrorCode code, const std::string& message) + : code_(code), message_(message) {} + + ErrorCode code() const noexcept { + return code_; + } + + const char* what() const noexcept override { + return message_.c_str(); + } + }; + + std::vector calc_max_group_size(const std::vector>& ams_counts,bool ignore_ext_filament); + + std::vector> build_machine_filaments(const std::vector>& filament_configs); + + bool collect_unprintable_limits(const std::vector>& physical_unprintables, const std::vector>& geometric_unprintables, std::vector>& unprintable_limits); + + bool remove_intersection(std::set& a, std::set& b); + + void extract_indices(const std::vector& used_filaments, const std::vector>& unprintable_elems, std::vector>& unprintable_idxs); + + void extract_unprintable_limit_indices(const std::vector>& unprintable_elems, const std::vector& used_filaments, std::map& unplaceable_limits); + + void extract_unprintable_limit_indices(const std::vector>& unprintable_elems, const std::vector& used_filaments, std::unordered_map>& unplaceable_limits); + + bool check_printable(const std::vector>& groups, const std::map& unprintable); + } + + +} + + +#endif \ No newline at end of file diff --git a/src/libslic3r/GCode/ToolOrderUtils.cpp b/src/libslic3r/GCode/ToolOrderUtils.cpp index 2809be6a0..86f638b03 100644 --- a/src/libslic3r/GCode/ToolOrderUtils.cpp +++ b/src/libslic3r/GCode/ToolOrderUtils.cpp @@ -7,8 +7,119 @@ namespace Slic3r { + struct MinCostMaxFlow { + public: + struct Edge { + int from, to, capacity, cost, flow; + Edge(int u, int v, int cap, int cst) : from(u), to(v), capacity(cap), cost(cst), flow(0) {} + }; - MaxFlow::MaxFlow(const std::vector& u_nodes, const std::vector& v_nodes, + std::vector solve(); + void add_edge(int from, int to, int capacity, int cost); + bool spfa(int source, int sink); + int get_distance(int idx_in_left, int idx_in_right); + + std::vector> matrix; + std::vector l_nodes; + std::vector r_nodes; + std::vector edges; + std::vector> adj; + + int total_nodes{ -1 }; + int source_id{ -1 }; + int sink_id{ -1 }; + }; + + std::vector MinCostMaxFlow::solve() + { + while (spfa(source_id, sink_id)); + + std::vectormatching(l_nodes.size(), MaxFlowGraph::INVALID_ID); + // to get the match info, just traverse the left nodes and + // check the edges with flow > 0 and linked to right nodes + for (int u = 0; u < l_nodes.size(); ++u) { + for (int eid : adj[u]) { + Edge& e = edges[eid]; + if (e.flow > 0 && e.to >= l_nodes.size() && e.to < l_nodes.size() + r_nodes.size()) + matching[e.from] = r_nodes[e.to - l_nodes.size()]; + } + } + + return matching; + } + + void MinCostMaxFlow::add_edge(int from, int to, int capacity, int cost) + { + adj[from].emplace_back(edges.size()); + edges.emplace_back(from, to, capacity, cost); + //also add reverse edge ,set capacity to zero,cost to negative + adj[to].emplace_back(edges.size()); + edges.emplace_back(to, from, 0, -cost); + } + + bool MinCostMaxFlow::spfa(int source, int sink) + { + std::vectordist(total_nodes, MaxFlowGraph::INF); + std::vectorin_queue(total_nodes, false); + std::vectorflow(total_nodes, MaxFlowGraph::INF); + std::vectorprev(total_nodes, 0); + + std::queueq; + q.push(source); + in_queue[source] = true; + dist[source] = 0; + + while (!q.empty()) { + int now_at = q.front(); + q.pop(); + in_queue[now_at] = false; + + for (auto eid : adj[now_at]) //traverse all linked edges + { + Edge& e = edges[eid]; + if (e.flowdist[now_at] + e.cost) { + dist[e.to] = dist[now_at] + e.cost; + prev[e.to] = eid; + flow[e.to] = std::min(flow[now_at], e.capacity - e.flow); + if (!in_queue[e.to]) { + q.push(e.to); + in_queue[e.to] = true; + } + } + } + } + + if (dist[sink] == MaxFlowGraph::INF) + return false; + + int now_at = sink; + while (now_at != source) { + int prev_edge = prev[now_at]; + edges[prev_edge].flow += flow[sink]; + edges[prev_edge ^ 1].flow -= flow[sink]; + now_at = edges[prev_edge].from; + } + + return true; + } + + int MinCostMaxFlow::get_distance(int idx_in_left, int idx_in_right) + { + if (l_nodes[idx_in_left] == -1) { + return 0; + //TODO: test more here + int sum = 0; + for (int i = 0; i < matrix.size(); ++i) + sum += matrix[i][idx_in_right]; + sum /= matrix.size(); + return -sum; + } + + return matrix[l_nodes[idx_in_left]][r_nodes[idx_in_right]]; + } + + + MaxFlowSolver::MaxFlowSolver(const std::vector& u_nodes, const std::vector& v_nodes, const std::unordered_map>& uv_link_limits, const std::unordered_map>& uv_unlink_limits, const std::vector& u_capacity, @@ -58,7 +169,7 @@ namespace Slic3r } } - void MaxFlow::add_edge(int from, int to, int capacity) + void MaxFlowSolver::add_edge(int from, int to, int capacity) { adj[from].emplace_back(edges.size()); edges.emplace_back(from, to, capacity); @@ -67,14 +178,14 @@ namespace Slic3r edges.emplace_back(to, from, 0); } - std::vector MaxFlow::solve() { + std::vector MaxFlowSolver::solve() { std::vector augment; std::vector previous(total_nodes, 0); while (1) { std::vector(total_nodes, 0).swap(augment); std::queue travel; travel.push(source_id); - augment[source_id] = INF; + augment[source_id] = MaxFlowGraph::INF; while (!travel.empty()) { int from = travel.front(); travel.pop(); @@ -104,7 +215,7 @@ namespace Slic3r } } - std::vector matching(l_nodes.size(), -1); + std::vector matching(l_nodes.size(), MaxFlowGraph::INVALID_ID); // to get the match info, just traverse the left nodes and // check the edge with flow > 0 and linked to right nodes for (int u = 0; u < l_nodes.size(); ++u) { @@ -117,7 +228,52 @@ namespace Slic3r return matching; } - MinCostMaxFlow::MinCostMaxFlow(const std::vector>& matrix_, const std::vector& u_nodes, const std::vector& v_nodes, + GeneralMinCostSolver::~GeneralMinCostSolver() + { + } + + GeneralMinCostSolver::GeneralMinCostSolver(const std::vector>& matrix_, const std::vector& u_nodes, const std::vector& v_nodes) + { + m_solver = std::make_unique(); + m_solver->matrix = matrix_;; + m_solver->l_nodes = u_nodes; + m_solver->r_nodes = v_nodes; + + m_solver->total_nodes = u_nodes.size() + v_nodes.size() + 2; + + m_solver->source_id =m_solver->total_nodes - 2; + m_solver->sink_id = m_solver->total_nodes - 1; + + m_solver->adj.resize(m_solver->total_nodes); + + + // add edge from source to left nodes,cost to 0 + for (int i = 0; i < m_solver->l_nodes.size(); ++i) + m_solver->add_edge(m_solver->source_id, i, 1, 0); + + // add edge from right nodes to sink,cost to 0 + for (int i = 0; i < m_solver->r_nodes.size(); ++i) + m_solver->add_edge(m_solver->l_nodes.size() + i, m_solver->sink_id, 1, 0); + + // add edge from left node to right nodes + for (int i = 0; i < m_solver->l_nodes.size(); ++i) { + int from_idx = i; + for (int j = 0; j < m_solver->r_nodes.size(); ++j) { + int to_idx = m_solver->l_nodes.size() + j; + m_solver->add_edge(from_idx, to_idx, 1, m_solver->get_distance(i, j)); + } + } + } + + std::vector GeneralMinCostSolver::solve() { + return m_solver->solve(); + } + + MinFlushFlowSolver::~MinFlushFlowSolver() + { + } + + MinFlushFlowSolver::MinFlushFlowSolver(const std::vector>& matrix_, const std::vector& u_nodes, const std::vector& v_nodes, const std::unordered_map>& uv_link_limits, const std::unordered_map>& uv_unlink_limits, const std::vector& u_capacity, @@ -125,34 +281,35 @@ namespace Slic3r { assert(u_capacity.empty() || u_capacity.size() == u_nodes.size()); assert(v_capacity.empty() || v_capacity.size() == v_nodes.size()); - matrix = matrix_; - l_nodes = u_nodes; - r_nodes = v_nodes; + m_solver = std::make_unique(); + m_solver->matrix = matrix_;; + m_solver->l_nodes = u_nodes; + m_solver->r_nodes = v_nodes; - total_nodes = u_nodes.size() + v_nodes.size() + 2; + m_solver->total_nodes = u_nodes.size() + v_nodes.size() + 2; - source_id = total_nodes - 2; - sink_id = total_nodes - 1; + m_solver->source_id =m_solver->total_nodes - 2; + m_solver->sink_id = m_solver->total_nodes - 1; - adj.resize(total_nodes); + m_solver->adj.resize(m_solver->total_nodes); // add edge from source to left nodes,cost to 0 - for (int i = 0; i < l_nodes.size(); ++i) { + for (int i = 0; i < m_solver->l_nodes.size(); ++i) { int capacity = u_capacity.empty() ? 1 : u_capacity[i]; - add_edge(source_id, i, capacity, 0); + m_solver->add_edge(m_solver->source_id, i, capacity, 0); } // add edge from right nodes to sink,cost to 0 - for (int i = 0; i < r_nodes.size(); ++i) { + for (int i = 0; i < m_solver->r_nodes.size(); ++i) { int capacity = v_capacity.empty() ? 1 : v_capacity[i]; - add_edge(l_nodes.size() + i, sink_id, capacity, 0); + m_solver->add_edge(m_solver->l_nodes.size() + i, m_solver->sink_id, capacity, 0); } // add edge from left node to right nodes - for (int i = 0; i < l_nodes.size(); ++i) { + for (int i = 0; i < m_solver->l_nodes.size(); ++i) { int from_idx = i; // process link limits, i can only link to link_limits if (auto iter = uv_link_limits.find(i); iter != uv_link_limits.end()) { for (auto r_id : iter->second) - add_edge(from_idx, l_nodes.size() + r_id, 1, get_distance(i, r_id)); + m_solver->add_edge(from_idx, m_solver->l_nodes.size() + r_id, 1, m_solver->get_distance(i, r_id)); continue; } @@ -160,100 +317,64 @@ namespace Slic3r std::optional> unlink_limits; if (auto iter = uv_unlink_limits.find(i); iter != uv_unlink_limits.end()) unlink_limits = iter->second; - for (int j = 0; j < r_nodes.size(); ++j) { + for (int j = 0; j < m_solver->r_nodes.size(); ++j) { if (unlink_limits.has_value() && std::find(unlink_limits->begin(), unlink_limits->end(), j) != unlink_limits->end()) continue; - add_edge(from_idx, l_nodes.size() + j, 1, get_distance(i, j)); + m_solver->add_edge(from_idx, m_solver->l_nodes.size() + j, 1, m_solver->get_distance(i, j)); } } } - std::vector MinCostMaxFlow::solve() - { - while (spfa(source_id, sink_id)); + std::vector MinFlushFlowSolver::solve() { + return m_solver->solve(); + } - std::vectormatching(l_nodes.size(), -1); - // to get the match info, just traverse the left nodes and - // check the edges with flow > 0 and linked to right nodes - for (int u = 0; u < l_nodes.size(); ++u) { - for (int eid : adj[u]) { - Edge& e = edges[eid]; - if (e.flow > 0 && e.to >= l_nodes.size() && e.to < l_nodes.size() + r_nodes.size()) - matching[e.from] = r_nodes[e.to - l_nodes.size()]; + MatchModeGroupSolver::~MatchModeGroupSolver() + { + } + + MatchModeGroupSolver::MatchModeGroupSolver(const std::vector>& matrix_, const std::vector& u_nodes, const std::vector& v_nodes, const std::vector& v_capacity, const std::unordered_map>& uv_unlink_limits) + { + assert(v_nodes.size() == v_capacity.size()); + m_solver = std::make_unique(); + m_solver->matrix = matrix_;; + m_solver->l_nodes = u_nodes; + m_solver->r_nodes = v_nodes; + + m_solver->total_nodes = u_nodes.size() + v_nodes.size() + 2; + + m_solver->source_id = m_solver->total_nodes - 2; + m_solver->sink_id = m_solver->total_nodes - 1; + + m_solver->adj.resize(m_solver->total_nodes); + + + // add edge from source to left nodes,cost to 0 + for (int i = 0; i < m_solver->l_nodes.size(); ++i) + m_solver->add_edge(m_solver->source_id, i, 1, 0); + + // add edge from right nodes to sink,cost to 0 + for (int i = 0; i < m_solver->r_nodes.size(); ++i) + m_solver->add_edge(m_solver->l_nodes.size() + i, m_solver->sink_id, v_capacity[i], 0); + + // add edge from left node to right nodes + for (int i = 0; i < m_solver->l_nodes.size(); ++i) { + int from_idx = i; + + // process unlink limits, check whether i can link to j + std::optional> unlink_limits; + if (auto iter = uv_unlink_limits.find(i); iter != uv_unlink_limits.end()) + unlink_limits = iter->second; + for (int j = 0; j < m_solver->r_nodes.size(); ++j) { + if (unlink_limits.has_value() && std::find(unlink_limits->begin(), unlink_limits->end(), j) != unlink_limits->end()) + continue; + m_solver->add_edge(from_idx, m_solver->l_nodes.size() + j, 1, m_solver->get_distance(i, j)); } } - - return matching; } - void MinCostMaxFlow::add_edge(int from, int to, int capacity, int cost) - { - adj[from].emplace_back(edges.size()); - edges.emplace_back(from, to, capacity, cost); - //also add reverse edge ,set capacity to zero,cost to negative - adj[to].emplace_back(edges.size()); - edges.emplace_back(to, from, 0, -cost); - } - - bool MinCostMaxFlow::spfa(int source, int sink) - { - std::vectordist(total_nodes, INF); - std::vectorin_queue(total_nodes, false); - std::vectorflow(total_nodes, INF); - std::vectorprev(total_nodes, 0); - - std::queueq; - q.push(source); - in_queue[source] = true; - dist[source] = 0; - - while (!q.empty()) { - int now_at = q.front(); - q.pop(); - in_queue[now_at] = false; - - for (auto eid : adj[now_at]) //traverse all linked edges - { - Edge& e = edges[eid]; - if (e.flowdist[now_at] + e.cost) { - dist[e.to] = dist[now_at] + e.cost; - prev[e.to] = eid; - flow[e.to] = std::min(flow[now_at], e.capacity - e.flow); - if (!in_queue[e.to]) { - q.push(e.to); - in_queue[e.to] = true; - } - } - } - } - - if (dist[sink] == INF) - return false; - - int now_at = sink; - while (now_at != source) { - int prev_edge = prev[now_at]; - edges[prev_edge].flow += flow[sink]; - edges[prev_edge ^ 1].flow -= flow[sink]; - now_at = edges[prev_edge].from; - } - - return true; - } - - int MinCostMaxFlow::get_distance(int idx_in_left, int idx_in_right) - { - if (l_nodes[idx_in_left] == -1) { - return 0; - //TODO: test more here - int sum = 0; - for (int i = 0; i < matrix.size(); ++i) - sum += matrix[i][idx_in_right]; - sum /= matrix.size(); - return -sum; - } - - return matrix[l_nodes[idx_in_left]][r_nodes[idx_in_right]]; + std::vector MatchModeGroupSolver::solve() { + return m_solver->solve(); } //solve the problem by searching the least flush of current filament diff --git a/src/libslic3r/GCode/ToolOrderUtils.hpp b/src/libslic3r/GCode/ToolOrderUtils.hpp index d66d03e4e..a2da86b0d 100644 --- a/src/libslic3r/GCode/ToolOrderUtils.hpp +++ b/src/libslic3r/GCode/ToolOrderUtils.hpp @@ -1,24 +1,29 @@ #ifndef TOOL_ORDER_UTILS_HPP #define TOOL_ORDER_UTILS_HPP -#include -#include -#include +#include +#include +#include +#include namespace Slic3r { using FlushMatrix = std::vector>; -class MaxFlow +namespace MaxFlowGraph { + const int INF = std::numeric_limits::max(); + const int INVALID_ID = -1; +} + +class MaxFlowSolver { private: - const int INF = std::numeric_limits::max(); struct Edge { int from, to, capacity, flow; Edge(int u, int v, int cap) :from(u), to(v), capacity(cap), flow(0) {} }; public: - MaxFlow(const std::vector& u_nodes, const std::vector& v_nodes, + MaxFlowSolver(const std::vector& u_nodes, const std::vector& v_nodes, const std::unordered_map>& uv_link_limits = {}, const std::unordered_map>& uv_unlink_limits = {}, const std::vector& u_capacity = {}, @@ -29,7 +34,6 @@ public: private: void add_edge(int from, int to, int capacity); - int total_nodes; int source_id; int sink_id; @@ -39,41 +43,57 @@ private: std::vector>adj; }; -class MinCostMaxFlow -{ - const int INF = std::numeric_limits::max(); - struct Edge - { - int from, to, capacity, cost, flow; - Edge(int u, int v, int cap, int cst) : from(u), to(v), capacity(cap), cost(cst), flow(0) {} - }; +struct MinCostMaxFlow; + +class GeneralMinCostSolver +{ public: - MinCostMaxFlow(const std::vector>& matrix_, const std::vector& u_nodes, const std::vector& v_nodes, + GeneralMinCostSolver(const std::vector>& matrix_, + const std::vector& u_nodes, + const std::vector& v_nodes); + + std::vector solve(); + ~GeneralMinCostSolver(); +private: + std::unique_ptr m_solver; +}; + + +class MinFlushFlowSolver +{ +public: + MinFlushFlowSolver(const std::vector>& matrix_, + const std::vector& u_nodes, + const std::vector& v_nodes, const std::unordered_map>& uv_link_limits = {}, const std::unordered_map>& uv_unlink_limits = {}, const std::vector& u_capacity = {}, const std::vector& v_capacity = {} ); std::vector solve(); - + ~MinFlushFlowSolver(); private: - void add_edge(int from, int to, int capacity, int cost); - bool spfa(int source, int sink); - int get_distance(int idx_in_left, int idx_in_right); - -private: - std::vector> matrix; - std::vector l_nodes; - std::vector r_nodes; - std::vector edges; - std::vector> adj; - - int total_nodes; - int source_id; - int sink_id; + std::unique_ptr m_solver; }; + +class MatchModeGroupSolver +{ +public: + MatchModeGroupSolver(const std::vector>& matrix_, + const std::vector& u_nodes, + const std::vector& v_nodes, + const std::vector& v_capacity, + const std::unordered_map>& uv_unlink_limits = {}); + + std::vector solve(); + ~MatchModeGroupSolver(); +private: + std::unique_ptr m_solver; +}; + + std::vector get_extruders_order(const std::vector> &wipe_volumes, const std::vector &curr_layer_extruders, const std::vector &next_layer_extruders, diff --git a/src/libslic3r/GCode/ToolOrdering.cpp b/src/libslic3r/GCode/ToolOrdering.cpp index 5951f5a9e..b837b4be6 100644 --- a/src/libslic3r/GCode/ToolOrdering.cpp +++ b/src/libslic3r/GCode/ToolOrdering.cpp @@ -4,6 +4,7 @@ #include "ClipperUtils.hpp" #include "ParameterUtils.hpp" #include "GCode/ToolOrderUtils.hpp" +#include "FilamentGroupUtils.hpp" // #define SLIC3R_DEBUG // Make assert active if SLIC3R_DEBUG @@ -1010,6 +1011,7 @@ float get_flush_volume(const std::vector &filament_maps, const std::vector< std::vector ToolOrdering::get_recommended_filament_maps(const std::vector>& layer_filaments, const PrintConfig* print_config, const Print* print, const std::vector>&physical_unprintables,const std::vector>&geometric_unprintables) { + using namespace FilamentGroupUtils; if (!print_config || layer_filaments.empty()) return std::vector(); @@ -1052,73 +1054,48 @@ std::vector ToolOrdering::get_recommended_filament_maps(const std::vector extruder_ams_count_str = print_config->extruder_ams_count.values; - auto extruder_ams_counts = get_extruder_ams_count(extruder_ams_count_str); - std::vector group_size = {16, 16}; - if (extruder_ams_counts.size() > 0) { - assert(extruder_ams_counts.size() == 2); - for (int i = 0; i < extruder_ams_counts.size(); ++i) { - group_size[i] = 0; - const auto &ams_count = extruder_ams_counts[i]; - for (auto iter = ams_count.begin(); iter != ams_count.end(); ++iter) { group_size[i] += iter->first * iter->second; } - } - // When the AMS count is 0, only external filament can be used, so set the capacity to 1. - for(auto& size: group_size) - if(size == 0) - size = 1; - } + auto extruder_ams_counts = get_extruder_ams_count(extruder_ams_count_str); + std::vector group_size = calc_max_group_size(extruder_ams_counts, false); + + auto machine_filament_info = build_machine_filaments(print->get_extruder_filament_info()); + std::vector filament_types = print_config->filament_type.values; + std::vector filament_colours = print_config->filament_colour.values; - FilamentGroupContext context; - { - context.flush_matrix = std::move(nozzle_flush_mtx); - context.geometric_unprintables = geometric_unprintables; - context.physical_unprintables = physical_unprintables; - context.max_group_size = std::move(group_size); - context.total_filament_num = (int)filament_nums; - context.master_extruder_id = print_config->master_extruder_id.value - 1; // transfer to 0 based idx - } // speacially handle tpu filaments auto used_filaments = collect_sorted_used_filaments(layer_filaments); auto tpu_filaments = get_filament_by_type(used_filaments, print_config, "TPU"); + FGMode fg_mode = print_config->filament_map_mode.value == FilamentMapMode::fmmAutoForMatch ? FGMode::MatchMode: FGMode::FlushMode; + + std::vector> ext_unprintable_filaments; + collect_unprintable_limits(physical_unprintables, geometric_unprintables, ext_unprintable_filaments); // TODO: throw exception if fail or set it to status + + FilamentGroupContext context; + { + context.model_info.flush_matrix = std::move(nozzle_flush_mtx); + context.model_info.unprintable_filaments = ext_unprintable_filaments; // TODO: + context.model_info.layer_filaments = layer_filaments; + context.model_info.filament_colors = filament_colours; + context.model_info.filament_types = filament_types; + + context.machine_info.machine_filament_info = machine_filament_info; + context.machine_info.max_group_size = std::move(group_size); + context.machine_info.master_extruder_id = print_config->master_extruder_id.value - 1; // switch to 0 based idx + + context.group_info.total_filament_num = (int)(filament_nums); + context.group_info.max_gap_threshold = 0.01; + context.group_info.strategy = FGStrategy::BestCost; + context.group_info.mode = fg_mode; + context.group_info.ignore_ext_filament = false; // TODO: + } + if (!tpu_filaments.empty()) { - for (size_t fidx = 0; fidx < filament_nums; ++fidx) { - if (tpu_filaments.count(fidx)) - ret[fidx] = context.master_extruder_id; - else - ret[fidx] = 1 - context.master_extruder_id; - } + ret = calc_filament_group_for_tpu(tpu_filaments, context.group_info.total_filament_num, context.machine_info.master_extruder_id); } else { FilamentGroup fg(context); - fg.set_memory_threshold(0.02); fg.get_custom_seq = get_custom_seq; - - ret = fg.calc_filament_group(layer_filaments, FGStrategy::BestCost); - - // optimize for master extruder id - optimize_group_for_master_extruder(used_filaments, context, ret); - - // optimize according to AMS filaments - std::vector>memoryed_maps{ ret }; - { - auto tmp_maps = fg.get_memoryed_groups(); - memoryed_maps.insert(memoryed_maps.end(), std::make_move_iterator(tmp_maps.begin()), std::make_move_iterator(tmp_maps.end())); - } - - std::vectorused_colors; - for (size_t idx = 0; idx < used_filaments.size(); ++idx) - used_colors.emplace_back(print_config->filament_colour.get_at(used_filaments[idx])); - - auto ams_filament_info = print->get_extruder_filament_info(); - std::vector> ams_colors(extruder_nums); - for (size_t i = 0; i < ams_filament_info.size(); ++i) { - auto& arr = ams_filament_info[i]; - std::vectorcolors; - for (auto& item : arr) - colors.emplace_back(item.option("filament_colour")->get_at(0)); - ams_colors[i] = std::move(colors); - } - ret = select_best_group_for_ams(memoryed_maps, used_filaments, used_colors, ams_colors, similar_color_threshold_de2000); + ret = fg.calc_filament_group(); } }