#include "ToolOrderUtils.hpp" #include #include #include #include #include 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) {} }; 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, const std::vector& v_capacity) { assert(u_capacity.empty() || u_capacity.size() == u_nodes.size()); assert(v_capacity.empty() || v_capacity.size() == v_nodes.size()); l_nodes = u_nodes; r_nodes = v_nodes; total_nodes = u_nodes.size() + v_nodes.size() + 2; source_id = total_nodes - 2; sink_id = total_nodes - 1; adj.resize(total_nodes); // add edge from source to left nodes for (int idx = 0; idx < l_nodes.size(); ++idx) { int capacity = u_capacity.empty() ? 1 : u_capacity[idx]; add_edge(source_id, idx, capacity); } // add edge from right nodes to sink node for (int idx = 0; idx < r_nodes.size(); ++idx) { int capacity = v_capacity.empty() ? 1 : v_capacity[idx]; add_edge(l_nodes.size() + idx, sink_id, capacity); } // add edge from left nodes to right nodes for (int i = 0; i < l_nodes.size(); ++i) { int from_idx = i; // process link limits , i can only link to uv_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); continue; } // process unlink limits 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) { // check whether i can link to 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); } } } void MaxFlowSolver::add_edge(int from, int to, int capacity) { adj[from].emplace_back(edges.size()); edges.emplace_back(from, to, capacity); //also add reverse edge ,set capacity to zero adj[to].emplace_back(edges.size()); edges.emplace_back(to, from, 0); } 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] = MaxFlowGraph::INF; while (!travel.empty()) { int from = travel.front(); travel.pop(); // traverse all linked edges for (int i = 0; i < adj[from].size(); ++i) { int eid = adj[from][i]; Edge& tmp = edges[eid]; if (augment[tmp.to] == 0 && tmp.capacity > tmp.flow) { previous[tmp.to] = eid; augment[tmp.to] = std::min(augment[from], tmp.capacity - tmp.flow); travel.push(tmp.to); } } // already find an extend path, stop and do update if (augment[sink_id] != 0) break; } // no longer have extend path if (augment[sink_id] == 0) break; for (int i = sink_id; i != source_id; i = edges[previous[i]].from) { edges[previous[i]].flow += augment[sink_id]; edges[previous[i] ^ 1].flow -= augment[sink_id]; } } 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) { 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; } 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, const std::vector& v_capacity) { assert(u_capacity.empty() || u_capacity.size() == u_nodes.size()); assert(v_capacity.empty() || v_capacity.size() == v_nodes.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) { int capacity = u_capacity.empty() ? 1 : u_capacity[i]; 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 < m_solver->r_nodes.size(); ++i) { int capacity = v_capacity.empty() ? 1 : v_capacity[i]; 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 < 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) m_solver->add_edge(from_idx, m_solver->l_nodes.size() + r_id, 1, m_solver->get_distance(i, r_id)); continue; } // 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)); } } } std::vector MinFlushFlowSolver::solve() { return m_solver->solve(); } 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)); } } } std::vector MatchModeGroupSolver::solve() { return m_solver->solve(); } //solve the problem by searching the least flush of current filament static std::vector solve_extruder_order_with_greedy(const std::vector>& wipe_volumes, const std::vector curr_layer_extruders, const std::optional& start_extruder_id, float* min_cost) { float cost = 0; std::vector best_seq; std::vectoris_visited(curr_layer_extruders.size(), false); std::optionalprev_filament = start_extruder_id; int idx = curr_layer_extruders.size(); while (idx > 0) { if (!prev_filament) { auto iter = std::find_if(is_visited.begin(), is_visited.end(), [](auto item) {return item == 0; }); assert(iter != is_visited.end()); prev_filament = curr_layer_extruders[iter - is_visited.begin()]; } int target_idx = -1; int target_cost = std::numeric_limits::max(); for (size_t k = 0; k < is_visited.size(); ++k) { if (!is_visited[k]) { if (wipe_volumes[*prev_filament][curr_layer_extruders[k]] < target_cost) { target_idx = k; target_cost = wipe_volumes[*prev_filament][curr_layer_extruders[k]]; } } } assert(target_idx != -1); cost += target_cost; best_seq.emplace_back(curr_layer_extruders[target_idx]); prev_filament = curr_layer_extruders[target_idx]; is_visited[target_idx] = true; idx -= 1; } if (min_cost) *min_cost = cost; return best_seq; } //solve the problem by forcasting one layer static std::vector solve_extruder_order_with_forcast(const std::vector>& wipe_volumes, std::vector curr_layer_extruders, std::vector next_layer_extruders, const std::optional& start_extruder_id, float* min_cost) { std::sort(curr_layer_extruders.begin(), curr_layer_extruders.end()); std::sort(next_layer_extruders.begin(), next_layer_extruders.end()); float best_cost = std::numeric_limits::max(); std::vectorbest_seq; do { std::optionalprev_extruder_1 = start_extruder_id; float curr_layer_cost = 0; for (size_t idx = 0; idx < curr_layer_extruders.size(); ++idx) { if (prev_extruder_1) curr_layer_cost += wipe_volumes[*prev_extruder_1][curr_layer_extruders[idx]]; prev_extruder_1 = curr_layer_extruders[idx]; } if (curr_layer_cost > best_cost) continue; do { std::optionalprev_extruder_2 = prev_extruder_1; float total_cost = curr_layer_cost; for (size_t idx = 0; idx < next_layer_extruders.size(); ++idx) { if (prev_extruder_2) total_cost += wipe_volumes[*prev_extruder_2][next_layer_extruders[idx]]; prev_extruder_2 = next_layer_extruders[idx]; } if (total_cost < best_cost) { best_cost = total_cost; best_seq = curr_layer_extruders; } } while (std::next_permutation(next_layer_extruders.begin(), next_layer_extruders.end())); } while (std::next_permutation(curr_layer_extruders.begin(), curr_layer_extruders.end())); if (min_cost) { float real_cost = 0; std::optionalprev_extruder = start_extruder_id; for (size_t idx = 0; idx < best_seq.size(); ++idx) { if (prev_extruder) real_cost += wipe_volumes[*prev_extruder][best_seq[idx]]; prev_extruder = best_seq[idx]; } *min_cost = real_cost; } return best_seq; } // Shortest hamilton path problem static std::vector solve_extruder_order(const std::vector>& wipe_volumes, std::vector all_extruders, std::optional start_extruder_id, float* min_cost) { bool add_start_extruder_flag = false; if (start_extruder_id) { auto start_iter = std::find(all_extruders.begin(), all_extruders.end(), start_extruder_id); if (start_iter == all_extruders.end()) all_extruders.insert(all_extruders.begin(), *start_extruder_id), add_start_extruder_flag = true; else std::swap(*all_extruders.begin(), *start_iter); } else { start_extruder_id = all_extruders.front(); } unsigned int iterations = (1 << all_extruders.size()); unsigned int final_state = iterations - 1; std::vector>cache(iterations, std::vector(all_extruders.size(), 0x7fffffff)); std::vector>prev(iterations, std::vector(all_extruders.size(), -1)); cache[1][0] = 0.; for (unsigned int state = 0; state < iterations; ++state) { if (state & 1) { for (unsigned int target = 0; target < all_extruders.size(); ++target) { if (state >> target & 1) { for (unsigned int mid_point = 0; mid_point < all_extruders.size(); ++mid_point) { if (state >> mid_point & 1) { auto tmp = cache[state - (1 << target)][mid_point] + wipe_volumes[all_extruders[mid_point]][all_extruders[target]]; if (cache[state][target] > tmp) { cache[state][target] = tmp; prev[state][target] = mid_point; } } } } } } } //get res float cost = std::numeric_limits::max(); int final_dst = 0; for (unsigned int dst = 0; dst < all_extruders.size(); ++dst) { if (all_extruders[dst] != start_extruder_id && cost > cache[final_state][dst]) { cost = cache[final_state][dst]; if (min_cost) *min_cost = cost; final_dst = dst; } } std::vectorpath; unsigned int curr_state = final_state; int curr_point = final_dst; while (curr_point != -1) { path.emplace_back(all_extruders[curr_point]); auto mid_point = prev[curr_state][curr_point]; curr_state -= (1 << curr_point); curr_point = mid_point; }; if (add_start_extruder_flag) path.pop_back(); std::reverse(path.begin(), path.end()); return path; } template static std::vector collect_filaments_in_groups(const std::unordered_set& group, const std::vector& filament_list) { std::vectorret; ret.reserve(group.size()); for (auto& f : filament_list) { if (auto iter = group.find(f); iter != group.end()) ret.emplace_back(static_cast(f)); } return ret; } // get best filament order of single nozzle std::vector get_extruders_order(const std::vector>& wipe_volumes, const std::vector& curr_layer_extruders, const std::vector& next_layer_extruders, const std::optional& start_extruder_id, bool use_forcast, float* cost) { if (curr_layer_extruders.empty()) { if (cost) *cost = 0; return curr_layer_extruders; } if (curr_layer_extruders.size() == 1) { if (cost) { *cost = 0; if (start_extruder_id) *cost = wipe_volumes[*start_extruder_id][curr_layer_extruders[0]]; } return curr_layer_extruders; } if (use_forcast) return solve_extruder_order_with_forcast(wipe_volumes, curr_layer_extruders, next_layer_extruders, start_extruder_id, cost); else if (curr_layer_extruders.size() <= 20) return solve_extruder_order(wipe_volumes, curr_layer_extruders, start_extruder_id, cost); else return solve_extruder_order_with_greedy(wipe_volumes, curr_layer_extruders, start_extruder_id, cost); } int reorder_filaments_for_minimum_flush_volume(const std::vector& filament_lists, const std::vector& filament_maps, const std::vector>& layer_filaments, const std::vector& flush_matrix, std::optional&)>> get_custom_seq, std::vector>* filament_sequences) { //only when layer filament num <= 5,we do forcast constexpr int max_n_with_forcast = 5; int cost = 0; std::vector>groups(2); //save the grouped filaments std::vector>> layer_sequences(2); //save the reordered filament sequence by group std::map> custom_layer_sequence_map; // save the filament sequences of custom layer // group the filament for (int i = 0; i < filament_maps.size(); ++i) { if (filament_maps[i] == 0) groups[0].insert(filament_lists[i]); if (filament_maps[i] == 1) groups[1].insert(filament_lists[i]); } // store custom layer sequence for (size_t layer = 0; layer < layer_filaments.size(); ++layer) { const auto& curr_lf = layer_filaments[layer]; std::vectorcustom_filament_seq; if (get_custom_seq && (*get_custom_seq)(layer, custom_filament_seq) && !custom_filament_seq.empty()) { std::vector unsign_custom_extruder_seq; for (int extruder : custom_filament_seq) { unsigned int unsign_extruder = static_cast(extruder) - 1; auto it = std::find(curr_lf.begin(), curr_lf.end(), unsign_extruder); if (it != curr_lf.end()) unsign_custom_extruder_seq.emplace_back(unsign_extruder); } assert(curr_lf.size() == unsign_custom_extruder_seq.size()); custom_layer_sequence_map[layer] = unsign_custom_extruder_seq; } } using uint128_t = boost::multiprecision::uint128_t; auto extruders_to_hash_key = [](const std::vector& curr_layer_extruders, const std::vector& next_layer_extruders, const std::optional& prev_extruder, bool use_forcast)->uint128_t { uint128_t hash_key = 0; //31-0 bit define current layer extruder,63-32 bit define next layer extruder,95~64 define prev extruder if (prev_extruder) hash_key |= (uint128_t(1) << (64 + *prev_extruder)); if (use_forcast) { for (auto item : next_layer_extruders) hash_key |= (uint128_t(1) << (32 + item)); } for (auto item : curr_layer_extruders) hash_key |= (uint128_t(1) << item); return hash_key; }; // get best layer sequence by group for (size_t idx = 0; idx < groups.size(); ++idx) { // case with one group if (groups[idx].empty()) continue; std::optionalcurrent_extruder_id; std::unordered_map>> caches; for (size_t layer = 0; layer < layer_filaments.size(); ++layer) { const auto& curr_lf = layer_filaments[layer]; if (auto iter = custom_layer_sequence_map.find(layer); iter != custom_layer_sequence_map.end()) { auto sequence_in_group = collect_filaments_in_groups(groups[idx], iter->second); float tmp_cost = 0; std::optionalprev = current_extruder_id; for (auto& f : sequence_in_group) { if (prev) { tmp_cost += flush_matrix[idx][*prev][f]; } prev = f; } cost += tmp_cost; if (!sequence_in_group.empty()) current_extruder_id = sequence_in_group.back(); //insert an empty array if (filament_sequences) layer_sequences[idx].emplace_back(std::vector()); continue; } std::vectorfilament_used_in_group = collect_filaments_in_groups(groups[idx], curr_lf); std::vectornext_lf; if (layer + 1 < layer_filaments.size()) next_lf = layer_filaments[layer + 1]; std::vectorfilament_used_in_group_next_layer = collect_filaments_in_groups(groups[idx], next_lf); bool use_forcast = (filament_used_in_group.size() <= max_n_with_forcast && filament_used_in_group_next_layer.size() <= max_n_with_forcast); float tmp_cost = 0; std::vectorsequence; uint128_t hash_key = extruders_to_hash_key(filament_used_in_group, filament_used_in_group_next_layer, current_extruder_id, use_forcast); if (auto iter = caches.find(hash_key); iter != caches.end()) { tmp_cost = iter->second.first; sequence = iter->second.second; } else { sequence = get_extruders_order(flush_matrix[idx], filament_used_in_group, filament_used_in_group_next_layer, current_extruder_id, use_forcast, &tmp_cost); caches[hash_key] = { tmp_cost,sequence }; } assert(sequence.size() == filament_used_in_group.size()); if (filament_sequences) layer_sequences[idx].emplace_back(sequence); if (!sequence.empty()) current_extruder_id = sequence.back(); cost += tmp_cost; } } // get the final layer sequences // if only have one group,we need to check whether layer sequence[idx] is valid if (filament_sequences) { filament_sequences->clear(); filament_sequences->resize(layer_filaments.size()); int last_group_id = 0; //if last_group == 0,print group 0 first ,else print group 1 first if (!custom_layer_sequence_map.empty()) { const auto& first_layer = custom_layer_sequence_map.begin()->first; const auto& first_layer_filaments = custom_layer_sequence_map.begin()->second; assert(!first_layer_filaments.empty()); bool first_group = groups[0].count(first_layer_filaments.front()) ? 0 : 1; last_group_id = (first_layer & 1) ? !first_group : first_group; } for (size_t layer = 0; layer < layer_filaments.size(); ++layer) { auto& curr_layer_seq = (*filament_sequences)[layer]; if (custom_layer_sequence_map.find(layer) != custom_layer_sequence_map.end()) { curr_layer_seq = custom_layer_sequence_map[layer]; if (!curr_layer_seq.empty()) { last_group_id = groups[0].count(curr_layer_seq.back()) ? 0 : 1; } continue; } if (last_group_id == 1) { // try reuse the last group if (!layer_sequences[1].empty() && !layer_sequences[1][layer].empty()) curr_layer_seq.insert(curr_layer_seq.end(), layer_sequences[1][layer].begin(), layer_sequences[1][layer].end()); if (!layer_sequences[0].empty() && !layer_sequences[0][layer].empty()) { curr_layer_seq.insert(curr_layer_seq.end(), layer_sequences[0][layer].begin(), layer_sequences[0][layer].end()); last_group_id = 0; // update last group id } } else if(last_group_id == 0) { if (!layer_sequences[0].empty() && !layer_sequences[0][layer].empty()) { curr_layer_seq.insert(curr_layer_seq.end(), layer_sequences[0][layer].begin(), layer_sequences[0][layer].end()); } if (!layer_sequences[1].empty() && !layer_sequences[1][layer].empty()) { curr_layer_seq.insert(curr_layer_seq.end(), layer_sequences[1][layer].begin(), layer_sequences[1][layer].end()); last_group_id = 1; // update last group id } } } } return cost; } }