viewit/OrcaSlicer-KX
5
1
Fork 1
Code Issues Pull Requests Actions 4 Packages Projects Releases 5 Wiki Activity

ENH: refactor filament group

Browse Source 
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 <xun.zhang@bambulab.com>
Change-Id: If4ba09a0320366b862cec59f8ed1f22c392c53b9
(cherry picked from commit 414a2105c9d77bbf7771bdf3fdec40d96dc949c2)
This commit is contained in:
xun.zhang
2024-11-27 10:13:28 +08:00
committed by Noisyfox
parent f5a8c96924
commit e585d5ceb7
8 changed files with 829 additions and 382 deletions
Download Patch File Download Diff File Expand all files Collapse all files

325
src/libslic3r/GCode/ToolOrderUtils.cpp
View File

@@ -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<int>& u_nodes, const std::vector<int>& v_nodes,
std::vector<int> 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<std::vector<float>> matrix;
std::vector<int> l_nodes;
std::vector<int> r_nodes;
std::vector<Edge> edges;
std::vector<std::vector<int>> adj;
int total_nodes{ -1 };
int source_id{ -1 };
int sink_id{ -1 };
};
std::vector<int> MinCostMaxFlow::solve()
{
while (spfa(source_id, sink_id));
std::vector<int>matching(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::vector<int>dist(total_nodes, MaxFlowGraph::INF);
std::vector<bool>in_queue(total_nodes, false);
std::vector<int>flow(total_nodes, MaxFlowGraph::INF);
std::vector<int>prev(total_nodes, 0);
std::queue<int>q;
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.flow<e.capacity && dist[e.to]>dist[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<int>& u_nodes, const std::vector<int>& v_nodes,
const std::unordered_map<int, std::vector<int>>& uv_link_limits,
const std::unordered_map<int, std::vector<int>>& uv_unlink_limits,
const std::vector<int>& 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<int> MaxFlow::solve() {
std::vector<int> MaxFlowSolver::solve() {
std::vector<int> augment;
std::vector<int> previous(total_nodes, 0);
while (1) {
std::vector<int>(total_nodes, 0).swap(augment);
std::queue<int> 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<int> matching(l_nodes.size(), -1);
std::vector<int> 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<std::vector<float>>& matrix_, const std::vector<int>& u_nodes, const std::vector<int>& v_nodes,
GeneralMinCostSolver::~GeneralMinCostSolver()
{
}
GeneralMinCostSolver::GeneralMinCostSolver(const std::vector<std::vector<float>>& matrix_, const std::vector<int>& u_nodes, const std::vector<int>& v_nodes)
{
m_solver = std::make_unique<MinCostMaxFlow>();
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<int> GeneralMinCostSolver::solve() {
return m_solver->solve();
}
MinFlushFlowSolver::~MinFlushFlowSolver()
{
}
MinFlushFlowSolver::MinFlushFlowSolver(const std::vector<std::vector<float>>& matrix_, const std::vector<int>& u_nodes, const std::vector<int>& v_nodes,
const std::unordered_map<int, std::vector<int>>& uv_link_limits,
const std::unordered_map<int, std::vector<int>>& uv_unlink_limits,
const std::vector<int>& 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<MinCostMaxFlow>();
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<std::vector<int>> 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<int> MinCostMaxFlow::solve()
{
while (spfa(source_id, sink_id));
std::vector<int> MinFlushFlowSolver::solve() {
return m_solver->solve();
}
std::vector<int>matching(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<std::vector<float>>& matrix_, const std::vector<int>& u_nodes, const std::vector<int>& v_nodes, const std::vector<int>& v_capacity, const std::unordered_map<int, std::vector<int>>& uv_unlink_limits)
{
assert(v_nodes.size() == v_capacity.size());
m_solver = std::make_unique<MinCostMaxFlow>();
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<std::vector<int>> 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::vector<int>dist(total_nodes, INF);
std::vector<bool>in_queue(total_nodes, false);
std::vector<int>flow(total_nodes, INF);
std::vector<int>prev(total_nodes, 0);
std::queue<int>q;
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.flow<e.capacity && dist[e.to]>dist[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<int> MatchModeGroupSolver::solve() {
return m_solver->solve();
}
//solve the problem by searching the least flush of current filament

82
src/libslic3r/GCode/ToolOrderUtils.hpp
View File

@@ -1,24 +1,29 @@
#ifndef TOOL_ORDER_UTILS_HPP
#define TOOL_ORDER_UTILS_HPP
#include<vector>
#include<optional>
#include<functional>
#include <vector>
#include <optional>
#include <functional>
#include <memory>
namespace Slic3r {
using FlushMatrix = std::vector<std::vector<float>>;
class MaxFlow
namespace MaxFlowGraph {
const int INF = std::numeric_limits<int>::max();
const int INVALID_ID = -1;
}
class MaxFlowSolver
{
private:
const int INF = std::numeric_limits<int>::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<int>& u_nodes, const std::vector<int>& v_nodes,
MaxFlowSolver(const std::vector<int>& u_nodes, const std::vector<int>& v_nodes,
const std::unordered_map<int, std::vector<int>>& uv_link_limits = {},
const std::unordered_map<int, std::vector<int>>& uv_unlink_limits = {},
const std::vector<int>& 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<std::vector<int>>adj;
};
class MinCostMaxFlow
{
const int INF = std::numeric_limits<int>::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<std::vector<float>>& matrix_, const std::vector<int>& u_nodes, const std::vector<int>& v_nodes,
GeneralMinCostSolver(const std::vector<std::vector<float>>& matrix_,
const std::vector<int>& u_nodes,
const std::vector<int>& v_nodes);
std::vector<int> solve();
~GeneralMinCostSolver();
private:
std::unique_ptr<MinCostMaxFlow> m_solver;
};
class MinFlushFlowSolver
{
public:
MinFlushFlowSolver(const std::vector<std::vector<float>>& matrix_,
const std::vector<int>& u_nodes,
const std::vector<int>& v_nodes,
const std::unordered_map<int, std::vector<int>>& uv_link_limits = {},
const std::unordered_map<int, std::vector<int>>& uv_unlink_limits = {},
const std::vector<int>& u_capacity = {},
const std::vector<int>& v_capacity = {}
);
std::vector<int> 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<std::vector<float>> matrix;
std::vector<int> l_nodes;
std::vector<int> r_nodes;
std::vector<Edge> edges;
std::vector<std::vector<int>> adj;
int total_nodes;
int source_id;
int sink_id;
std::unique_ptr<MinCostMaxFlow> m_solver;
};
class MatchModeGroupSolver
{
public:
MatchModeGroupSolver(const std::vector<std::vector<float>>& matrix_,
const std::vector<int>& u_nodes,
const std::vector<int>& v_nodes,
const std::vector<int>& v_capacity,
const std::unordered_map<int, std::vector<int>>& uv_unlink_limits = {});
std::vector<int> solve();
~MatchModeGroupSolver();
private:
std::unique_ptr<MinCostMaxFlow> m_solver;
};
std::vector<unsigned int> get_extruders_order(const std::vector<std::vector<float>> &wipe_volumes,
const std::vector<unsigned int> &curr_layer_extruders,
const std::vector<unsigned int> &next_layer_extruders,

91
src/libslic3r/GCode/ToolOrdering.cpp
View File

@@ -5,6 +5,7 @@
#include "ClipperUtils.hpp"
#include "ParameterUtils.hpp"
#include "GCode/ToolOrderUtils.hpp"
#include "FilamentGroupUtils.hpp"
// #define SLIC3R_DEBUG
// Make assert active if SLIC3R_DEBUG
@@ -1032,6 +1033,7 @@ float get_flush_volume(const std::vector<int> &filament_maps, const std::vector<
std::vector<int> ToolOrdering::get_recommended_filament_maps(const std::vector<std::vector<unsigned int>>& layer_filaments, const PrintConfig* print_config, const Print* print, const std::vector<std::set<int>>&physical_unprintables,const std::vector<std::set<int>>&geometric_unprintables)
{
using namespace FilamentGroupUtils;
if (!print_config || layer_filaments.empty())
return std::vector<int>();
@@ -1074,73 +1076,48 @@ std::vector<int> ToolOrdering::get_recommended_filament_maps(const std::vector<s
// if mutli_extruder, calc group,otherwise set to 0
if (extruder_nums == 2) {
std::vector<std::string> extruder_ams_count_str = print_config->extruder_ams_count.values;
auto extruder_ams_counts = get_extruder_ams_count(extruder_ams_count_str);
std::vector<int> 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<int> group_size = calc_max_group_size(extruder_ams_counts, false);
auto machine_filament_info = build_machine_filaments(print->get_extruder_filament_info());
std::vector<std::string> filament_types = print_config->filament_type.values;
std::vector<std::string> 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<std::set<int>> 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<std::vector<int>>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::vector<std::string>used_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<std::vector<std::string>> ams_colors(extruder_nums);
for (size_t i = 0; i < ams_filament_info.size(); ++i) {
auto& arr = ams_filament_info[i];
std::vector<std::string>colors;
for (auto& item : arr)
colors.emplace_back(item.option<ConfigOptionStrings>("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();
}
}