RhodeCode

/* -*- C++ -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

/// \ingroup demos

/// \file

/// \brief Demo of the graph grawing function \ref graphToEps()

///

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

/// graphToEps(), and showing how to draw directed/graphs,

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

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

/// using appropriate \ref maps-page "graph maps".

///

/// \include graph_to_eps_demo.cc

#include <lemon/math.h>

#include<lemon/graph_to_eps.h>

#include<lemon/list_graph.h>

#include<lemon/graph_utils.h>

using namespace std;

using namespace lemon;

int main()

{

  Palette palette;

  ListDigraph g;

  typedef ListDigraph::Node Node;

  typedef ListDigraph::NodeIt NodeIt;

  typedef ListDigraph::Arc Arc;

  typedef dim2::Point<int> Point;

  Node n1=g.addNode();

  Node n2=g.addNode();

  Node n3=g.addNode();

  Node n4=g.addNode();

  Node n5=g.addNode();

  ListDigraph::NodeMap<Point> coords(g);

  ListDigraph::NodeMap<double> sizes(g);

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

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

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

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

  coords[n1]=Point(50,50);  sizes[n1]=1; colors[n1]=1; shapes[n1]=0;

  coords[n2]=Point(50,70);  sizes[n2]=2; colors[n2]=2; shapes[n2]=2;

  coords[n3]=Point(70,70);  sizes[n3]=1; colors[n3]=3; shapes[n3]=0;

  coords[n4]=Point(70,50);  sizes[n4]=2; colors[n4]=4; shapes[n4]=1;

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

  Arc e;

  e=g.addArc(n1,n2); ecolors[e]=0; widths[e]=1;

  e=g.addArc(n2,n3); ecolors[e]=0; widths[e]=1;

  e=g.addArc(n3,n5); ecolors[e]=0; widths[e]=3;

  e=g.addArc(n5,n4); ecolors[e]=0; widths[e]=1;

  e=g.addArc(n4,n1); ecolors[e]=0; widths[e]=1;

  e=g.addArc(n2,n4); ecolors[e]=1; widths[e]=2;

  e=g.addArc(n3,n4); ecolors[e]=2; widths[e]=1;

  IdMap<ListDigraph,Node> id(g);

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

  graphToEps(g,"graph_to_eps_demo_out_pure.eps").

    //scale(10).

    coords(coords).

    title("Sample .eps figure").

    copyright("(C) 2003-2007 LEMON Project").

    run();

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

  graphToEps(g,"graph_to_eps_demo_out.eps").

    //scale(10).

    coords(coords).

    title("Sample .eps figure").

    copyright("(C) 2003-2007 LEMON Project").

    absoluteNodeSizes().absoluteArcWidths().

    nodeScale(2).nodeSizes(sizes).

    nodeShapes(shapes).

    nodeColors(composeMap(palette,colors)).

    arcColors(composeMap(palette,ecolors)).

    arcWidthScale(.4).arcWidths(widths).

    nodeTexts(id).nodeTextSize(3).

    run();

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

  graphToEps(g,"graph_to_eps_demo_out_arr.eps").

    //scale(10).

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

    copyright("(C) 2003-2007 LEMON Project").

    absoluteNodeSizes().absoluteArcWidths().

    nodeColors(composeMap(palette,colors)).

    coords(coords).

    nodeScale(2).nodeSizes(sizes).

    nodeShapes(shapes).

    arcColors(composeMap(palette,ecolors)).

    arcWidthScale(.4).arcWidths(widths).

    nodeTexts(id).nodeTextSize(3).

    drawArrows().arrowWidth(1).arrowLength(1).

    run();

  e=g.addArc(n1,n4); ecolors[e]=2; widths[e]=1;

  e=g.addArc(n4,n1); ecolors[e]=1; widths[e]=2;

  e=g.addArc(n1,n2); ecolors[e]=1; widths[e]=1;

  e=g.addArc(n1,n2); ecolors[e]=2; widths[e]=1;

  e=g.addArc(n1,n2); ecolors[e]=3; widths[e]=1;

  e=g.addArc(n1,n2); ecolors[e]=4; widths[e]=1;

  e=g.addArc(n1,n2); ecolors[e]=5; widths[e]=1;

  e=g.addArc(n1,n2); ecolors[e]=6; widths[e]=1;

  e=g.addArc(n1,n2); ecolors[e]=7; widths[e]=1;

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

  graphToEps(g,"graph_to_eps_demo_out_par.eps").

    //scale(10).

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

    copyright("(C) 2003-2007 LEMON Project").

    absoluteNodeSizes().absoluteArcWidths().

    nodeShapes(shapes).

///\ingroup misc

///\file

///\brief Tools to manage RGB colors.

///

///\author Alpar Juttner

namespace lemon {

  /// \addtogroup misc

  /// @{

  ///Data structure representing RGB colors.

  ///Data structure representing RGB colors.

  class Color

  {

    double _r,_g,_b;

  public:

    ///Default constructor

    Color() {}

    ///Constructor

    Color(double r,double g,double b) :_r(r),_g(g),_b(b) {};

    ///Set the red component

    double & red() {return _r;}

    ///Return the red component

    const double & red() const {return _r;}

    ///Set the green component

    double & green() {return _g;}

    ///Return the green component

    const double & green() const {return _g;}

    ///Set the blue component

    double & blue() {return _b;}

    ///Return the blue component

    const double & blue() const {return _b;}

    ///Set the color components

    void set(double r,double g,double b) { _r=r;_g=g;_b=b; };

  };

  /// White color constant

  extern const Color WHITE;  

  /// Black color constant

  extern const Color BLACK;

  /// Red color constant

  extern const Color RED;

  /// Green color constant

  extern const Color GREEN;

  /// Blue color constant

  extern const Color BLUE;

  /// Yellow color constant

  extern const Color YELLOW;

  /// Magenta color constant

  extern const Color MAGENTA;

  /// Cyan color constant

  extern const Color CYAN;

  /// Grey color constant

  extern const Color GREY;

  /// Dark red color constant

  extern const Color DARK_RED;

  /// Dark green color constant

  extern const Color DARK_GREEN;

  /// Drak blue color constant

  extern const Color DARK_BLUE;

  /// Dark yellow color constant

  extern const Color DARK_YELLOW;

  /// Dark magenta color constant

  extern const Color DARK_MAGENTA;

  /// Dark cyan color constant

  extern const Color DARK_CYAN;

  ///Map <tt>int</tt>s to different \ref Color "Color"s

  ///This map assigns one of the predefined \ref Color "Color"s to

  ///each <tt>int</tt>. It is possible to change the colors as well as

  ///their number. The integer range is cyclically mapped to the

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

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

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

    ///\param have_white indicates whether white is amongst the

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

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

    {

      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));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    }

    ///\e

    Color &operator[](int i)

    {

      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;

    }

    ///\e

    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 visible distinct \ref Color

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

  }

  /// @}

} //END OF NAMESPACE LEMON

#endif // LEMON_COLOR_H