RhodeCode

/// \ingroup demos

/// \file

///

/// This demo program shows examples how to  use the function \ref

/// graphToEps(). It takes no input but simply creates  six

/// <tt>.eps</tt> files demonstrating the capability of \ref

/// how to handle parallel egdes, how to change the properties (like

/// color, shape, size, title etc.) of nodes and arcs individually

/// \include graph_to_eps_demo.cc

#include<lemon/list_graph.h>

#include<lemon/graph_utils.h>

using namespace std;

  Palette paletteW(true);

  ListDigraph g;

  typedef ListDigraph::Node Node;

  ListDigraph::NodeMap<int> colors(g);

  ListDigraph::NodeMap<int> shapes(g);

  ListDigraph::ArcMap<int> widths(g);

  coords[n5]=Point(85,60);  sizes[n5]=3; colors[n5]=5; shapes[n5]=2;

  IdMap<ListDigraph,Node> id(g);

    coords(coords).

    title("Sample .eps figure").

    run();

    coords(coords).

    title("Sample .eps figure").

    absoluteNodeSizes().absoluteArcWidths().

    nodeScale(2).nodeSizes(sizes).

    nodeShapes(shapes).

    nodeColors(composeMap(palette,colors)).

    arcWidthScale(.4).arcWidths(widths).

    nodeTexts(id).nodeTextSize(3).

    run();

    title("Sample .eps figure (with arrowheads)").

    absoluteNodeSizes().absoluteArcWidths().

    nodeColors(composeMap(palette,colors)).

    nodeScale(2).nodeSizes(sizes).

    nodeShapes(shapes).

    arcWidthScale(.4).arcWidths(widths).

    nodeTexts(id).nodeTextSize(3).

    run();

  cout << "Create 'graph_to_eps_demo_out_par.eps'" << endl;

    //scale(10).

    title("Sample .eps figure (parallel arcs)").

    absoluteNodeSizes().absoluteArcWidths().

    nodeShapes(shapes).

    nodeScale(2).nodeSizes(sizes).

    nodeColors(composeMap(palette,colors)).

    arcWidthScale(.4).arcWidths(widths).

    nodeTexts(id).nodeTextSize(3).

    enableParallel().parArcDist(1.5).

    run();

    title("Sample .eps figure (parallel arcs and arrowheads)").

    absoluteNodeSizes().absoluteArcWidths().

    nodeScale(2).nodeSizes(sizes).

    nodeShapes(shapes).

    nodeColors(composeMap(palette,colors)).

    arcWidthScale(.3).arcWidths(widths).

    nodeTexts(id).nodeTextSize(3).

    run();

    title("Sample .eps figure (fits to A4)").

    absoluteNodeSizes().absoluteArcWidths().

    nodeScale(2).nodeSizes(sizes).

    nodeShapes(shapes).

    nodeColors(composeMap(palette,colors)).

    arcWidthScale(.3).arcWidths(widths).

    nodeTexts(id).nodeTextSize(3).

    run();

  ListDigraph h;

  ListDigraph::NodeMap<int> hcolors(h);

  for(int i=0;i<int(paletteW.size());i++) {

    Node n=h.addNode();

    hcolors[n]=i;

  }

    title("Sample .eps figure (Palette demo)").

    coords(hcoords).

    absoluteNodeSizes().absoluteArcWidths().

    nodeScale(.45).

    distantColorNodeTexts().

    nodeTexts(hcolors).nodeTextSize(.6).

    nodeColors(composeMap(paletteW,hcolors)).

    run();

}

    ///Constructor

    ///provided initial colors (\c true) or not (\c false). If it is true,

    ///white will be assigned to \c 0.

    ///the default color configuration is set up (26 color plus optionaly the

    ///white).  If \c num is less then 26/27 then the default color

        colors.push_back(Color(.5,0,1));

      } while(int(colors.size())<num);

      if(num>=0) colors.resize(num);

    }

      colors[i%colors.size()]=c;

    }

    void add(const Color &c) 

    {

    }

    void resize(int s) { colors.resize(s);}

    ///Returns the number of the existing colors.

///Default traits class of \ref GraphToEps

///

///\c G is the type of the underlying graph.

  ///Constructor

  ///\param _pros If it is \c true, then the \c ostream referenced by \c _os

  ///will be explicitly deallocated by the destructor.

  DefaultGraphToEpsTraits(const G &_g,std::ostream& _os=std::cout,

			  bool _pros=false) :

///Auxiliary class to implement the named parameters of \ref graphToEps()

template<class T> class GraphToEps : public T 

{

  ///Node shapes

  ///

  enum NodeShapes { 

  ///Sets the map of the node coordinates.

  ///\ref dim2::Point "dim2::Point<int>" values. 

  template<class X> GraphToEps<CoordsTraits<X> > coords(const X &x) {

  ///Sets the map of the node sizes

  ///\param x must be a node map with \c double (or convertible) values. 

  template<class X> GraphToEps<NodeSizesTraits<X> > nodeSizes(const X &x)

  ///Sets the text printed on the nodes

  ///\param x must be a node map with type that can be pushed to a standard

  template<class X> GraphToEps<NodeTextsTraits<X> > nodeTexts(const X &x)

  {

  ///With this command it is possible to insert a verbatim PostScript

  ///block to the nodes.

  ///the PostScript block inserted.

  ///

  ///

  ///\param x must be a node map with type that can be pushed to a standard

  ///

  ///\sa nodePsTextsPreamble()

  ///Sets the map of the arc widths

  ///\param x must be an arc map with \c double (or convertible) values. 

  template<class X> GraphToEps<ArcWidthsTraits<X> > arcWidths(const X &x)

  ///Sets the map of the node colors

  ///\param x must be a node map with \ref Color values.

  ///

  ///Sets the map of the node text colors

  ///\param x must be a node map with \ref Color values. 

  ///

  ///Sets the map of the arc colors

  ///\param x must be an arc map with \ref Color values. 

  ///

  /// \sa autoNodeScale()

  GraphToEps<T> &nodeScale(double d=.01) {_nodeScale=d;return *this;}

  ///

  ///\sa nodeScale()

  }

  ///

  ///\sa nodeScale()

  ///Negates the Y coordinates.

  GraphToEps<T> &negateY(bool b=true) {

    _negY=b;return *this;

  }

  ///Sets a global scale factor for the whole picture

  GraphToEps<T> &scale(double d) {_scale=d;return *this;}

  ///Sets the width of the border around the picture

  GraphToEps<T> &border(double b=10) {_xBorder=_yBorder=b;return *this;}

  ///Sets the width of the border around the picture

  GraphToEps<T> &border(double x, double y) {

    _xBorder=x;_yBorder=y;return *this;

  }

  ///Sets whether to draw arrows

  GraphToEps<T> &drawArrows(bool b=true) {_drawArrows=b;return *this;}

  ///Sets the length of the arrowheads

  GraphToEps<T> &arrowLength(double d=1.0) {_arrowLength*=d;return *this;}

  ///Sets the width of the arrowheads

  GraphToEps<T> &arrowWidth(double d=.3) {_arrowWidth*=d;return *this;}

  ///Scales the drawing to fit to A4 page

  GraphToEps<T> &scaleToA4() {_scaleToA4=true;return *this;}

  ///Enables parallel arcs

  GraphToEps<T> &enableParallel(bool b=true) {_enableParallel=b;return *this;}

  GraphToEps<T> &parArcDist(double d) {_parArcDist*=d;return *this;}

  ///Hides the arcs

  GraphToEps<T> &hideArcs(bool b=true) {_showArcs=!b;return *this;}

  ///Hides the nodes

  GraphToEps<T> &hideNodes(bool b=true) {_showNodes=!b;return *this;}

  ///Sets the size of the node texts

  GraphToEps<T> &nodeTextSize(double d) {_nodeTextSize=d;return *this;}

  ///Sets the color of the node texts to be as different from the node color

  GraphToEps<T> &distantColorNodeTexts()

  {_nodeTextColorType=DIST_COL;return *this;}

  ///Sets the color of the node texts to be black or white according to

  GraphToEps<T> &distantBWNodeTexts()

  {_nodeTextColorType=DIST_BW;return *this;}

    _nodePsTextsPreamble=str ;return *this;

  }

  ///

  ///This setting is the default for undirected graphs.

   GraphToEps<T> &undirected(bool b=true) {_undirected=b;return *this;}

  ///Use it to show the edges as a pair of directed ones.

  ///

    if(_title.size()>0) os << "%%Title: " << _title << '\n';

     if(_copyright.size()>0) os << "%%Copyright: " << _copyright << '\n';

    os << "%%Creator: LEMON, graphToEps()\n";

      for(ArcIt e(g);e!=INVALID;++e)

	max_w=std::max(double(_arcWidths[e]),max_w);

      if(max_w>EPSILON) {

	_arcWidthScale/=max_w;

      for(NodeIt n(g);n!=INVALID;++n)

	max_s=std::max(double(_nodeSizes[n]),max_s);

      if(max_s>EPSILON) {

	_nodeScale/=max_s;

  ///An alias for arcWidths()

  template<class X> GraphToEps<ArcWidthsTraits<X> > edgeWidths(const X &x)

  {

  ///An alias for arcColors()

  template<class X> GraphToEps<ArcColorsTraits<X> >

  edgeColors(const X &x)

  ///An alias for arcWidthScale()

  GraphToEps<T> &edgeWidthScale(double d) {return arcWidthScale(d);}

  ///An alias for autoArcWidthScale()

  GraphToEps<T> &autoEdgeWidthScale(bool b=true)

  {

  ///An alias for absoluteArcWidths()

  GraphToEps<T> &absoluteEdgeWidths(bool b=true)

  {

  ///An alias for parArcDist()

  GraphToEps<T> &parEdgeDist(double d) {return parArcDist(d);}

  ///An alias for hideArcs()

  GraphToEps<T> &hideEdges(bool b=true) {return hideArcs(b);}

///\ingroup eps_io

///Generates an EPS file from a graph.

///

///This function also has a lot of

///              .arcWidthScale(.4).run();

///\endcode

///\warning Don't forget to put the \ref GraphToEps::run() "run()"

///to the end of the parameter list.