void FullTokenXmlLogger::dump(std::ostream& xmlStream,
AnalysisGraph& tTokenList) const
{
//LASLOGINIT;
xmlStream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
xmlStream << "<!--generated by MM project on ";
// const uint64_t dateLen = strlen("Tue Oct 22 13:42:36 2002");
time_t aclock;
time(&aclock); /* Get time in seconds */
std::string str(ctime(&aclock));
xmlStream << str;
xmlStream << "-->" << std::endl;
xmlStream << "<?xml-stylesheet type=\"text/xsl\" href=\"DataStructure.xslt\"?>" << std::endl;
xmlStream << "<data_structure xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"";
xmlStream << " xsi:noNamespaceSchemaLocation=\"DataStructure.xsd\">" << std::endl;
// dump the graph
const FsaStringsPool& sp=Common::MediaticData::MediaticData::single().stringsPool(m_language);
DumpXMLVisitor vis(xmlStream,*m_propertyCodeManager,sp);
breadth_first_search(*(tTokenList.getGraph()),
tTokenList.firstVertex(),
visitor(vis));
xmlStream << "</data_structure>" << std::endl;
}
void breadth_first_search
(const VertexListGraph& g,
typename graph_traits<VertexListGraph>::vertex_descriptor s,
Buffer& Q, BFSVisitor vis, ColorMap color)
{
typename graph_traits<VertexListGraph>::vertex_descriptor sources[1] = {s};
breadth_first_search(g, sources, sources + 1, Q, vis, color);
}
void search(const Graph g)
{
std::vector<Vertex> bfs;
vertex_visitor vv(bfs);
breadth_first_search(g, S, visitor(vv));
std::cout << "breath first search" << std::endl;
BOOST_FOREACH(Vertex v, bfs){
std::cout << Names[v] << std::endl;
// get(vertex_name, G, v)
}
void num_min_paths(const std::vector<node> &grafo,
int source,
int destination,
std::ofstream &out) {
// Used to calculate the length of path from source to destination.
breadth_first_search(grafo, source);
int min_length = grafo[destination].dist;
out << min_length << " "
<< calc_num(grafo, source, destination, min_length, min_length);
}
static bool willProduceLoop(std::vector<GraphVertex>& vecPredecessor, GraphVertex v, GraphVertex u, Graph& g)
{
path_recorder pathRecorder(vecPredecessor, v, u);
try {
breadth_first_search(g, v, visitor(pathRecorder));
// no path, so after we add edge(u, v), there will be no loop
return false;
} catch (PathDetectedException& e) {
// there is a path between u and v, and we added edge(u, v), so there will be loop
// and edge(u,v) is redundant
return true;
}
}
void print_max_capacity_path_krukskal(struct Graph* graph, int source_vertex,
int target_vertex) {
struct BFS_Result* bfs_result = breadth_first_search(graph, source_vertex,
target_vertex);
PRINT_TEXT_VALUE("MAX_CAPACITY PATH:", bfs_result->max_capacity);
if (PRINT_MAX_CAPACITY_PATH) {
int vertex = target_vertex;
PRINT_TEXT_VALUE("PRINTING PATH:", vertex);
while (bfs_result->path[vertex][0] != -2) {
PRINT_VALUES(bfs_result->path[vertex][0],
bfs_result->path[vertex][1]);
vertex = bfs_result->path[vertex][0];
}
}
}
Vertex
pseudo_peripheral_pair(Graph& G, const Vertex& u, int& ecc,
ColorMap color, DegreeMap degree)
{
typedef typename property_traits<ColorMap>::value_type ColorValue;
typedef color_traits<ColorValue> Color;
detail::rcm_queue<Vertex, DegreeMap> Q(degree);
typename boost::graph_traits<Graph>::vertex_iterator ui, ui_end;
for (tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
put(color, *ui, Color::white());
breadth_first_search(G, u, buffer(Q).color_map(color));
ecc = Q.eccentricity();
return Q.spouse();
}
void bfs_helper
(VertexListGraph& g,
typename graph_traits<VertexListGraph>::vertex_descriptor s,
ColorMap color,
BFSVisitor vis,
const bgl_named_params<P, T, R>& params)
{
typedef graph_traits<VertexListGraph> Traits;
// Buffer default
typedef typename Traits::vertex_descriptor Vertex;
typedef boost::queue<Vertex> queue_t;
queue_t Q;
detail::wrap_ref<queue_t> Qref(Q);
breadth_first_search
(g, s,
choose_param(get_param(params, buffer_param_t()), Qref).ref,
vis, color);
}
void bfs_helper
(VertexListGraph& g,
typename graph_traits<VertexListGraph>::vertex_descriptor s,
EdgeType e,
ColorMap color,
BFSVisitor vis,
const bgl_named_params<P, T, R>& params,
boost::mpl::false_)
{
typedef graph_traits<VertexListGraph> Traits;
// Buffer default
typedef typename Traits::vertex_descriptor Vertex;
typedef boost::queue<Vertex> queue_t;
queue_t Q;
breadth_first_search
(g, s, e,
choose_param(get_param(params, buffer_param_t()), boost::ref(Q)).get(),
vis, color);
}
void CorefSolvingXmlLogger::dump(std::ostream& xmlStream, AnalysisGraph* anagraph, /*SyntacticAnalysis::SyntacticData* sd,*/ AnnotationData* ad) const
{
if (m_outputSuffix == ".wh.xml")
{
xmlStream << "<?xml version='1.0' standalone='no'?>" << std::endl;
xmlStream << "<!--generated by Amose on ";
xmlStream << QDateTime::currentDateTime().toString().toUtf8().data();
xmlStream << "-->" << std::endl;
xmlStream << "<!DOCTYPE COREF SYSTEM \"coref.dtd\">" << std::endl;
xmlStream << std::endl;
xmlStream << "<TEXT>" << std::endl;
// dump the graph
DumpXMLAnnotationVisitor vis(xmlStream, /*sd,*/ ad, m_language);
breadth_first_search(*(anagraph->getGraph()), anagraph->firstVertex(),visitor(vis));
xmlStream << std::endl << std::endl << "</TEXT>" << std::endl;
}
}
int main(int argc, char const *argv[])
{
// Tree construction
TreeNode *root;
root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(3);
root->left->left = new TreeNode(4);
root->left->right = new TreeNode(5);
root->right->left = new TreeNode(6);
root->right->right = new TreeNode(7);
// The breadth-first search algorithm to print nodes in order
cout << "The breadth-first search algorithm to print nodes in level order:" << endl;
breadth_first_search(root);
// The depth-first search algorithm to print nodes in order
cout << "TThe depth-first search algorithm to print nodes in order:" << endl;
depth_first_search(root);
return 0;
}
static
depth findMinWidth(const NGHolder &h, const SpecialEdgeFilter &filter,
NFAVertex src) {
if (isLeafNode(src, h)) {
return depth::unreachable();
}
boost::filtered_graph<NFAGraph, SpecialEdgeFilter> g(h.g, filter);
assert(hasCorrectlyNumberedVertices(h));
const size_t num = num_vertices(h);
vector<depth> distance(num, depth::unreachable());
distance.at(g[src].index) = depth(0);
auto index_map = get(&NFAGraphVertexProps::index, g);
// Since we are interested in the single-source shortest paths on a graph
// with the same weight on every edge, using BFS will be faster than
// Dijkstra here.
breadth_first_search(
g, src,
visitor(make_bfs_visitor(record_distances(
make_iterator_property_map(distance.begin(), index_map),
boost::on_tree_edge()))).vertex_index_map(index_map));
DEBUG_PRINTF("d[accept]=%s, d[acceptEod]=%s\n",
distance.at(NODE_ACCEPT).str().c_str(),
distance.at(NODE_ACCEPT_EOD).str().c_str());
depth d = min(distance.at(NODE_ACCEPT), distance.at(NODE_ACCEPT_EOD));
if (d.is_unreachable()) {
return d;
}
assert(d.is_finite());
assert(d > depth(0));
return d - depth(1);
}
void WordSenseXmlLogger::dump(std::ostream& xmlStream, AnalysisGraph* anagraph, /*SyntacticAnalysis::SyntacticData* sd,*/ AnnotationData* ad) const
{
if (m_outputSuffix == ".senses.xml")
{
xmlStream << "<?xml version='1.0' standalone='no'?>" << std::endl;
xmlStream << "<!--generated by MM project on ";
time_t aclock;
time(&aclock); /* Get time in seconds */
std::string str(ctime(&aclock));
str = str.substr(0,str.size()-1);
xmlStream << str;
xmlStream << "-->" << std::endl;
xmlStream << "<!DOCTYPE WORDSENSE SYSTEM \"wordsense.dtd\">" << std::endl;
xmlStream << std::endl;
xmlStream << "<TEXT>" << std::endl;
// dump the graph
DumpXMLAnnotationVisitor vis(xmlStream, /*sd,*/ ad, m_language);
breadth_first_search(*(anagraph->getGraph()), anagraph->firstVertex(),visitor(vis));
xmlStream << std::endl << std::endl << "</TEXT>" << std::endl;
}
}
typename property_traits<CapacityEdgeMap>::value_type
edmunds_karp_max_flow
(Graph& g,
typename graph_traits<Graph>::vertex_descriptor src,
typename graph_traits<Graph>::vertex_descriptor sink,
CapacityEdgeMap cap,
ResidualCapacityEdgeMap res,
ReverseEdgeMap rev,
ColorMap color,
PredEdgeMap pred)
{
typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;
typedef typename property_traits<ColorMap>::value_type ColorValue;
typedef color_traits<ColorValue> Color;
typename graph_traits<Graph>::vertex_iterator u_iter, u_end;
typename graph_traits<Graph>::out_edge_iterator ei, e_end;
for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
res[*ei] = cap[*ei];
color[sink] = Color::gray();
while (color[sink] != Color::white()) {
boost::queue<vertex_t> Q;
breadth_first_search
(detail::residual_graph(g, res), src, Q,
make_bfs_visitor(record_edge_predecessors(pred, on_tree_edge())),
color);
if (color[sink] != Color::white())
detail::augment(g, src, sink, pred, res, rev);
} // while
typename property_traits<CapacityEdgeMap>::value_type flow = 0;
for (tie(ei, e_end) = out_edges(src, g); ei != e_end; ++ei)
flow += (cap[*ei] - res[*ei]);
return flow;
} // edmunds_karp_max_flow()
void connected_components(Graph& g, ComponentMap& result)
{
#pragma mta noalias g
#pragma mta noalias result
typedef typename graph_traits<Graph>::size_type size_type;
typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
typedef typename graph_traits<Graph>::thread_vertex_iterator
thread_vertex_iterator;
typedef typename graph_traits<Graph>::thread_edge_iterator
thread_edge_iterator;
size_type order = num_vertices(g);
size_type size = num_edges(g);
vertex_id_map<Graph> vid_map = get(_vertex_id_map, g);
size_type stream_id = 0;
size_type num_streams = 1;
// Initialize each vertex to have itself as its leader.
#pragma mta for all streams stream_id of num_streams
{
size_type start_pos = begin_block_range(order, stream_id, num_streams);
size_type end_pos = end_block_range(order, stream_id, num_streams);
thread_vertex_iterator verts = thread_vertices(start_pos, g);
for ( ; start_pos != end_pos; ++start_pos, ++verts)
{
put(result, *verts, start_pos);
}
}
// Find the highest degree vertex.
size_type* degrees = new size_type[order];
#pragma mta for all streams stream_id of num_streams
{
size_type start_pos = begin_block_range(order, stream_id, num_streams);
size_type end_pos = end_block_range(order, stream_id, num_streams);
thread_vertex_iterator verts = thread_vertices(start_pos, g);
for ( ; start_pos != end_pos; ++start_pos, ++verts)
{
degrees[start_pos] = out_degree(*verts, g);
}
}
size_type max_deg_vert_id = 0;
size_type maxdeg = degrees[0];
#pragma mta assert nodep
for (size_type i = 1; i < order; i++)
{
if (degrees[i] > maxdeg)
{
maxdeg = degrees[i];
max_deg_vert_id = i;
}
}
delete [] degrees;
vertex_descriptor max_deg_vert = *(thread_vertices(max_deg_vert_id, g));
// Search from the highest degree vertex to label the giant component (GCC).
detail::news_visitor<Graph, ComponentMap> nvis(result, max_deg_vert);
breadth_first_search(g, max_deg_vert, nvis);
size_type orphan_edges = 0;
#pragma mta for all streams stream_id of num_streams
{
size_type start_pos = begin_block_range(size, stream_id, num_streams);
size_type end_pos = end_block_range(size, stream_id, num_streams);
size_type my_orphan_edges = 0;
thread_edge_iterator tedgs = thread_edges(start_pos, g);
for ( ; start_pos != end_pos; ++start_pos, ++tedgs)
{
edge_descriptor e = *tedgs;
vertex_descriptor u = source(e, g);
vertex_descriptor v = target(e, g);
if (result[u] != max_deg_vert_id || result[v] != max_deg_vert_id)
{
++my_orphan_edges;
}
}
mt_incr(orphan_edges, my_orphan_edges);
}
size_type next_index = 0;
size_type* srcs = new size_type[orphan_edges];
size_type* dests = new size_type[orphan_edges];
#pragma mta for all streams stream_id of num_streams
{
size_type start_pos = begin_block_range(size, stream_id, num_streams);
size_type end_pos = end_block_range(size, stream_id, num_streams);
thread_edge_iterator tedgs = thread_edges(start_pos, g);
for ( ; start_pos != end_pos; ++start_pos, ++tedgs)
{
edge_descriptor e = *tedgs;
vertex_descriptor u = source(e, g);
vertex_descriptor v = target(e, g);
if (result[u] != max_deg_vert_id || result[v] != max_deg_vert_id)
{
size_type my_ind = mt_incr(next_index, 1);
srcs[my_ind] = get(vid_map, u);
dests[my_ind] = get(vid_map, v);
}
}
}
edge_array_adapter<size_type> eaa(srcs, dests, order, orphan_edges);
vertex_property_map<edge_array_adapter<size_type>, size_type>
eaa_components(eaa);
#pragma mta for all streams stream_id of num_streams
{
size_type start_pos = begin_block_range(order, stream_id, num_streams);
size_type end_pos = end_block_range(order, stream_id, num_streams);
thread_vertex_iterator verts = thread_vertices(start_pos, g);
for ( ; start_pos != end_pos; ++start_pos, ++verts)
{
vertex_descriptor v = *verts;
eaa_components[v] = result[v];
}
}
shiloach_vishkin_no_init(eaa, eaa_components);
#pragma mta for all streams stream_id of num_streams
{
size_type start_pos = begin_block_range(order, stream_id, num_streams);
size_type end_pos = end_block_range(order, stream_id, num_streams);
thread_vertex_iterator verts = thread_vertices(start_pos, g);
for ( ; start_pos != end_pos; ++start_pos, ++verts)
{
vertex_descriptor v = *verts;
result[v] = eaa_components[v];
}
}
delete [] srcs;
delete [] dests;
}
OutputIterator
sloan_ordering(Graph& g,
typename graph_traits<Graph>::vertex_descriptor s,
typename graph_traits<Graph>::vertex_descriptor e,
OutputIterator permutation,
ColorMap color,
DegreeMap degree,
PriorityMap priority,
Weight W1,
Weight W2)
{
//typedef typename property_traits<DegreeMap>::value_type Degree;
typedef typename property_traits<PriorityMap>::value_type Degree;
typedef typename property_traits<ColorMap>::value_type ColorValue;
typedef color_traits<ColorValue> Color;
typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
typedef typename std::vector<typename graph_traits<Graph>::vertices_size_type>::iterator vec_iter;
typedef typename graph_traits<Graph>::vertices_size_type size_type;
typedef typename property_map<Graph, vertex_index_t>::const_type VertexID;
//Creating a std-vector for storing the distance from the end vertex in it
typename std::vector<typename graph_traits<Graph>::vertices_size_type> dist(num_vertices(g), 0);
//Wrap a property_map_iterator around the std::iterator
boost::iterator_property_map<vec_iter, VertexID, size_type, size_type&> dist_pmap(dist.begin(), get(vertex_index, g));
breadth_first_search
(g, e, visitor
(
make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) )
)
);
//Creating a property_map for the indices of a vertex
typename property_map<Graph, vertex_index_t>::type index_map = get(vertex_index, g);
//Sets the color and priority to their initial status
unsigned cdeg;
typename graph_traits<Graph>::vertex_iterator ui, ui_end;
for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui)
{
put(color, *ui, Color::white());
cdeg=get(degree, *ui)+1;
put(priority, *ui, W1*dist[index_map[*ui]]-W2*cdeg );
}
//Priority list
typedef indirect_cmp<PriorityMap, std::greater<Degree> > Compare;
Compare comp(priority);
std::list<Vertex> priority_list;
//Some more declarations
typename graph_traits<Graph>::out_edge_iterator ei, ei_end, ei2, ei2_end;
Vertex u, v, w;
put(color, s, Color::green()); //Sets the color of the starting vertex to gray
priority_list.push_front(s); //Puts s into the priority_list
while ( !priority_list.empty() )
{
priority_list.sort(comp); //Orders the elements in the priority list in an ascending manner
u = priority_list.front(); //Accesses the last element in the priority list
priority_list.pop_front(); //Removes the last element in the priority list
if(get(color, u) == Color::green() )
{
//for-loop over all out-edges of vertex u
for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei)
{
v = target(*ei, g);
put( priority, v, get(priority, v) + W2 ); //updates the priority
if (get(color, v) == Color::white() ) //test if the vertex is inactive
{
put(color, v, Color::green() ); //giving the vertex a preactive status
priority_list.push_front(v); //writing the vertex in the priority_queue
}
}
}
//Here starts step 8
*permutation++ = u; //Puts u to the first position in the permutation-vector
put(color, u, Color::black() ); //Gives u an inactive status
//for loop over all the adjacent vertices of u
for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
v = target(*ei, g);
if (get(color, v) == Color::green() ) { //tests if the vertex is inactive
put(color, v, Color::red() ); //giving the vertex an active status
put(priority, v, get(priority, v)+W2); //updates the priority
//for loop over alll adjacent vertices of v
for (boost::tie(ei2, ei2_end) = out_edges(v, g); ei2 != ei2_end; ++ei2) {
w = target(*ei2, g);
if(get(color, w) != Color::black() ) { //tests if vertex is postactive
put(priority, w, get(priority, w)+W2); //updates the priority
if(get(color, w) == Color::white() ){
put(color, w, Color::green() ); // gives the vertex a preactive status
priority_list.push_front(w); // puts the vertex into the priority queue
} //end if
} //end if
} //end for
} //end if
} //end for
} //end while
return permutation;
}
typename graph_traits<Graph>::vertex_descriptor
sloan_start_end_vertices(Graph& G,
typename graph_traits<Graph>::vertex_descriptor &s,
ColorMap color,
DegreeMap degree)
{
typedef typename property_traits<DegreeMap>::value_type Degree;
typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
typedef typename std::vector< typename graph_traits<Graph>::vertices_size_type>::iterator vec_iter;
typedef typename graph_traits<Graph>::vertices_size_type size_type;
typedef typename property_map<Graph, vertex_index_t>::const_type VertexID;
s = *(vertices(G).first);
Vertex e = s;
Vertex i;
unsigned my_degree = get(degree, s );
unsigned dummy, h_i, h_s, w_i, w_e;
bool new_start = true;
unsigned maximum_degree = 0;
//Creating a std-vector for storing the distance from the start vertex in dist
std::vector<typename graph_traits<Graph>::vertices_size_type> dist(num_vertices(G), 0);
//Wrap a property_map_iterator around the std::iterator
boost::iterator_property_map<vec_iter, VertexID, size_type, size_type&> dist_pmap(dist.begin(), get(vertex_index, G));
//Creating a property_map for the indices of a vertex
typename property_map<Graph, vertex_index_t>::type index_map = get(vertex_index, G);
//Creating a priority queue
typedef indirect_cmp<DegreeMap, std::greater<Degree> > Compare;
Compare comp(degree);
std::priority_queue<Vertex, std::vector<Vertex>, Compare> degree_queue(comp);
//step 1
//Scan for the vertex with the smallest degree and the maximum degree
typename graph_traits<Graph>::vertex_iterator ui, ui_end;
for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
{
dummy = get(degree, *ui);
if(dummy < my_degree)
{
my_degree = dummy;
s = *ui;
}
if(dummy > maximum_degree)
{
maximum_degree = dummy;
}
}
//end 1
do{
new_start = false; //Setting the loop repetition status to false
//step 2
//initialize the the disance std-vector with 0
for(typename std::vector<typename graph_traits<Graph>::vertices_size_type>::iterator iter = dist.begin(); iter != dist.end(); ++iter) *iter = 0;
//generating the RLS (rooted level structure)
breadth_first_search
(G, s, visitor
(
make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) )
)
);
//end 2
//step 3
//calculating the depth of the RLS
h_s = RLS_depth(dist);
//step 4
//pushing one node of each degree in an ascending manner into degree_queue
std::vector<bool> shrink_trace(maximum_degree, false);
for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
{
dummy = get(degree, *ui);
if( (dist[index_map[*ui]] == h_s ) && ( !shrink_trace[ dummy ] ) )
{
degree_queue.push(*ui);
shrink_trace[ dummy ] = true;
}
}
//end 3 & 4
// step 5
// Initializing w
w_e = (std::numeric_limits<unsigned>::max)();
//end 5
//step 6
//Testing for termination
while( !degree_queue.empty() )
{
i = degree_queue.top(); //getting the node with the lowest degree from the degree queue
degree_queue.pop(); //ereasing the node with the lowest degree from the degree queue
//generating a RLS
for(typename std::vector<typename graph_traits<Graph>::vertices_size_type>::iterator iter = dist.begin(); iter != dist.end(); ++iter) *iter = 0;
breadth_first_search
(G, i, boost::visitor
(
make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) )
)
);
//Calculating depth and width of the rooted level
h_i = RLS_depth(dist);
w_i = RLS_max_width(dist, h_i);
//Testing for termination
if( (h_i > h_s) && (w_i < w_e) )
{
h_s = h_i;
s = i;
while(!degree_queue.empty()) degree_queue.pop();
new_start = true;
}
else if(w_i < w_e)
{
w_e = w_i;
e = i;
}
}
//end 6
}while(new_start);
return e;
}
/*
* The mex function runs a max-flow min-cut problem.
*/
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
mwIndex i;
mwIndex mrows, ncols;
mwIndex n,nz;
/* sparse matrix */
mwIndex *ia, *ja;
/* source */
mwIndex u;
/* target */
mwIndex v;
/* output data */
double *d, *dt, *pred;
int *int_d;
int *int_dt;
/*
* The current calling pattern is
* bfs_mex(A,u,v)
*
* u and v are the source and target. v = 0 if there is no target
* and the entire search should complete.
*/
const mxArray* arg_matrix;
const mxArray* arg_source;
const mxArray* arg_target;
if (nrhs != 3)
{
mexErrMsgTxt("3 inputs required.");
}
arg_matrix = prhs[0];
arg_source = prhs[1];
arg_target = prhs[2];
/* The first input must be a sparse matrix. */
mrows = mxGetM(arg_matrix);
ncols = mxGetN(arg_matrix);
if (mrows != ncols ||
!mxIsSparse(arg_matrix))
{
mexErrMsgTxt("Input must be a square sparse matrix.");
}
n = mrows;
/* The second input must be a scalar. */
if (mxGetNumberOfElements(arg_source) > 1 || !mxIsDouble(arg_source))
{
mexErrMsgTxt("Invalid scalar.");
}
/* Get the sparse matrix */
/* recall that we've transposed the matrix */
ja = mxGetIr(arg_matrix);
ia = mxGetJc(arg_matrix);
nz = ia[n];
/* Get the scalar */
u = (mwIndex)mxGetScalar(arg_source);
u = u-1;
/* Get the target */
v = (mwIndex)mxGetScalar(arg_target);
if (v == 0) {
/* they want the entire search */
v = n;
} else {
/* they want to look for vertex v */
v -= 1;
}
if (u < 0 || u >= n)
{
mexErrMsgIdAndTxt("matlab_bgl:invalidParameter",
"start vertex (%i) not a valid vertex.", u+1);
}
if (v < 0 || v > n)
{
mexErrMsgIdAndTxt("matlab_bgl:invalidParameter",
"target vertex (%i) not a valid vertex.", v+1);
}
plhs[0] = mxCreateDoubleMatrix(n,1,mxREAL);
plhs[1] = mxCreateDoubleMatrix(n,1,mxREAL);
plhs[2] = mxCreateDoubleMatrix(1,n,mxREAL);
d = mxGetPr(plhs[0]);
dt = mxGetPr(plhs[1]);
pred = mxGetPr(plhs[2]);
int_d = (int*)d;
int_dt = (int*)dt;
for (i=0; i < n; i++)
{
int_d[i]=-1;
int_dt[i]=-1;
}
int_d[u] = 0;
#ifdef _DEBUG
mexPrintf("bfs...");
#endif
breadth_first_search(n, ja, ia,
u, v, (int*)d, (int*)dt, (mbglIndex*)pred);
#ifdef _DEBUG
mexPrintf("done!\n");
#endif
expand_int_to_double((int*)d, d, n, 0.0);
expand_int_to_double((int*)dt, dt, n, 0.0);
expand_index_to_double_zero_equality((mwIndex*)pred, pred, n, 1.0);
#ifdef _DEBUG
mexPrintf("return\n");
#endif
}
/**
* Calculates Shortest Path Related metrics of the graph. The
* function runs a BFS from each node to find out the shortest
* distances to other nodes in the graph. The maximum of this distance
* is called the eccentricity of that node. The maximum eccentricity
* in the graph is called diameter and the minimum eccentricity is
* called the radius of the graph. Central points are those nodes
* having eccentricity equals to radius.
*/
void mitk::ConnectomicsStatisticsCalculator::CalculateShortestPathMetrics()
{
//for all vertices:
VertexIteratorType vi, vi_end;
//store the eccentricities in a vector.
m_VectorOfEccentrities.resize( m_NumberOfVertices );
m_VectorOfEccentrities90.resize( m_NumberOfVertices );
m_VectorOfAveragePathLengths.resize( m_NumberOfVertices );
//assign diameter and radius while iterating over the ecccencirities.
m_Diameter = 0;
m_Diameter90 = 0;
m_Radius = std::numeric_limits<unsigned int>::max();
m_Radius90 = std::numeric_limits<unsigned int>::max();
m_AverageEccentricity = 0.0;
m_AverageEccentricity90 = 0.0;
m_AveragePathLength = 0.0;
//The size of the giant connected component so far.
unsigned int giant_component_size = 0;
VertexDescriptorType radius_src;
//Loop over the vertices
for( boost::tie(vi, vi_end) = boost::vertices( *(m_Network->GetBoostGraph()) ); vi!=vi_end; ++vi)
{
//We are going to start a BFS, initialize the neccessary
//structures for that. Store the distances of nodes from the
//source in distance vector. The maximum distance is stored in
//max. The BFS will start from the node that vi is pointing, that
//is the src is *vi. We also init the distance of the src node to
//itself to 0. size gives the number of nodes discovered during
//this BFS.
std::vector<int> distances( m_NumberOfVertices );
int max_distance = 0;
VertexDescriptorType src = *vi;
distances[src] = 0;
unsigned int size = 0;
breadth_first_search(*(m_Network->GetBoostGraph()), src,
visitor(all_pairs_shortest_recorder<NetworkType>
(&distances[0], max_distance, size)));
// vertex vi has eccentricity equal to max_distance
m_VectorOfEccentrities[src] = max_distance;
//check whether there is any change in the diameter or the radius.
//note that the diameter we are calculating here is also the
//diameter of the giant connected component!
if(m_VectorOfEccentrities[src] > m_Diameter)
{
m_Diameter = m_VectorOfEccentrities[src];
}
//The radius should be calculated on the largest connected
//component, otherwise it is very likely that radius will be 1.
//We change the value of the radius only if this is the giant
//connected component so far. After all the eccentricities are
//found we should loop over this connected component and find the
//minimum eccentricity which is the radius. So we keep the src
//node, so that we can find the connected component later on.
if(size > giant_component_size)
{
giant_component_size = size;
radius_src = src;
}
//Calculate in how many hops we can reach 90 percent of the
//nodes. We store the number of hops we can reach in h hops in the
//bucket vector. That is bucket[h] gives the number of nodes
//reachable in exactly h hops. sum of bucket[i<h] gives the number
//of nodes that are reachable in less than h hops. We also
//calculate sum of the distances from this node to every single
//other node in the graph.
int reachable90 = std::ceil((double)size * 0.9);
std::vector <int> bucket (max_distance+1);
int counter = 0;
for(unsigned int i=0; i<distances.size(); i++)
{
if(distances[i]>0)
{
bucket[distances[i]]++;
m_VectorOfAveragePathLengths[src] += distances[i];
counter ++;
}
}
if(counter > 0)
{
m_VectorOfAveragePathLengths[src] = m_VectorOfAveragePathLengths[src] / counter;
}
int eccentricity90 = 0;
while(reachable90 > 0)
{
eccentricity90 ++;
reachable90 = reachable90 - bucket[eccentricity90];
}
// vertex vi has eccentricity90 equal to eccentricity90
m_VectorOfEccentrities90[src] = eccentricity90;
if(m_VectorOfEccentrities90[src] > m_Diameter90)
{
m_Diameter90 = m_VectorOfEccentrities90[src];
}
}
//We are going to calculate the radius now. We stored the src node
//that when we start a BFS gives the giant connected component, and
//we have the eccentricities calculated. Iterate over the nodes of
//this giant component and find the minimum eccentricity.
std::vector<int> component( m_NumberOfVertices );
boost::connected_components( *(m_Network->GetBoostGraph()), &component[0]);
for (unsigned int i=0; i<component.size(); i++)
{
//If we are in the same component and the radius is not the
//minimum so far store the eccentricity as the radius.
if( component[i] == component[radius_src])
{
if(m_Radius > m_VectorOfEccentrities[i])
{
m_Radius = m_VectorOfEccentrities[i];
}
if(m_Radius90 > m_VectorOfEccentrities90[i])
{
m_Radius90 = m_VectorOfEccentrities90[i];
}
}
}
m_AverageEccentricity = std::accumulate(m_VectorOfEccentrities.begin(),
m_VectorOfEccentrities.end(), 0.0) / m_NumberOfVertices;
m_AverageEccentricity90 = std::accumulate(m_VectorOfEccentrities90.begin(),
m_VectorOfEccentrities90.end(), 0.0) / m_NumberOfVertices;
m_AveragePathLength = std::accumulate(m_VectorOfAveragePathLengths.begin(),
m_VectorOfAveragePathLengths.end(), 0.0) / m_NumberOfVertices;
//calculate Number of Central Points, nodes having eccentricity = radius.
m_NumberOfCentralPoints = 0;
for (boost::tie(vi, vi_end) = boost::vertices( *(m_Network->GetBoostGraph()) ); vi != vi_end; ++vi)
{
if(m_VectorOfEccentrities[*vi] == m_Radius)
{
m_NumberOfCentralPoints++;
}
}
m_RatioOfCentralPoints = (double)m_NumberOfCentralPoints / m_NumberOfVertices;
}
/*
* The mex function runs a max-flow min-cut problem.
*/
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
mwIndex i;
mwIndex mrows, ncols;
mwIndex n,nz;
/* sparse matrix */
mwIndex *ia, *ja;
/* source/sink */
mwIndex u;
/* output data */
double *d, *dt, *pred;
int *int_d;
int *int_dt;
if (nrhs != 2)
{
mexErrMsgTxt("2 inputs required.");
}
/* The first input must be a sparse matrix. */
mrows = mxGetM(prhs[0]);
ncols = mxGetN(prhs[0]);
if (mrows != ncols ||
!mxIsSparse(prhs[0]))
{
mexErrMsgTxt("Input must be a square sparse matrix.");
}
n = mrows;
/* The second input must be a scalar. */
if (mxGetNumberOfElements(prhs[1]) > 1 || !mxIsDouble(prhs[1]))
{
mexErrMsgTxt("Invalid scalar.");
}
/* Get the sparse matrix */
/* recall that we've transposed the matrix */
ja = mxGetIr(prhs[0]);
ia = mxGetJc(prhs[0]);
nz = ia[n];
/* Get the scalar */
u = (mwIndex)mxGetScalar(prhs[1]);
u = u-1;
plhs[0] = mxCreateDoubleMatrix(n,1,mxREAL);
plhs[1] = mxCreateDoubleMatrix(n,1,mxREAL);
plhs[2] = mxCreateDoubleMatrix(1,n,mxREAL);
d = mxGetPr(plhs[0]);
dt = mxGetPr(plhs[1]);
pred = mxGetPr(plhs[2]);
int_d = (int*)d;
int_dt = (int*)dt;
for (i=0; i < n; i++)
{
int_d[i]=-1;
int_dt[i]=-1;
}
int_d[u] = 0;
#ifdef _DEBUG
mexPrintf("bfs...");
#endif
breadth_first_search(n, ja, ia,
u, (int*)d, (int*)dt, (mbglIndex*)pred);
#ifdef _DEBUG
mexPrintf("done!\n");
#endif
expand_int_to_double((int*)d, d, n, 0.0);
expand_int_to_double((int*)dt, dt, n, 0.0);
expand_index_to_double_zero_equality((mwIndex*)pred, pred, n, 1.0);
#ifdef _DEBUG
mexPrintf("return\n");
#endif
}
int main()
{
graph_link gl;
init_graph(&gl);
insert_vertex(&gl, 'A');
insert_vertex(&gl, 'B');
insert_vertex(&gl, 'C');
insert_vertex(&gl, 'D');
insert_vertex(&gl, 'E');
insert_vertex(&gl, 'F');
insert_vertex(&gl, 'G');
insert_vertex(&gl, 'H');
insert_vertex(&gl, 'I');
insert_vertex(&gl, 'J');
insert_vertex(&gl, 'K');
insert_vertex(&gl, 'L');
insert_vertex(&gl, 'M');
insert_edge(&gl, 'A', 'B');
insert_edge(&gl, 'A', 'C');
insert_edge(&gl, 'A', 'F');
insert_edge(&gl, 'A', 'L');
insert_edge(&gl, 'B', 'M');
insert_edge(&gl, 'L', 'J');
insert_edge(&gl, 'L', 'M');
insert_edge(&gl, 'J', 'M');
insert_edge(&gl, 'D', 'E');
insert_edge(&gl, 'G', 'H');
insert_edge(&gl, 'G', 'I');
insert_edge(&gl, 'G', 'K');
insert_edge(&gl, 'H', 'K');
printf("\n");
show_graph(&gl);
printf("Depth First Search(DFS) all nodes of the graph: \n");
depth_first_search(&gl, 'D');
printf("Nul\n");
printf("Breadth First Search(BFS) all nodes of the graph: \n");
breadth_first_search(&gl, 'A');
printf("Nul\n");
printf("Non connect graph DFS: \n");
components(&gl);
printf("Nul\n");
//int v = get_first_neighbor(&gl, 'A');
//printf("The first neighbor node of 'A' is: %d\n", v);
//int v1 = get_next_neighbor(&gl, 'B', 'E');
//printf("The next neighbor node of 'B' and 'E' is: %d\n", v1);
//printf("\n");
//delete_edge(&gl, 'B', 'C');
//show_graph(&gl);
//delete_vertex(&gl, 'C');
destroy_graph(&gl);
}
void evaluateGeodesicDist(GridSpecs grid_specs, std::vector<Polygon_2> polygons,
std::vector<Point> ref_points, IOSpecs io_specs)
{
// -- grid definition --
// no. of rows and columns
int no_rows, no_cols;
no_rows = (int)grid_specs.getGridSpecs().at(0);
no_cols = (int)grid_specs.getGridSpecs().at(1);
// grid points
int no_gpoints;
no_gpoints = (no_rows*no_cols);
// spatial locations of the grid points
std::vector<Point_2> grid_points;
// evaluating the spatial locations of the grid points
initGrid(grid_specs, grid_points);
//--
// -- graph definition --
//
// note that two different graphs need to be considered:
//
// 1) effective graph -
// graph associated with the complementary domain;
// the nodes of this graph do not include the grid points
// associated with the polygon(s);
//
// 2) BGL graph -
// graph processed by the BGL library;
// this graph coincides with the grid;
// the nodes of this graph coincide the grid points;
// the nodes associated with the polygon(s) are nodes
// with no edges, i.e. they are nodes of degree zero;
//
//
// no. of nodes (effective graph) < no. of nodes (BGL graph)
// no. of edges (effective graph) = no. of edges (BGL graph)
//
// grid points IDs associated with the polygon(s)
std::vector<Polygon_gp_id> gpoints_id_pgn;
// grid points IDs associated with the graph
std::vector<int> gpoints_id_graph;
// project the data to the grid;
// evaluate the grid points IDs associated with the polygon(s) and
// those associated with the complementary domain (graph)
projectDataToGrid(grid_points, polygons, gpoints_id_pgn, gpoints_id_graph);
// no. of grid points associated with the polygon
int no_gpoints_png = gpoints_id_pgn.at(0).size();
// no. of grid points associated with the graph
int no_gpoints_graph = gpoints_id_graph.size();
// writing output file `Dreses.dat'
std::string outfile_name_1("Dreses.dat");
OutputProcess_Dreses out1(io_specs.getAbsolutePathName(outfile_name_1));
out1.toOutput(ref_points, polygons,
grid_specs, no_gpoints_png, no_gpoints_graph);
grid_points.clear();
polygons.clear();
// names of the nodes (vertices)
std::vector<std::string> node_names;
// edges
std::vector<Edge> edges;
// evaluating the node names and the edges of the `effective graph'
initGraph(grid_specs, gpoints_id_pgn, gpoints_id_graph, node_names, edges);
gpoints_id_pgn.clear();
gpoints_id_graph.clear();
// number of edges
int no_edges;
no_edges = edges.size();
// weights
float* weights = new float[no_edges];
for (int i=0; i<no_edges; i++) {
weights[i] = grid_specs.getGridSpecs().at(2);
}
// BGL graph
GridGraph g(edges.begin(), edges.end(), weights, no_gpoints);
GridGraph g_copy(edges.begin(), edges.end(), weights, no_gpoints);
//--
#ifdef DEBUG_GRAPH
std::cout << "\n>> debug - graph" << std::endl;
std::cout << "no. of nodes (effective graph): " << node_names.size() << std::endl;
std::cout << "no. of nodes (BGL graph): " << no_gpoints << std::endl;
std::cout << "no. of edges: " << edges.size() << std::endl;
write_graphviz(std::cout, g);
#endif // DEBUG_GRAPH
//--
// parents of the nodes
std::vector<vertex_descriptor> parents(num_vertices(g));
// source node ID
// note that node ID = (grid point ID - 1)
int s_node_id;
s_node_id = (getGridPointID(ref_points.at(0).first, ref_points.at(0).second, grid_specs) - 1);
// source node
vertex_descriptor s_node = vertex(s_node_id, g);
// the parent of `s_node' is `s_node' (distance = 0)
parents[s_node] = s_node;
// distances from the source to each node
// (including the null distances - i.e. the distance from the source to itself
// and the distances from the source to the nodes of degree zero)
vertices_size_type distances[no_gpoints];
std::fill_n(distances, no_gpoints, 0);
// evaluating the distances by using the Breadth-First Search (BFS) algorithm
breadth_first_search(g,
s_node,
visitor(make_bfs_visitor(std::make_pair(record_distances(distances,
on_tree_edge()),
std::make_pair(record_predecessors(&parents[0],
on_tree_edge()),
copy_graph(g_copy,
on_examine_edge())
)
)
)
)
);
// writing output file `distances.dat'
std::string outfile_name_2("distances.dat");
OutputProcess_Distances out2(io_specs.getAbsolutePathName(outfile_name_2));
out2.toOutput(grid_specs, no_gpoints, s_node_id, node_names, distances);
delete [] weights;
}