| <HTML> |
| |
| <!-- |
| Copyright (c) Lie-Quan Lee and Jeremy Siek 2000, 2001 |
| |
| Distributed under the Boost Software License, Version 1.0. |
| (See accompanying file LICENSE_1_0.txt or copy at |
| http://www.boost.org/LICENSE_1_0.txt) |
| --> |
| <Head> |
| <Title>Boost Graph Library: write graphviz</Title> |
| <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" |
| ALINK="#ff0000"> |
| <IMG SRC="../../../boost.png" |
| ALT="C++ Boost" width="277" height="86"> |
| |
| <BR Clear> |
| |
| <H1><A NAME="sec:write-graphviz"> |
| <TT>write_graphviz</TT> |
| </H1> |
| |
| |
| <pre> |
| // Output graph structure without properties. |
| template < typename VertexAndEdgeListGraph > |
| void |
| write_graphviz(std::ostream& out, const VertexAndEdgeListGraph& g); |
| |
| // Graph structure with customized property output |
| template < typename VertexAndEdgeListGraph, typename VertexPropertyWriter > |
| void |
| write_graphviz(std::ostream& out, const VertexAndEdgeListGraph& g, |
| VertexPropertyWriter vpw); |
| |
| template < typename VertexAndEdgeListGraph, typename VertexPropertyWriter, |
| typename EdgePropertyWriter > |
| void |
| write_graphviz(std::ostream& out, const VertexAndEdgeListGraph& g, |
| VertexPropertyWriter vpw, EdgePropertyWriter epw); |
| |
| template < typename VertexAndEdgeListGraph, typename VertexPropertyWriter, |
| typename EdgePropertyWriter, typename GraphPropertyWriter > |
| void |
| write_graphviz(std::ostream& out, const VertexAndEdgeListGraph& g, |
| VertexPropertyWriter vpw, EdgePropertyWriter epw, |
| GraphPropertyWriter gpw); |
| |
| template < typename VertexAndEdgeListGraph, typename VertexPropertyWriter, |
| typename EdgePropertyWriter, typename GraphPropertyWriter, |
| typename VertexID > |
| void |
| write_graphviz(std::ostream& out, const VertexAndEdgeListGraph& g, |
| VertexPropertyWriter vpw, EdgePropertyWriter epw, |
| GraphPropertyWriter gpw, VertexID vertex_id); |
| |
| // Graph structure with dynamic property output |
| template<typename Graph> |
| void |
| write_graphviz_dp(std::ostream& out, const Graph& g, |
| const dynamic_properties& dp, |
| const std::string& node_id = "node_id"); |
| |
| template<typename Graph, typename VertexID> |
| void |
| write_graphviz_dp(std::ostream& out, const Graph& g, |
| const dynamic_properties& dp, const std::string& node_id, |
| VertexID vertex_id); |
| </pre> |
| |
| <p> |
| This is to write a BGL graph object into an output stream in graphviz dot format |
| so that users can make use of <a href="http://www.research.att.com/sw/tools/graphviz/">AT&T graphviz</a> |
| to draw a picture with nice layout. |
| <p> |
| The first version with two parameters will write the graph into a |
| <tt>std::ostream</tt> where each vertex is represented by its numerical vertex |
| ID. If users have either interior or exterior properties for each vertex |
| in the graph, the second version above provides a way to print those |
| properties into the graphviz format file. For example, if each vertex |
| in the graph has its label through property map object <tt>name</tt>, |
| users can use the second version: |
| <pre> |
| write_graph(out, g, make_label_writer(name)); |
| </pre> |
| The utility function <tt>make_label_writer</tt> returns a predefined |
| <a href="./write-graphviz.html#concept:PropertyWriter">PropertyWriter</a> for |
| vertex labels. Similarly, the third |
| version and fourth version require vertex |
| <a href="./write-graphviz.html#concept:PropertyWriter">PropertyWriter</a>, edge |
| <a href="./write-graphviz.html#concept:PropertyWriter">PropertyWriter</a>, and graph |
| <a href="./write-graphviz.html#concept:PropertyWriter">PropertyWriter</a>, |
| respectively. |
| |
| <p> The two overloads of <code>write_graphviz_dp</code> will emit |
| all of the properties stored in the <a |
| href="../../property_map/doc/dynamic_property_map.html"><code>dynamic_properties</a></code> |
| object, thereby retaining the properties that have been read in |
| through the dual function <a |
| href="read_graphviz.html"><code>read_graphviz</code></a>. With these |
| overloads, <code>node_id</code> is the name of the property map that |
| stores the IDs of each node for use in the output (if it is stored in |
| the <code>dynamic_properties</code> structure); alternatively, one may |
| provide an arbitrary property map for <code>vertex_id</code> giving the |
| vertex identifiers. In this case, the name |
| of <code>node_id</code> must still be supplied to suppress its |
| output as a label of the vertices.</p> |
| |
| <H3>Where Defined</H3> |
| |
| <P> |
| <a href="../../../boost/graph/graphviz.hpp"><TT>boost/graph/graphviz.hpp</TT></a> |
| |
| <h3><A NAME="concept:PropertyWriter"> |
| <tt>PropertyWriter</tt> |
| </h3> |
| |
| PropertyWriter is used in the <tt>write_graphviz</tt> function to |
| print vertex, edge or graph properties. There are two types of |
| PropertyWriter. One is for a vertex or edge. The other is for a graph. |
| Thus, users could easily extend the <tt>write_graphviz</tt> function |
| by creating their own <a href="./write-graphviz.html#concept:PropertyWriter">PropertyWriter</a> only. |
| <p> |
| A <a href="./write-graphviz.html#concept:PropertyWriter">PropertyWriter</a> |
| for vertices or edges is a functor which can be called with two parameters: |
| <tt>std::ostream</tt> and either a vertex or an edge descriptor. It should output a |
| pair of brackets with a series of assigments "name=value" inside. |
| Each assignment should be separated either with space, with comma, or with semicolon. |
| The following functor, provided by BGL, is the example of PropertyWriter for |
| vertices or edges. It is used to print the label of each vertex or edge. |
| <pre> |
| template <class Name> |
| class label_writer { |
| public: |
| label_writer(Name _name) : name(_name) {} |
| template <class VertexOrEdge> |
| void operator()(std::ostream& out, const VertexOrEdge& v) const { |
| out << "[label=\"" << name[v] << "\"]"; |
| } |
| private: |
| Name name; |
| }; |
| </pre> |
| |
| <p> |
| A function to conveniently create this writer is provided: |
| <pre> |
| template < class Name > |
| label_writer<Name> |
| make_label_writer(Name n); |
| </pre> |
| |
| <p> |
| A <a href="./write-graphviz.html#concept:PropertyWriter">PropertyWriter</a> |
| for graphs is a functor which is called with one parameter of type |
| <tt>std::ostream</tt> and should print a series of graph properties. The following |
| code excerpt is an example of a PropertyWriter for a graph. |
| <pre> |
| struct sample_graph_writer { |
| void operator()(std::ostream& out) const { |
| out << "graph [bgcolor=lightgrey]" << std::endl; |
| out << "node [shape=circle color=white]" << std::endl; |
| out << "edge [style=dashed]" << std::endl; |
| } |
| }; |
| } |
| </pre> |
| |
| <p> |
| There exists a class <tt>default_writer</tt>, which can be used as both |
| vertex/edge and graph property writer, and does nothing. It comes handy when |
| only edge properties must be written, but function interface requries to pass |
| vertex property writer as well. |
| |
| <h3>Parameters</h3> |
| OUT: <tt>std::ostream& out</tt> |
| <blockquote> |
| A standard <tt>std::ostream</tt> object. |
| </blockquote> |
| |
| IN: <tt>VertexAndEdgeListGraph& g</tt> |
| <blockquote> |
| A directed or undirected graph. The graph's type must be a model of |
| <a href="./VertexAndEdgeListGraph.html">VertexAndEdgeListGraph</a>. Also the |
| graph must have an internal <tt>vertex_index</tt> property map. |
| </blockquote> |
| |
| IN: <tt>VertexPropertyWriter vpw</tt> |
| <blockquote> |
| A functor that models <a href="./write-graphviz.html#concept:PropertyWriter">PropertyWriter</a> concept to print |
| properties of a vertex.<br> |
| <b>Default</b>: <tt>default_writer()</tt> |
| </blockquote> |
| |
| IN: <tt>EdgePropertyWriter epw</tt> |
| <blockquote> |
| A functor that models <a href="./write-graphviz.html#concept:PropertyWriter">PropertyWriter</a> concept to print |
| properties of an edge.<br> |
| <b>Default</b>: <tt>default_writer()</tt> |
| </blockquote> |
| |
| IN: <tt>GraphPropertyWriter epw</tt> |
| <blockquote> |
| A functor that models <a href="./write-graphviz.html#concept:PropertyWriter">PropertyWriter</a> concept to print |
| properties of a graph.<br> |
| <b>Default</b>: <tt>default_writer()</tt> |
| </blockquote> |
| |
| IN: <tt>dynamic_properties& dp</tt> |
| <blockquote> |
| Contains all of the vertex and edge properties that should be |
| emitted by the GraphViz writer. |
| </blockquote> |
| |
| IN: <tt>const std::string& node_id</tt> |
| <blockquote> |
| The name of the property map that provides identifiers for the |
| vertices in the graph.<br> |
| <b>Default</b>: <tt>"node_id"</tt> |
| </blockquote> |
| |
| IN: <tt>VertexID vertex_id</tt> |
| <blockquote> |
| A property map that models <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a> whose key type is the vertex descriptor of the graph and whose value type can be written to a stream. The value should be a unique descriptor that can be used to name a node in a Graphviz file (so it should not, for instance, have any spaces in it).<br> |
| <b>Default</b>: If no <code>dynamic_properties</code> object is provided, <tt>get(vertex_index, g)</tt>. Otherwise, a dynamic property map that accesses the property map named <code>node_id</code>. |
| </blockquote> |
| <H3> |
| Example |
| </H3> |
| |
| This example demonstrates using BGL-graphviz interface to write |
| a BGL graph into a graphviz format file. |
| |
| <pre> |
| #include <boost/graph/graphviz.hpp> |
| |
| enum files_e { dax_h, yow_h, boz_h, zow_h, foo_cpp, |
| foo_o, bar_cpp, bar_o, libfoobar_a, |
| zig_cpp, zig_o, zag_cpp, zag_o, |
| libzigzag_a, killerapp, N }; |
| const char* name[] = { "dax.h", "yow.h", "boz.h", "zow.h", "foo.cpp", |
| "foo.o", "bar.cpp", "bar.o", "libfoobar.a", |
| "zig.cpp", "zig.o", "zag.cpp", "zag.o", |
| "libzigzag.a", "killerapp" }; |
| |
| int main(int,char*[]) |
| { |
| |
| typedef pair<int,int> Edge; |
| Edge used_by[] = { |
| Edge(dax_h, foo_cpp), Edge(dax_h, bar_cpp), Edge(dax_h, yow_h), |
| Edge(yow_h, bar_cpp), Edge(yow_h, zag_cpp), |
| Edge(boz_h, bar_cpp), Edge(boz_h, zig_cpp), Edge(boz_h, zag_cpp), |
| Edge(zow_h, foo_cpp), |
| Edge(foo_cpp, foo_o), |
| Edge(foo_o, libfoobar_a), |
| Edge(bar_cpp, bar_o), |
| Edge(bar_o, libfoobar_a), |
| Edge(libfoobar_a, libzigzag_a), |
| Edge(zig_cpp, zig_o), |
| Edge(zig_o, libzigzag_a), |
| Edge(zag_cpp, zag_o), |
| Edge(zag_o, libzigzag_a), |
| Edge(libzigzag_a, killerapp) |
| }; |
| const int nedges = sizeof(used_by)/sizeof(Edge); |
| int weights[nedges]; |
| std::fill(weights, weights + nedges, 1); |
| |
| using namespace boost; |
| |
| typedef adjacency_list< vecS, vecS, directedS, |
| property< vertex_color_t, default_color_type >, |
| property< edge_weight_t, int > |
| > Graph; |
| Graph g(used_by, used_by + nedges, weights, N); |
| |
| write_graphviz(std::cout, g, make_label_writer(name)); |
| } |
| </pre> |
| |
| The output will be: |
| <pre> |
| digraph G { |
| 0 -> 4; |
| 0 -> 6; |
| 0 -> 1; |
| 0 [label="dax.h"]; |
| 1 -> 6; |
| 1 -> 11; |
| 1 [label="yow.h"]; |
| 2 -> 6; |
| 2 -> 9; |
| 2 -> 11; |
| 2 [label="boz.h"]; |
| 3 -> 4; |
| 3 [label="zow.h"]; |
| 4 -> 5; |
| 4 [label="foo.cpp"]; |
| 5 -> 8; |
| 5 [label="foo.o"]; |
| 6 -> 7; |
| 6 [label="bar.cpp"]; |
| 7 -> 8; |
| 7 [label="bar.o"]; |
| 8 -> 13; |
| 8 [label="libfoobar.a"]; |
| 9 -> 10; |
| 9 [label="zig.cpp"]; |
| 10 -> 13; |
| 10 [label="zig.o"]; |
| 11 -> 12; |
| 11 [label="zag.cpp"]; |
| 12 -> 13; |
| 12 [label="zag.o"]; |
| 13 -> 14; |
| 13 [label="libzigzag.a"]; |
| 14; |
| 14 [label="killerapp"]; |
| 6 -> 0; |
| } |
| </pre> |
| |
| <p>The examples directory contains an <a |
| href="../example/graphviz.cpp">example using |
| <code>dynamic_properties</code></a>.</p> |
| |
| <h3>See Also</h3> |
| |
| <a href="./read_graphviz.html"><tt>read_graphviz</tt></a> |
| |
| <br> |
| <HR> |
| <TABLE> |
| <TR valign=top> |
| <TD nowrap>Copyright © 2000-2001</TD><TD> |
| <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br> |
| <A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>) |
| </TD></TR></TABLE> |
| |
| </BODY> |
| </HTML> |
