Changeset 1062:8226427845bc in lemon-0.x

Timestamp:

01/08/05 21:16:56 (20 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1458

Message:

• Parallel edge support (without arrowheads)
• Texts on the nodes

File:

• src/work/alpar/graph_to_eps.cc (modified) (18 diffs)

src/work/alpar/graph_to_eps.cc

@@ +1 @@
+/* -*- C++ -*-
+ * src/lemon/graph_to_eps.h - Part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Combinatorial Optimization Research Group, 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.
+ *
+ */
+
 #include <iostream>
 #include <fstream>
@@ -9 +25 @@
 
 
-///\file \ingroup misc
-///Simple graph drawer
+///\ingroup misc
+///\file
+///\brief Simple graph drawer
 
 namespace lemon {
@@ -75 +92 @@
   double _arrowLength, _arrowWidth;
   
+  bool _showNodes, _showEdges;
+
   bool _enableParallel;
+  double _parEdgeDist;
+
+  bool _showNodeText;
+  ConstMap<typename Graph::Node,bool > _nodeTexts;  
+  double _nodeTextSize;
 
   bool _pleaseRemoveOsStream;
@@ -96 +120 @@
     _nodeBorderQuotient(.1),
     _drawArrows(false), _arrowLength(1), _arrowWidth(0.3),
-    _enableParallel(false), _pleaseRemoveOsStream(_pros) {}
+    _showNodes(true), _showEdges(true),
+    _enableParallel(false), _parEdgeDist(1),
+    _showNodeText(false), _nodeTexts(false), _nodeTextSize(1),
+    _pleaseRemoveOsStream(_pros) {}
 };
 
@@ -131 +158 @@
     }
   };
-    
+  bool isParallel(Edge e,Edge f) const
+  {
+    return (g.source(e)==g.source(f)&&g.target(e)==g.target(f))||
+      (g.source(e)==g.target(f)&&g.target(e)==g.source(f));
+  }
+  static xy<double> rot(xy<double> v) 
+  {
+    return xy<double>(v.y,-v.x);
+  }
+  
 public:
   GraphToEps(const T &t) : T(t), dontPrint(false) {};
@@ -160 +196 @@
     return GraphToEps<NodeSizesTraits<X> >(NodeSizesTraits<X>(*this,x));
   }
+  template<class X> struct NodeTextsTraits : public T {
+    const X &_nodeTexts;
+    NodeTextsTraits(const T &t,const X &x) : T(t), _nodeTexts(x) {}
+  };
+  ///Sets the text printed on the nodes
+
+  ///Sets the text printed on the nodes
+  ///\param x must be a node map with type that can be pushed to a standard
+  ///ostream. 
+  template<class X> GraphToEps<NodeTextsTraits<X> > nodeTexts(const X &x)
+  {
+    dontPrint=true;
+    _showNodeText=true;
+    return GraphToEps<NodeTextsTraits<X> >(NodeTextsTraits<X>(*this,x));
+  }
    template<class X> struct EdgeWidthsTraits : public T {
     const X &_edgeWidths;
@@ -248 +299 @@
 
   ///Enables parallel edges
-  ///\todo Unimplemented
+  ///\todo Partially implemented
   GraphToEps<T> &enableParallel(bool b=true) {_enableParallel=b;return *this;}
+  
+  ///Sets the distance 
+  
+  ///Sets the distance 
+  ///
+  GraphToEps<T> &parEdgeDist(double d) {_parEdgeDist*=d;return *this;}
+  
+  ///Hides the edges
+  
+  ///Hides the edges
+  ///
+  GraphToEps<T> &hideEdges(bool b=true) {_showEdges=!b;return *this;}
+  ///Hides the nodes
+  
+  ///Hides the nodes
+  ///
+  GraphToEps<T> &hideNodes(bool b=true) {_showNodes=!b;return *this;}
+  
+  ///Sets the size of the node texts
+  
+  ///Sets the size of the node texts
+  ///
+  GraphToEps<T> &nodeTextSize(double d) {_nodeTextSize=d;return *this;}
+
   
   ~GraphToEps() 
@@ -269 +344 @@
          << bb.right()* _scale+_xBorder << ' '
          << bb.top()*   _scale+_yBorder << '\n';
-    //x1 y1 x2 y2 cr cg cb w
+    //x1 y1 x2 y2 x3 y3 cr cg cb w
+    os << "/lb { setlinewidth setrgbcolor newpath moveto\n"
+       << "      4 2 roll 1 index 1 index curveto stroke } bind def\n";
     os << "/l { setlinewidth setrgbcolor newpath moveto lineto stroke } bind def\n";
-    os << "/c { newpath dup 3 index add 2 index moveto 0 360 arc } bind def\n";
+    os << "/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath } bind def\n";
     // x y r cr cg cb
     os << "/n { setrgbcolor 2 index 2 index 2 index c fill\n"
-         << "     0 0 0 setrgbcolor dup "
-         << _nodeBorderQuotient << " mul setlinewidth "
-         << 1+_nodeBorderQuotient/2 << " div c stroke\n"
-         << "   } bind def\n";
+       << "     0 0 0 setrgbcolor dup "
+       << _nodeBorderQuotient << " mul setlinewidth "
+       << 1+_nodeBorderQuotient/2 << " div c stroke\n"
+       << "   } bind def\n";
     os << "/arrl " << _arrowLength << " def\n";
     os << "/arrw " << _arrowWidth << " def\n";
@@ -284 +361 @@
     //len w dx_norm dy_norm x1 y1 cr cg cb
     os << "/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx exch def\n"
-         << "       /w exch def /len exch def\n"
+       << "       /w exch def /len exch def\n"
       //         << "       0.1 setlinewidth x1 y1 moveto dx len mul dy len mul rlineto stroke"
-         << "       newpath x1 dy w 2 div mul add y1 dx w 2 div mul sub moveto\n"
-         << "       len w sub arrl sub dx dy lrl\n"
-         << "       arrw dy dx neg lrl\n"
-         << "       dx arrl w add mul dy w 2 div arrw add mul sub\n"
-         << "       dy arrl w add mul dx w 2 div arrw add mul add rlineto\n"
-         << "       dx arrl w add mul neg dy w 2 div arrw add mul sub\n"
-         << "       dy arrl w add mul neg dx w 2 div arrw add mul add rlineto\n"
-         << "       arrw dy dx neg lrl\n"
-         << "       len w sub arrl sub neg dx dy lrl\n"
-         << "       closepath fill } bind def\n";
+       << "       newpath x1 dy w 2 div mul add y1 dx w 2 div mul sub moveto\n"
+       << "       len w sub arrl sub dx dy lrl\n"
+       << "       arrw dy dx neg lrl\n"
+       << "       dx arrl w add mul dy w 2 div arrw add mul sub\n"
+       << "       dy arrl w add mul dx w 2 div arrw add mul add rlineto\n"
+       << "       dx arrl w add mul neg dy w 2 div arrw add mul sub\n"
+       << "       dy arrl w add mul neg dx w 2 div arrw add mul add rlineto\n"
+       << "       arrw dy dx neg lrl\n"
+       << "       len w sub arrl sub neg dx dy lrl\n"
+       << "       closepath fill } bind def\n";
+    os << "/cshow { 2 index 2 index moveto\n"
+       << "         dup stringwidth pop neg 2 div fosi .35 mul neg rmoveto show pop pop} def\n";
+
     os << "\ngsave\n";
     if(_scale!=1.0) os << _scale << " dup scale\n";
@@ -301 +381 @@
     os << "%Edges:\ngsave\n";
     
-    vector<Edge> el;
-    if(_enableParallel) {
-      for(EdgeIt e(g);e!=INVALID;++e) el.push_back(e);
-      sort(el.begin(),el.end(),edgeLess(g));
-    }
-    
-    for(NodeIt n(g);n!=INVALID;++n)
-      for(OutEdgeIt e(g,n);e!=INVALID;++e)
-        if(_drawArrows) {
-          xy<double> d(_coords[g.target(e)]-_coords[g.source(e)]);
-          double l=sqrt(d.normSquare());
-          d/=l;
-          xy<double> x1(d*_nodeScale*_nodeSizes[g.source(e)]+
-                        _coords[g.source(e)]);
-          os << l-(_nodeSizes[g.source(e)]+
+    if(_showEdges)
+      if(_enableParallel) {
+        vector<Edge> el;
+        for(EdgeIt e(g);e!=INVALID;++e) el.push_back(e);
+        sort(el.begin(),el.end(),edgeLess(g));
+        
+        typename vector<Edge>::iterator j;
+        for(typename vector<Edge>::iterator i=el.begin();i!=el.end();i=j) {
+          for(j=i+1;j!=el.end()&&isParallel(*i,*j);++j) ;
+          
+          if(_drawArrows) {
+            //    xy<double> d(_coords[g.target(e)]-_coords[g.source(e)]);
+            //    double l=sqrt(d.normSquare());
+            //    d/=l;
+            //    xy<double> x1(d*_nodeScale*_nodeSizes[g.source(e)]+
+            //                  _coords[g.source(e)]);
+            //    os << l-(_nodeSizes[g.source(e)]+
+            //               _nodeSizes[g.target(e)])*_nodeScale << ' '
+            //         << _edgeWidths[e]*_edgeWidthScale << ' '
+            //         << d.x << ' ' << d.y << ' '
+            //         << x1.x << ' ' << x1.y << ' '
+            //         << _edgeColors[e].getR() << ' '
+            //         << _edgeColors[e].getG() << ' '
+            //         << _edgeColors[e].getB() << " arr\n";
+          }
+          else {
+            double sw=0;
+            for(typename vector<Edge>::iterator e=i;e!=j;++e)
+              sw+=_edgeWidths[*e]*_edgeWidthScale+_parEdgeDist;
+            sw-=_parEdgeDist;
+            sw/=-2.0;
+            xy<double> d(_coords[g.target(*i)]-_coords[g.source(*i)]);
+            double l=sqrt(d.normSquare());
+            d/=l;
+            for(typename vector<Edge>::iterator e=i;e!=j;++e) {
+              sw+=_edgeWidths[*e]*_edgeWidthScale/2.0;
+              xy<double> m(_coords[g.target(*e)]+_coords[g.source(*e)]);
+              m=m/2.0+rot(d)*sw/.75;
+              os << _coords[g.source(*e)].x << ' '
+                 << _coords[g.source(*e)].y << ' '
+                 << m.x << ' ' << m.y << ' '
+                 << _coords[g.target(*e)].x << ' '
+                 << _coords[g.target(*e)].y << ' '
+                 << _edgeColors[*e].getR() << ' '
+                 << _edgeColors[*e].getG() << ' '
+                 << _edgeColors[*e].getB() << ' '
+                 << _edgeWidths[*e]*_edgeWidthScale << " lb\n";
+              sw+=_edgeWidths[*e]*_edgeWidthScale/2.0+_parEdgeDist;
+            }
+          }
+        }
+      }
+      else for(NodeIt n(g);n!=INVALID;++n)
+        for(OutEdgeIt e(g,n);e!=INVALID;++e)
+          if(_drawArrows) {
+            xy<double> d(_coords[g.target(e)]-_coords[g.source(e)]);
+            double l=sqrt(d.normSquare());
+            d/=l;
+            xy<double> x1(d*_nodeScale*_nodeSizes[g.source(e)]+
+                          _coords[g.source(e)]);
+            os << l-(_nodeSizes[g.source(e)]+
                      _nodeSizes[g.target(e)])*_nodeScale << ' '
                << _edgeWidths[e]*_edgeWidthScale << ' '
@@ -323 +449 @@
                << _edgeColors[e].getG() << ' '
                << _edgeColors[e].getB() << " arr\n";
-        }
-        else os << _coords[g.source(e)].x << ' '
+          }
+          else os << _coords[g.source(e)].x << ' '
                   << _coords[g.source(e)].y << ' '
                   << _coords[g.target(e)].x << ' '
@@ -333 +459 @@
                   << _edgeWidths[e]*_edgeWidthScale << " l\n";
     os << "grestore\n%Nodes:\ngsave\n";
-    for(NodeIt n(g);n!=INVALID;++n)
-      os << _coords[n].x << ' ' << _coords[n].y << ' '
+    if(_showNodes)
+      for(NodeIt n(g);n!=INVALID;++n)
+        os << _coords[n].x << ' ' << _coords[n].y << ' '
            << _nodeSizes[n]*_nodeScale << ' '
            << _nodeColors[n].getR() << ' '
            << _nodeColors[n].getG() << ' '
            << _nodeColors[n].getB() << " n\n"; 
+    if(_showNodeText) {
+      os << "grestore\n%Node texts:\ngsave\n";
+      os << "/fosi " << _nodeTextSize << " def\n";
+      os << "(Helvetica) findfont fosi scalefont setfont\n";
+      os << "0 0 0 setrgbcolor\n";
+      for(NodeIt n(g);n!=INVALID;++n)
+        os << _coords[n].x << ' ' << _coords[n].y
+           << " (" << _nodeTexts[n] << ") cshow\n";
+    }
     os << "grestore\ngrestore\n";
-
 
     //CleanUp:
@@ -365 +500 @@
 ///\endcode
 ///\sa GraphToEps
+///\sa graphToEps(G &g, char *file_name)
 template<class G>
 GraphToEps<DefaultGraphToEpsTraits<G> > 
-graphToEps(G &g,std::ostream& os=std::cout)
+graphToEps(G &g, std::ostream& os=std::cout)
 {
   return 
@@ -375 +511 @@
 ///Generates an EPS file from a graph
 
-///\ingroup misc
-///Generates an EPS file from a graph.
-///\param g is a reference to the graph to be printed
-///\param file_name is the output file_name.
-///
-///This function also has a lot of \ref named-templ-param "named parameters",
-///they are declared as the members of class \ref GraphToEps. The following
-///example shows how to use these parameters.
-///\code
-/// graphToEps(g).scale(10).coords(coords)
-///              .nodeScale(2).nodeSizes(sizes)
-///              .edgeWidthScale(.4);
-///\endcode
-///\sa GraphToEps
-///\todo Avoid duplicated documentation
-///\bug Exception handling is missing? (Or we can just ignore it?)
+//\ingroup misc
+///This function does the same as
+///\ref graphToEps(G &g,std::ostream& os)
+///but it writes its output into the file \c file_name
+///instead of a stream.
+///\sa graphToEps(G &g, std::ostream& os)
 template<class G>
 GraphToEps<DefaultGraphToEpsTraits<G> > 
@@ -399 +525 @@
 }
 
+//Generates an EPS file from a graph.
+//\param g is a reference to the graph to be printed
+//\param file_name is the output file_name.
+//
+//This function also has a lot of \ref named-templ-param "named parameters",
+//they are declared as the members of class \ref GraphToEps. The following
+//example shows how to use these parameters.
+//\code
+// graphToEps(g).scale(10).coords(coords)
+//              .nodeScale(2).nodeSizes(sizes)
+//              .edgeWidthScale(.4);
+//\endcode
+//\sa GraphToEps
+//\todo Avoid duplicated documentation
+//\bug Exception handling is missing? (Or we can just ignore it?)
 
 }
@@ -423 +564 @@
 } colorSet;
 
+class IdMap :public MapBase<ListGraph::Node,int>
+{
+  const ListGraph &g;
+public:
+  IdMap(const ListGraph &_g) :g(_g) {}
+  Value operator[](Key n) const { return g.id(n); }
+};
+
+
+
 int main()
 {
@@ -459 +610 @@
   e=g.addEdge(n3,n4); ecolors[e]=2; widths[e]=1;
   
+  IdMap id(g);
+
   graphToEps(g,"proba.eps").scale(10).coords(coords).
     nodeScale(2).nodeSizes(sizes).
     nodeColors(composeMap(colorSet,colors)).
     edgeColors(composeMap(colorSet,ecolors)).
-    edgeWidthScale(.4).edgeWidths(widths);
+    edgeWidthScale(.4).edgeWidths(widths).
+    nodeTexts(id).nodeTextSize(3);
+
   graphToEps(g,"proba_arr.eps").scale(10).coords(coords).
     nodeScale(2).nodeSizes(sizes).
@@ -469 +624 @@
     edgeColors(composeMap(colorSet,ecolors)).
     edgeWidthScale(.4).edgeWidths(widths).
-    drawArrows().arrowWidth(1).arrowLength(1)
-    ;
+    nodeTexts(id).nodeTextSize(3).
+    drawArrows().arrowWidth(1).arrowLength(1);
+
+  e=g.addEdge(n1,n4); ecolors[e]=2; widths[e]=1;
+  e=g.addEdge(n4,n1); ecolors[e]=1; widths[e]=2;
+
+  e=g.addEdge(n1,n2); ecolors[e]=1; widths[e]=1;
+  e=g.addEdge(n1,n2); ecolors[e]=2; widths[e]=1;
+  e=g.addEdge(n1,n2); ecolors[e]=3; widths[e]=1;
+  e=g.addEdge(n1,n2); ecolors[e]=4; widths[e]=1;
+  e=g.addEdge(n1,n2); ecolors[e]=5; widths[e]=1;
+  e=g.addEdge(n1,n2); ecolors[e]=6; widths[e]=1;
+  e=g.addEdge(n1,n2); ecolors[e]=7; widths[e]=1;
+
+  graphToEps(g,"proba_par.eps").scale(10).coords(coords).
+    nodeScale(2).nodeSizes(sizes).
+    nodeColors(composeMap(colorSet,colors)).
+    edgeColors(composeMap(colorSet,ecolors)).
+    edgeWidthScale(.4).edgeWidths(widths).
+    nodeTexts(id).nodeTextSize(3).
+    enableParallel().parEdgeDist(1.5);
 }