static typename edge_capacity_value<Graph, P, T, R>::type
apply
(Graph& g,
typename graph_traits<Graph>::vertex_descriptor src,
typename graph_traits<Graph>::vertex_descriptor sink,
PredMap pred,
const bgl_named_params<P, T, R>& params,
detail::error_property_not_found)
{
typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
typedef typename graph_traits<Graph>::vertices_size_type size_type;
size_type n = is_default_param(get_param(params, vertex_color)) ?
num_vertices(g) : 1;
std::vector<default_color_type> color_vec(n);
return edmonds_karp_max_flow
(g, src, sink,
choose_const_pmap(get_param(params, edge_capacity), g, edge_capacity),
choose_pmap(get_param(params, edge_residual_capacity),
g, edge_residual_capacity),
choose_const_pmap(get_param(params, edge_reverse), g, edge_reverse),
make_iterator_property_map(color_vec.begin(), choose_const_pmap
(get_param(params, vertex_index),
g, vertex_index), color_vec[0]),
pred);
}
Flow min_st_cut(const Graph &g, const size_t source, const size_t target,
const std::vector<size_t> &rev_edge,
const std::vector<Flow> &capacity,
std::vector<bool> &source_side) {
std::vector<Flow> residual;
const auto max_flow =
edmonds_karp_max_flow(g, source, target, rev_edge, capacity, residual);
source_side.assign(g.num_vertices(), false);
std::stack<size_t> stack;
source_side[source] = true;
stack.push(source);
while (!stack.empty()) {
const size_t current = stack.top();
stack.pop();
for (const auto edge : g.out_edges(current)) {
const size_t neighbor = g.target(edge);
if (source_side[neighbor])
continue; // Already discovered.
if (!residual[edge])
continue; // Can't navigate through saturated edges.
source_side[neighbor] = true;
stack.push(neighbor);
}
}
return max_flow;
}
typename property_traits<
typename property_map<Graph, edge_capacity_t>::const_type
>::value_type
edmonds_karp_max_flow
(Graph& g,
typename graph_traits<Graph>::vertex_descriptor src,
typename graph_traits<Graph>::vertex_descriptor sink)
{
bgl_named_params<int, buffer_param_t> params(0);
return edmonds_karp_max_flow(g, src, sink, params);
}
static typename edge_capacity_value<Graph, P, T, R>::type
apply
(Graph& g,
typename graph_traits<Graph>::vertex_descriptor src,
typename graph_traits<Graph>::vertex_descriptor sink,
PredMap pred,
const bgl_named_params<P, T, R>& params,
ColorMap color)
{
return edmonds_karp_max_flow
(g, src, sink,
choose_const_pmap(get_param(params, edge_capacity), g, edge_capacity),
choose_pmap(get_param(params, edge_residual_capacity),
g, edge_residual_capacity),
choose_const_pmap(get_param(params, edge_reverse), g, edge_reverse),
color, pred);
}
typename graph_traits<VertexListGraph>::degree_size_type
edge_connectivity(VertexListGraph& g, OutputIterator disconnecting_set)
{
//-------------------------------------------------------------------------
// Type Definitions
typedef graph_traits<VertexListGraph> Traits;
typedef typename Traits::vertex_iterator vertex_iterator;
typedef typename Traits::edge_iterator edge_iterator;
typedef typename Traits::out_edge_iterator out_edge_iterator;
typedef typename Traits::vertex_descriptor vertex_descriptor;
typedef typename Traits::degree_size_type degree_size_type;
typedef color_traits<default_color_type> Color;
typedef adjacency_list_traits<vecS, vecS, directedS> Tr;
typedef typename Tr::edge_descriptor Tr_edge_desc;
typedef adjacency_list<vecS, vecS, directedS, no_property,
property<edge_capacity_t, degree_size_type,
property<edge_residual_capacity_t, degree_size_type,
property<edge_reverse_t, Tr_edge_desc> > > >
FlowGraph;
typedef typename graph_traits<FlowGraph>::edge_descriptor edge_descriptor;
//-------------------------------------------------------------------------
// Variable Declarations
vertex_descriptor u, v, p, k;
edge_descriptor e1, e2;
bool inserted;
vertex_iterator vi, vi_end;
edge_iterator ei, ei_end;
degree_size_type delta, alpha_star, alpha_S_k;
std::set<vertex_descriptor> S, neighbor_S;
std::vector<vertex_descriptor> S_star, non_neighbor_S;
std::vector<default_color_type> color(num_vertices(g));
std::vector<edge_descriptor> pred(num_vertices(g));
//-------------------------------------------------------------------------
// Create a network flow graph out of the undirected graph
FlowGraph flow_g(num_vertices(g));
typename property_map<FlowGraph, edge_capacity_t>::type
cap = get(edge_capacity, flow_g);
typename property_map<FlowGraph, edge_residual_capacity_t>::type
res_cap = get(edge_residual_capacity, flow_g);
typename property_map<FlowGraph, edge_reverse_t>::type
rev_edge = get(edge_reverse, flow_g);
for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
u = source(*ei, g), v = target(*ei, g);
tie(e1, inserted) = add_edge(u, v, flow_g);
cap[e1] = 1;
tie(e2, inserted) = add_edge(v, u, flow_g);
cap[e2] = 1; // not sure about this
rev_edge[e1] = e2;
rev_edge[e2] = e1;
}
//-------------------------------------------------------------------------
// The Algorithm
tie(p, delta) = detail::min_degree_vertex(g);
S_star.push_back(p);
alpha_star = delta;
S.insert(p);
neighbor_S.insert(p);
detail::neighbors(g, S.begin(), S.end(),
std::inserter(neighbor_S, neighbor_S.begin()));
std::set_difference(vertices(g).first, vertices(g).second,
neighbor_S.begin(), neighbor_S.end(),
std::back_inserter(non_neighbor_S));
while (!non_neighbor_S.empty()) { // at most n - 1 times
k = non_neighbor_S.front();
alpha_S_k = edmonds_karp_max_flow
(flow_g, p, k, cap, res_cap, rev_edge, &color[0], &pred[0]);
if (alpha_S_k < alpha_star) {
alpha_star = alpha_S_k;
S_star.clear();
for (tie(vi, vi_end) = vertices(flow_g); vi != vi_end; ++vi)
if (color[*vi] != Color::white())
S_star.push_back(*vi);
}
S.insert(k);
neighbor_S.insert(k);
detail::neighbors(g, k, std::inserter(neighbor_S, neighbor_S.begin()));
non_neighbor_S.clear();
std::set_difference(vertices(g).first, vertices(g).second,
neighbor_S.begin(), neighbor_S.end(),
std::back_inserter(non_neighbor_S));
}
//-------------------------------------------------------------------------
// Compute edges of the cut [S*, ~S*]
std::vector<bool> in_S_star(num_vertices(g), false);
typename std::vector<vertex_descriptor>::iterator si;
for (si = S_star.begin(); si != S_star.end(); ++si)
in_S_star[*si] = true;
degree_size_type c = 0;
for (si = S_star.begin(); si != S_star.end(); ++si) {
out_edge_iterator ei, ei_end;
for (tie(ei, ei_end) = out_edges(*si, g); ei != ei_end; ++ei)
if (!in_S_star[target(*ei, g)]) {
*disconnecting_set++ = *ei;
++c;
}
}
return c;
}
/*
* The mex function runs a max-flow min-cut problem.
*/
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
mbglIndex i,j,k;
mbglIndex mrows, ncols;
mbglIndex n,nz;
/* sparse matrix */
mwIndex *A_row, *A_col;
double *A_val;
/* source/sink */
mbglIndex u, v;
/* algorithm name */
char *algname;
/* flow matrix connectivity */
mbglIndex *pi_flow, *j_flow;
/* capacity and residual structures */
int *cap, *res;
/* reverse edge map */
mbglIndex *rev_edge_map;
/* result */
int flow;
/* output */
double *pflowval;
double *pmincut;
double *pri;
double *prj;
double *prv;
/*
* The current calling pattern is
* matching_mex(A,verify,initial_match_name,augmenting_path_name)
*/
const mxArray* arg_matrix;
const mxArray* arg_source;
const mxArray* arg_sink;
const mxArray* arg_algname;
int required_arguments = 4;
if (nrhs != required_arguments) {
mexErrMsgIdAndTxt("matlab_bgl:invalidMexArgument",
"the function requires %i arguments, not %i\n",
required_arguments, nrhs);
}
arg_matrix = prhs[0];
arg_source = prhs[1];
arg_sink = prhs[2];
arg_algname = prhs[3];
u = (mbglIndex)load_scalar_arg(arg_source,1);
v = (mbglIndex)load_scalar_arg(arg_sink,2);
algname = load_string_arg(arg_algname,3);
/* The first input must be a sparse matrix. */
mrows = mxGetM(prhs[0]);
ncols = mxGetN(prhs[0]);
if (mrows != ncols ||
!mxIsSparse(prhs[0]) ||
!mxIsDouble(prhs[0]) ||
mxIsComplex(prhs[0]))
{
mexErrMsgIdAndTxt("matlab_bgl:invalidMexArgument",
"the matrix must be sparse, square, and double valued");
}
n = mrows;
/* Get the sparse matrix */
A_val = mxGetPr(prhs[0]);
A_row = mxGetIr(prhs[0]);
A_col = mxGetJc(prhs[0]);
nz = A_col[n];
/* Quick input check */
if (u > n || u < 1) {
mexErrMsgIdAndTxt("matlab_bgl:invalidMexArgument",
"invalid source vertex: %i\n", u);
}
if (v > n || v < 1) {
mexErrMsgIdAndTxt("matlab_bgl:invalidMexArgument",
"invalid sink vertex: %i\n", v);
}
u = u-1;
v = v-1;
/* build flow connectivity structure */
build_matrix(n,A_row,A_col,A_val,
&pi_flow, &j_flow, &cap, &rev_edge_map);
/* allocate the residual map */
res = mxCalloc(sizeof(int),pi_flow[n]);
/*i = 0;
for (k=0; k < pi_flow[n]; k++)
{
// get the correct row
while (k >= pi_flow[i+1]) { ++i; }
mexPrintf("(%i,%i) (%i,%i)\n", i,j_flow[k],cap[k],res[k]);
}*/
/* mexPrintf("Calling flow (%i,%i)...\n", u, v); */
#ifdef _DEBUG
mexPrintf("max_flow(%s)...", algname);
#endif
if (strcmp(algname,"push_relabel") == 0) {
push_relabel_max_flow(n,j_flow,pi_flow,
u,v,cap,res,rev_edge_map,&flow);
} else if (strcmp(algname, "edmunds_karp") == 0) {
edmonds_karp_max_flow(n,j_flow,pi_flow,
u,v,cap,res,rev_edge_map,&flow);
} else if (strcmp(algname, "kolmogorov") == 0) {
boykov_kolmogorov_max_flow(n,j_flow,pi_flow,
u,v,cap,res,rev_edge_map,&flow);
} else {
mexErrMsgIdAndTxt("matlab_bgl:invalidMexArgument",
"algname option %s is invalid\n",
algname);
}
#ifdef _DEBUG
mexPrintf("done!\n");
#endif
/*i = 0;
for (k=0; k < pi_flow[n]; k++)
{
// get the correct row
while (k >= pi_flow[i+1]) { ++i; }
mexPrintf("(%i,%i) (%i,%i)\n", i,j_flow[k],cap[k],res[k]);
}*/
if (nlhs >= 1)
{
plhs[0] = mxCreateDoubleMatrix(1,1, mxREAL);
pflowval = mxGetPr(plhs[0]);
pflowval[0] = (double)flow;
}
if (nlhs >= 2)
{
int *pimincut;
plhs[1] = mxCreateDoubleMatrix(n,1,mxREAL);
pmincut = mxGetPr(plhs[1]);
pimincut = (int*)pmincut;
build_cut(u, n, pi_flow, j_flow, cap, res, pimincut);
test_cut(flow,pimincut,n,A_row,A_col,A_val);
/* now expand mincut to the full dataset, we need to
* do this operation backwards because pimincut has integer
* entries specified and we are expanding them to double.
*/
expand_int_to_double(pimincut,pmincut,n,0.0);
}
if (nlhs >= 3)
{
plhs[2] = mxCreateDoubleMatrix(nz,1,mxREAL);
plhs[3] = mxCreateDoubleMatrix(nz,1,mxREAL);
plhs[4] = mxCreateDoubleMatrix(nz,1,mxREAL);
pri = mxGetPr(plhs[2]);
prj = mxGetPr(plhs[3]);
prv = mxGetPr(plhs[4]);
/* j will be our index into the new matrix. */
j = 0;
for (i=0;i<n;i++)
{
for (k=pi_flow[i];k<pi_flow[i+1];k++)
{
if (cap[k] != 0)
{
/* since cap[k] != 0, this is a real edge */
pri[j] = i+1;
prj[j] = j_flow[k]+1;
prv[j] = res[k];
j++;
}
}
}
if (j != nz)
{
mexPrintf("error... j != nz...\n");
}
}
#ifdef _DEBUG
mexPrintf("return\n");
#endif
}
typename graph_traits < VertexListGraph >::degree_size_type
edge_connectivity(VertexListGraph & g, OutputIterator disconnecting_set)
{
typedef typename graph_traits <
VertexListGraph >::vertex_descriptor vertex_descriptor;
typedef typename graph_traits <
VertexListGraph >::degree_size_type degree_size_type;
typedef color_traits < default_color_type > Color;
typedef typename adjacency_list_traits < vecS, vecS,
directedS >::edge_descriptor edge_descriptor;
typedef adjacency_list < vecS, vecS, directedS, no_property,
property < edge_capacity_t, degree_size_type,
property < edge_residual_capacity_t, degree_size_type,
property < edge_reverse_t, edge_descriptor > > > > FlowGraph;
vertex_descriptor u, v, p, k;
edge_descriptor e1, e2;
bool inserted;
typename graph_traits < VertexListGraph >::vertex_iterator vi, vi_end;
degree_size_type delta, alpha_star, alpha_S_k;
std::set < vertex_descriptor > S, neighbor_S;
std::vector < vertex_descriptor > S_star, nonneighbor_S;
std::vector < default_color_type > color(num_vertices(g));
std::vector < edge_descriptor > pred(num_vertices(g));
FlowGraph flow_g(num_vertices(g));
typename property_map < FlowGraph, edge_capacity_t >::type
cap = get(edge_capacity, flow_g);
typename property_map < FlowGraph, edge_residual_capacity_t >::type
res_cap = get(edge_residual_capacity, flow_g);
typename property_map < FlowGraph, edge_reverse_t >::type
rev_edge = get(edge_reverse, flow_g);
typename graph_traits < VertexListGraph >::edge_iterator ei, ei_end;
for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
u = source(*ei, g), v = target(*ei, g);
boost::tie(e1, inserted) = add_edge(u, v, flow_g);
cap[e1] = 1;
boost::tie(e2, inserted) = add_edge(v, u, flow_g);
cap[e2] = 1;
rev_edge[e1] = e2;
rev_edge[e2] = e1;
}
boost::tie(p, delta) = min_degree_vertex(g);
S_star.push_back(p);
alpha_star = delta;
S.insert(p);
neighbor_S.insert(p);
neighbors(g, S.begin(), S.end(),
std::inserter(neighbor_S, neighbor_S.begin()));
std::set_difference(vertices(g).first, vertices(g).second,
neighbor_S.begin(), neighbor_S.end(),
std::back_inserter(nonneighbor_S));
while (!nonneighbor_S.empty()) {
k = nonneighbor_S.front();
alpha_S_k = edmonds_karp_max_flow
(flow_g, p, k, cap, res_cap, rev_edge, &color[0], &pred[0]);
if (alpha_S_k < alpha_star) {
alpha_star = alpha_S_k;
S_star.clear();
for (boost::tie(vi, vi_end) = vertices(flow_g); vi != vi_end; ++vi)
if (color[*vi] != Color::white())
S_star.push_back(*vi);
}
S.insert(k);
neighbor_S.insert(k);
neighbors(g, k, std::inserter(neighbor_S, neighbor_S.begin()));
nonneighbor_S.clear();
std::set_difference(vertices(g).first, vertices(g).second,
neighbor_S.begin(), neighbor_S.end(),
std::back_inserter(nonneighbor_S));
}
std::vector < bool > in_S_star(num_vertices(g), false);
typename std::vector < vertex_descriptor >::iterator si;
for (si = S_star.begin(); si != S_star.end(); ++si)
in_S_star[*si] = true;
degree_size_type c = 0;
for (si = S_star.begin(); si != S_star.end(); ++si) {
typename graph_traits < VertexListGraph >::out_edge_iterator ei, ei_end;
for (boost::tie(ei, ei_end) = out_edges(*si, g); ei != ei_end; ++ei)
if (!in_S_star[target(*ei, g)]) {
*disconnecting_set++ = *ei;
++c;
}
}
return c;
}