RhodeCode

/// \file

///

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

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

#include<lemon/list_graph.h>

#include<lemon/graph_utils.h>

  ListDigraph g;

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

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

    coords(coords).

    title("Sample .eps figure").

    run();

    coords(coords).

    title("Sample .eps figure").

    absoluteNodeSizes().absoluteArcWidths().

    nodeColors(composeMap(palette,colors)).

    arcWidthScale(.4).arcWidths(widths).

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

    absoluteNodeSizes().absoluteArcWidths().

    nodeShapes(shapes).

    arcWidthScale(.4).arcWidths(widths).

    nodeTexts(id).nodeTextSize(3).

    run();

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

    absoluteNodeSizes().absoluteArcWidths().

    nodeColors(composeMap(palette,colors)).

    arcWidthScale(.4).arcWidths(widths).

    run();

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

    absoluteNodeSizes().absoluteArcWidths().

    nodeColors(composeMap(palette,colors)).

    arcWidthScale(.3).arcWidths(widths).

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

    absoluteNodeSizes().absoluteArcWidths().

    nodeColors(composeMap(palette,colors)).

    arcWidthScale(.3).arcWidths(widths).

  ListDigraph h;

    Node n=h.addNode();

    hcolors[n]=i;

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

    coords(hcoords).

    distantColorNodeTexts().

    nodeTexts(hcolors).nodeTextSize(.6).

    run();

}

    ///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

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

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

    }

    void add(const Color &c) 

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

///

  ///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,

template<class T> class GraphToEps : public T 

  ///

  ///Sets the map of the node coordinates.

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

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

  ///\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)

  ///block to the nodes.

  ///the PostScript block inserted.

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

  ///

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

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

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

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

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

  ///

  ///

  ///Negates the Y coordinates.

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

  ///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) {

  ///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()

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

  GraphToEps<T> &distantBWNodeTexts()

  }

  ///

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

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

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

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

      if(max_w>EPSILON) {

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

      if(max_s>EPSILON) {

  ///An alias for arcWidths()

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

  ///An alias for arcColors()

  template<class X> GraphToEps<ArcColorsTraits<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);}

///Generates an EPS file from a graph.

///

///\endcode

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