Slic3r::MinFlushFlowSolver Class Reference

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

Collaboration diagram for Slic3r::MinFlushFlowSolver:

Public Member Functions
	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={}, const std::vector< std::pair< std::set< int >, int > > &v_group_capacity={})
std::vector< int >	solve ()
	~MinFlushFlowSolver ()

Private Attributes
std::unique_ptr< MinCostMaxFlow >	m_solver

Detailed Description

Constructor & Destructor Documentation

MinFlushFlowSolver()

Slic3r::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 = {},
		const std::vector< int > &	v_capacity = {},
		const std::vector< std::pair< std::set< int >, int > > &	v_group_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<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() + v_group_capacity.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);
 
        std::vector<int> v_node_to(v_nodes.size(), m_solver->sink_id);
        for (size_t gid = 0; gid < v_group_capacity.size(); ++gid) {
            for (auto vid : v_group_capacity[gid].first)
                v_node_to[vid] = m_solver->l_nodes.size() + m_solver->r_nodes.size() + gid;
        }
 
        // 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, v_node_to[i], capacity, 0);
        }
        // add edge from temp group node to sink node
        for(int i=0;i<v_group_capacity.size();++i){
            int capacity = v_group_capacity[i].second;
            m_solver->add_edge(m_solver->l_nodes.size() + m_solver->r_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<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));
            }
        }
    }

References m_solver.

~MinFlushFlowSolver()

Slic3r::MinFlushFlowSolver::~MinFlushFlowSolver

(

)

    {
    }

Member Function Documentation

solve()

std::vector< int > Slic3r::MinFlushFlowSolver::solve

(

)

                                             {
        return m_solver->solve();
    }

References m_solver.

Referenced by Slic3r::KMediods::assign_cluster_label(), and Slic3r::refine_groups_by_Nozzle_State().

Here is the caller graph for this function:

Member Data Documentation

m_solver

std::unique_ptr<MinCostMaxFlow> Slic3r::MinFlushFlowSolver::m_solver

private

Referenced by MinFlushFlowSolver(), and solve().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/ToolOrderUtils.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/ToolOrderUtils.cpp