RhodeCode

  ///provided set of colors.

  ///

  ///This is a true \ref concepts::ReferenceMap "reference map", so

  ///you can also change the actual colors.

  class Palette : public MapBase<int,Color>

  {

    std::vector<Color> colors;

  public:

    ///Constructor

    ///Constructor 

    ///\param num the number of the allocated colors. If it is \c -1,

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

    ///list is cut. Otherwise the color list is filled repeatedly with

    ///the default color list.  (The colors can be changed later on.)

    Palette(bool have_white=false,int num=-1)

    {

      if (num==0) return;

      do {

        if(have_white) colors.push_back(Color(1,1,1));

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

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

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

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

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

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

      return colors[i%colors.size()];

    }

    ///\e

    const Color &operator[](int i) const

    {

      return colors[i%colors.size()];

    }

    ///\e

    void set(int i,const Color &c)

    {

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

    }

    void add(const Color &c) 

    {

      colors.push_back(c);

    }

    ///Sets the number of the exiting colors.

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

    ///Returns the number of the existing colors.

    int size() const { return int(colors.size());}

  };

  ///Returns a \ref Color which is as different from the given parameter

  ///as it is possible.

  inline Color distantColor(const Color &c) 

  {

    return Color(c.red()<.5?1:0,c.green()<.5?1:0,c.blue()<.5?1:0);

  }

  ///Returns black for light colors and white for the dark ones.

  ///Returns black for light colors and white for the dark ones.

  inline Color distantBW(const Color &c){

    return (.2125*c.red()+.7154*c.green()+.0721*c.blue())<.5 ? WHITE : BLACK;

#include<ctime>

#include<lemon/math.h>

#include<lemon/bits/invalid.h>

#include<lemon/dim2.h>

#include<lemon/maps.h>

#include<lemon/color.h>

#include<lemon/bits/bezier.h>

///\ingroup eps_io

///\file

namespace lemon {

  namespace _graph_to_eps_bits {

    template<class MT>

    class _NegY {

    public:

      typedef typename MT::Key Key;

      typedef typename MT::Value Value;

      const MT ↦

      int yscale;

      _NegY(const MT &m,bool b) : map(m), yscale(1-b*2) {}

    _undirected(lemon::UndirectedTagIndicator<G>::value),

    _pleaseRemoveOsStream(_pros), _scaleToA4(false),

    _nodeTextColorType(SAME_COL), _nodeTextColors(BLACK),

    _autoNodeScale(false),

    _autoArcWidthScale(false),

    _absoluteNodeSizes(false),

    _absoluteArcWidths(false),

    _negY(false),

    _preScale(true)

  {}

};

template<class T> class GraphToEps : public T 

{

  // Can't believe it is required by the C++ standard

  using T::g;

  using T::os;

  using T::_coords;

  using T::_nodeSizes;

  using T::_nodeShapes;

  using T::_nodeColors;

  using T::_arcColors;

  using T::_arcWidths;

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

  {

    dontPrint=true;

    return GraphToEps<NodeSizesTraits<X> >(NodeSizesTraits<X>(*this,x));

  }

  template<class X> struct NodeShapesTraits : public T {

    const X &_nodeShapes;

    NodeShapesTraits(const T &t,const X &x) : T(t), _nodeShapes(x) {}

  };

  ///Sets the map of the node shapes

  ///Sets the map of the node shapes.

  ///can be found in \ref NodeShapes "enum NodeShapes".

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

  ///\sa NodeShapes

  template<class X> GraphToEps<NodeShapesTraits<X> > nodeShapes(const X &x)

  {

    dontPrint=true;

    return GraphToEps<NodeShapesTraits<X> >(NodeShapesTraits<X>(*this,x));

  }

  template<class X> struct NodeTextsTraits : public T {

    const X &_nodeTexts;

    NodeTextsTraits(const T &t,const X &x) : T(t), _nodeTexts(x) {}

  };

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

  ///block to the nodes.

  ///The PS current point will be moved to the centre of the node before

  ///the PostScript block inserted.

  ///

  ///Before and after the block a newline character is inserted so you

  ///don't have to bother with the separators.

  ///

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

  ///ostream.

  ///

  ///\sa nodePsTextsPreamble()

  template<class X> GraphToEps<NodePsTextsTraits<X> > nodePsTexts(const X &x)

  {

    dontPrint=true;

    _showNodePsText=true;

    return GraphToEps<NodePsTextsTraits<X> >(NodePsTextsTraits<X>(*this,x));

  }

  template<class X> struct ArcWidthsTraits : public T {

    const X &_arcWidths;

    ArcWidthsTraits(const T &t,const X &x) : T(t), _arcWidths(x) {}

  };

  ///Sets the map of the arc widths

  ///Turns on/off the absolutematic node width scaling.

  ///

  ///\sa nodeScale()

  ///

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

    _absoluteNodeSizes=b;return *this;

  }

  ///Negates the Y coordinates.

  ///Negates the Y coordinates.

  ///

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

    _negY=b;return *this;

  }

  ///By default graphToEps() rescales the whole image in order to avoid

  ///very big or very small bounding boxes.

  ///

  ///This (p)rescaling can be turned off with this function.

  ///

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

    _preScale=b;return *this;

  }

  ///Sets a global scale factor for arc widths

    _absoluteArcWidths=b;return *this;

  }

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

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

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

  ///

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

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

  ///Sets whether to draw arrows

  ///

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

  ///Sets the length of the arrowheads

  ///Sets the length of the arrowheads

  ///

  ///Sets the width of the arrowheads

  ///Sets the width of the arrowheads

  ///

  ///Scales the drawing to fit to A4 page

  ///Scales the drawing to fit to A4 page

  ///

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

  ///Enables parallel arcs

  ///Enables parallel arcs

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

  {_nodeTextColorType=DIST_BW;return *this;}

  ///Gives a preamble block for node Postscript block.

  ///Gives a preamble block for node Postscript block.

  ///

  ///\sa nodePsTexts()

  GraphToEps<T> & nodePsTextsPreamble(const char *str) {

    _nodePsTextsPreamble=str ;return *this;

  }

  ///Sets whether the the graph is undirected

  ///

  ///Sets whether the the graph is directed

  ///Sets whether the the graph is directed.

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

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

  ///Sets the title.

  ///Sets the title of the generated image,

  ///namely it inserts a <tt>%%Title:</tt> DSC field to the header of

  ///the EPS file.

  GraphToEps<T> &title(const std::string &t) {_title=t;return *this;}

  ///Sets the copyright statement.

  ///Sets the copyright statement of the generated image,

  ///namely it inserts a <tt>%%Copyright:</tt> DSC field to the header of

  ///the EPS file.

  GraphToEps<T> &copyright(const std::string &t) {_copyright=t;return *this;}

protected:

  bool isInsideNode(dim2::Point<double> p, double r,int t) 

  {

    switch(t) {

    case CIRCLE:

    case MALE:

    case FEMALE:

      return p.normSquare()<=r*r;

    case SQUARE:

      return p.x<=r&&p.x>=-r&&p.y<=r&&p.y>=-r;

      return p.x+p.y<=r && p.x-p.y<=r && -p.x+p.y<=r && -p.x-p.y<=r;

    }

    return false;

  }

public:

  ~GraphToEps() { }

  ///Draws the graph.

  ///Like other functions using

  ///\ref named-templ-func-param "named template parameters",

  ///it draws the graph.

  void run() {

    const double EPSILON=1e-9;

    if(dontPrint) return;

    _graph_to_eps_bits::_NegY<typename T::CoordsMapType>

      mycoords(_coords,_negY);

    os << "%!PS-Adobe-2.0 EPSF-2.0\n";

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

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

//        << "%%Copyright: XXXX\n"

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

	typename std::vector<Arc>::iterator j;

	for(typename std::vector<Arc>::iterator i=el.begin();i!=el.end();i=j) {

	  for(j=i+1;j!=el.end()&&isParallel(*i,*j);++j) ;

	  double sw=0;

	  for(typename std::vector<Arc>::iterator e=i;e!=j;++e)

	    sw+=_arcWidths[*e]*_arcWidthScale+_parArcDist;

	  sw-=_parArcDist;

	  sw/=-2.0;

	  dim2::Point<double>

	    dvec(mycoords[g.target(*i)]-mycoords[g.source(*i)]);

	  double l=std::sqrt(dvec.normSquare()); 

	  dim2::Point<double> d(dvec/std::max(l,EPSILON));

 	  dim2::Point<double> m;

// 	  m=dim2::Point<double>(mycoords[g.target(*i)]+mycoords[g.source(*i)])/2.0;

//  	  m=dim2::Point<double>(mycoords[g.source(*i)])+

// 	    dvec*(double(_nodeSizes[g.source(*i)])/

// 	       (_nodeSizes[g.source(*i)]+_nodeSizes[g.target(*i)]));

 	  m=dim2::Point<double>(mycoords[g.source(*i)])+

	    d*(l+_nodeSizes[g.source(*i)]-_nodeSizes[g.target(*i)])/2.0;

	  for(typename std::vector<Arc>::iterator e=i;e!=j;++e) {