string DFG::writeDot() { boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS> bfg( mkBoostGraph() ); stringstream ss; write_graphviz(ss, bfg, DFGNodeWriter(*this) ); return ss.str(); }
int main() { typedef b::adjacency_list<b::listS, b::vecS, b::undirectedS, vert, edge> Graph; Graph g; b::generate_random_graph(g, 10 /*100*/, 5 /*20*/, rng); write_graphviz(std::cout, g, boost::make_label_writer(boost::get(&vert::name, g)), make_edge_writer(boost::get(&edge::weight, g), boost::get(&edge::capacity, g))); }
inline void write_graphviz(std::ostream& out, const Graph& g, VertexPropertiesWriter vpw, EdgePropertiesWriter epw, GraphPropertiesWriter gpw BOOST_GRAPH_ENABLE_IF_MODELS_PARM(Graph,vertex_list_graph_tag)) { write_graphviz(out, g, vpw, epw, gpw, get(vertex_index, g)); }
void dump_dot_file(string fname, Graph &graphFOF) { if(true) { //////////////////////////////////////////////// // write dynamic_properties dp; dp.property("weight", get(edge_weight, graphFOF)); dp.property("node_id", get(vertex_index, graphFOF)); std::ofstream ofs( fname.c_str()); std::cout << "write_graphviz:....."; write_graphviz(ofs, graphFOF, dp); ofs.close(); std::cout << "Done" << std::endl; }else ////////////////// WRITE BY HAND ///////////// { /////////////////////////////////////////// property_map < Graph, edge_weight_t >::type weight = get(edge_weight, graphFOF); std::vector < Edge > spanning_tree; kruskal_minimum_spanning_tree(graphFOF, std::back_inserter(spanning_tree)); std::cout << "Print the edges in the MST:" << std::endl; for (std::vector < Edge >::iterator ei = spanning_tree.begin(); ei != spanning_tree.end(); ++ei) { std::cout << source(*ei, graphFOF) << " <--> " << target(*ei, graphFOF) << " with weight of " << weight[*ei] << std::endl; } //////////////////////////////////////////////////////// std::ofstream fout("kruskal.dot"); fout << "graph A {\n" << " rankdir=LR\n" << " size=\"60,60\"\n" << " ratio=\"filled\"\n" << " edge[style=\"bold\"]\n" << " node[shape=\"circle\"]\n"; graph_traits<Graph>::edge_iterator eiter, eiter_end; for (tie(eiter, eiter_end) = edges(graphFOF); eiter != eiter_end; ++eiter) { fout << source(*eiter, graphFOF) << " -- " << target(*eiter, graphFOF); if (std::find(spanning_tree.begin(), spanning_tree.end(), *eiter) != spanning_tree.end()) fout << "[color=\"blue\", label=\"" << get(edge_weight, graphFOF, *eiter) << "\"];\n"; else fout << "[color=\"red\", label=\"" << get(edge_weight, graphFOF, *eiter) << "\"];\n"; } fout << "}\n"; fout.close(); } }
int main(int argc, char ** argv) { if(argc>1) { // Test with the normal order Graph g(0); vertex_index_map m_index = get(boost::vertex_index, g); vertex_name_map m_name = get(boost::vertex_name, g); vertex_color_map m_color = get(boost::vertex_color, g); boost::dynamic_properties dp; // dp.property("node_id", m_index); // dp.property("label", m_name); dp.property("node_id", m_name); std::fstream infile(argv[1], std::ios::in); bool status = boost::read_graphviz(infile, g, dp, std::string("node_id")); std::vector<vertices_size_type> color_vec(num_vertices(g)); boost::iterator_property_map<vertices_size_type*, vertex_index_map> color(&color_vec.front(), boost::get(boost::vertex_index, g)); vertices_size_type num_colors = boost::sequential_vertex_coloring(g, color); int k=0; boost::graph_traits<Graph>::vertex_iterator v, v_end; for(boost::tie(v,v_end) = boost::vertices(g); v!=v_end; v++) { m_color[*v]=static_cast<boost::default_color_type>(color_vec[k++]); } write_graphviz(std::cout, g, graph_coloring::make_label_writer(m_name, m_color), boost::default_writer(), graph_coloring::graph_property_with_label_writer<vertices_size_type>(num_colors)); } else std::cout << "Put right args list!" << std::endl; return 0; }
void parse_and_write_graph(std::istream & is) { parsing::parser p(is); parsing::node * tree; try { tree = p.parse(); } catch (std::exception & e) { std::cerr << "Unhandled exception: " << e.what() << std::endl; return; } std::vector<const char *> names; std::vector<edge_t> edges; dfs(tree, edges, names); graph_t graph(edges.begin(), edges.end(), names.size()); write_graphviz(std::cout, graph, boost::make_label_writer(names.data())); }
int Graph::toGraphviz(string filename){ ofstream dotFile (filename.c_str()); if( !dotFile.is_open()){ return -1; } vector<string> ids; vector< pair< double, double> > locs; vector<nodeType> types; map< edge_d,string> edge_labels; // cout << "Num vertices " << num_vertices(*this) << endl; // property_map<MyGraphType, vertex_name_t>::type idmap = get(vertex_name_t(),*this); graph_traits<MyGraphType>::vertex_iterator vi, vi_end, next; tie(vi, vi_end) = vertices(*this); for (next = vi; next != vi_end; next++) { // printf("Vertex id [%d] = %s\n",*next,idmap[*next].c_str()); ids.push_back((*this)[*next].id); locs.push_back( make_pair( (*this)[*next].x, (*this)[*next].y)); types.push_back((*this)[*next].t); } graph_traits<MyGraphType>::edge_iterator ei,e_end,e_next; graph_traits<MyGraphType>::edge_descriptor e; tie(ei, e_end) = edges( (*this)); for(e_next = ei; e_next != e_end; e_next++) { edge_labels[*e_next] = (*this)[*e_next].label; } write_graphviz(dotFile, *this,make_position_writer(ids,locs,types),make_edge_writer(edge_labels),graph_writer()); return 0; }
void Internal_Graph::output() { std::ofstream dotFile("dependencies.dot"); write_graphviz(dotFile, g, graphnode_property_writer < VertexNodeMap > (*NodeMap)); dotFile.flush(); }
void WriteDot(const DirectedGraph &g, std::string filename) { std::ofstream outfile(filename.c_str()); write_graphviz(outfile, g); }
void FamilyTree::saveGraphViz(const char* iFileName) { std::ofstream ofs(iFileName, std::ofstream::out); LabelWriter<graph> lw(mGraph); write_graphviz(ofs, mGraph, lw); }
void k_shell_snapshot(Graph& G, vector<int>& core, int core_num, string filename) { srand(time(NULL)); vector<int> keep_core; int size = num_vertices(G); // long edgeCount = num_edges(G); vector<float> s(size,0); vector<float> p; vector<int> count(size,0); vector<int> indOrig(size,0); int ind; //float alpha = .2; //float eps = .001; for(int i=0;i<core.size();i++) { if(core[i]==core_num) keep_core.push_back(i); } int r = 0; if(keep_core.size()>0) r = rand() % keep_core.size(); else return; ind = keep_core[r]; s[ind] = 1; /* p = approxPR(G,s,alpha,eps); for(int j=0; j<size; j++) { Vert v = vertex(j,G); count[j] = j; graph_traits<Graph>::degree_size_type outDegree = out_degree(v,G); p[j] = p[j]/outDegree; } sort(count.begin(),count.end(),compareInd<vector<float>&>(p)); for(int j=0;j<size;j++) indOrig[count[j]] = j; long vol = 0; long out = 0; int maxC = 200; float c = 1.0; int cutInd = 0; for(int j=0; j<maxC; j++) { // cout<<"Comm: "<<j<<"\n"; vector<int>::iterator it; Vert v = vertex(count[j],G); // cout<<"index: "<<index<<"\n"; //Out edge iterators graph_traits<Graph>::out_edge_iterator out_i, out_e; //Create index map for Graph property_map<Graph, vertex_index_t>::type index = get(vertex_index, G); //Count outgoing edges for v graph_traits<Graph>::degree_size_type outDegree = out_degree(v,G); //update edges leaving cut set (out) out += outDegree; //update internal volume of cut set (vol) vol += outDegree; //Iterate over out going edges of v for(tie(out_i,out_e)=out_edges(v,G);out_i!=out_e;++out_i) { Edge e = *out_i; // cout<<"node: "<<node1<<"\n"; Vert vt = target(e,G); //Check if edge crosses set boundary, if so, update out and vol accordingly if(indOrig[index[vt]]<j && indOrig[index[vt]]>=0) { out -= 2; //note that 2 is due to outgoing/incoming edge as G is a directed graph representation of an undirected graph. vol--; } } //cout<<edgeCount<<"\n"; //Pick minimum of cut set and complement volume if(vol>(edgeCount-vol)) vol = edgeCount - vol; // cout<<"Comm size "<<j<<": "<<ctime2-ctime1<<"\n"; //conductance c is now given by: c = out/vol float tempC = float(out)/vol; //Check if this beats previous minimum if(tempC<c) { c = tempC; cutInd = j; } } for(int j=0;j<=cutInd;j++) S.push_back(vertex(count[j],G)); */ vector<Vert> S; for(int j=0;j<=core.size();j++) { if(core[j]==core_num) S.push_back(vertex(j,G)); } Graph localG = subset(G,S); //localG = connected(localG,-1); adjacency_list<vecS, vecS, undirectedS> localUGraph; copy_graph(localG,localUGraph); ofstream outViz; outViz.open(filename.c_str()); write_graphviz(outViz,localUGraph); outViz.close(); }
void write_graphviz(const std::string& filename, const subgraph<Graph>& g) { std::ofstream out(filename.c_str()); write_graphviz(out, g); }
inline void write_graphviz(std::ostream& out, const Graph& g) { default_writer dw; default_writer gw; write_graphviz(out, g, dw, dw, gw); }
void write_graphviz( const aig_graph& aig, const std::string& layout_algorithm, const std::string& render_format, std::ostream& os ) { std::map< aig_node, gv_node > node_map; std::map< aig_edge, gv_edge > edge_map; write_graphviz( aig, layout_algorithm, render_format, node_map, edge_map, os ); }
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; }
void DecayTree::print(std::ostream& os) const { // boost::associative_property_map<IndexNameMap> propmapIndex(index_label_map); VertexWriter vertex_writer(decay_tree_); write_graphviz(os, decay_tree_, vertex_writer); }
inline void write_graphviz(std::ostream& out, const Graph& g, VertexWriter vw, EdgeWriter ew) { default_writer gw; write_graphviz(out, g, vw, ew, gw); }