lemon-0.x: comparison src/lemon/graph_to

equal deleted inserted replaced

-:718d40cdad63
+:d5f5a09e1e0b
 ///Default constructor
 Color() {}
 ///Constructor
 Color(double r,double g,double b) :_r(r),_g(g),_b(b) {};
 ///Returns the red component
-double getR() {return _r;}
+///\todo \c red() could be a better name...
+double getR() const {return _r;}
 ///Returns the green component
-double getG() {return _g;}
+double getG() const {return _g;}
 ///Returns the blue component
-double getB() {return _b;}
+double getB() const {return _b;}
 ///Set the color components
 void set(double r,double g,double b) { _r=r;_g=g;_b=b; };
 };
+///Maps <tt>int</tt>s to different \ref Color "Color"s
+///This map assing 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 concept::ReferenceMap "reference map", so you can also
+///change the actual colors.
+class ColorSet : public MapBase<int,Color>
+{
+std::vector<Color> colors;
+public:
+///Constructor
+///Constructor
+///\param have_white indicates wheter white is
+///amongst the provided color (\c true) or not (\c false). If it is true,
+///white will be assigned to \c 0.
+///\param num the number of the allocated colors. If it is \c 0
+///the default color configuration is set up (26 color plus the while).
+///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.
+ColorSet(bool have_white=false,int num=0)
+{
+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;
+}
+///Sets the number of the exiting colors.
+void resize(int s) { colors.resize(s);}
+///Returns the munber of the existing colors.
+std::size_t size() { return 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.getR()<.5?1:0,c.getG()<.5?1:0,c.getB()<.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.
+///\todo weighted average would be better
+inline Color distantBW(const Color &c){
+double v=(c.getR()+c.getR()+c.getR())<1.5?1:0;
+return Color(v,v,v);
+}
 ///Default traits class of \ref GraphToEps
 ///Default traits class of \ref GraphToEps
 ///
 ///\c G is the type of the underlying graph.
 bool _scaleToA4;
 std::string _title;
 std::string _copyright;
+enum NodeTextColorType
+{ DIST_COL=0, DIST_BW=1, CUST_COL=2, SAME_COL=3 } _nodeTextColorType;
+ConstMap<typename Graph::Node,Color > _nodeTextColors;
 ///Constructor
 ///Constructor
 ///\param _g is a reference to the graph to be printed
 ///\param _os is a reference to the output stream.
 _showNodes(true), _showEdges(true),
 _enableParallel(false), _parEdgeDist(1),
 _showNodeText(false), _nodeTexts(false), _nodeTextSize(1),
 _showNodePsText(false), _nodePsTexts(false), _nodePsTextsPreamble(0),
 _undir(false),
-_pleaseRemoveOsStream(_pros), _scaleToA4(false) {}
+_pleaseRemoveOsStream(_pros), _scaleToA4(false),
+_nodeTextColorType(SAME_COL), _nodeTextColors(Color(0,0,0))
+{}
 };
 ///Helper class to implement the named parameters of \ref graphToEps()
 ///Helper class to implement the named parameters of \ref graphToEps()
 }
 static xy<double> rot(xy<double> v)
 {
 return xy<double>(v.y,-v.x);
 }
-template<class xy>
+template<class TT>
-static std::string psOut(const xy &p)
+static std::string psOut(const xy<TT> &p)
 {
 std::ostringstream os;
 os << p.x << ' ' << p.y;
+return os.str();
+}
+static std::string psOut(const Color &c)
+{
+std::ostringstream os;
+os << c.getR() << ' ' << c.getG() << ' ' << c.getB();
 return os.str();
 }
 public:
 GraphToEps(const T &t) : T(t), dontPrint(false) {};
 nodeColors(const X &x)
 {
 dontPrint=true;
 return GraphToEps<NodeColorsTraits<X> >(NodeColorsTraits<X>(*this,x));
 }
+template<class X> struct NodeTextColorsTraits : public T {
+const X &_nodeTextColors;
+NodeTextColorsTraits(const T &t,const X &x) : T(t), _nodeTextColors(x) {}
+};
+///Sets the map of the node text colors
+///Sets the map of the node text colors
+///\param x must be a node map with \ref Color values.
+template<class X> GraphToEps<NodeTextColorsTraits<X> >
+nodeTextColors(const X &x)
+{
+dontPrint=true;
+_nodeTextColorType=CUST_COL;
+return GraphToEps<NodeTextColorsTraits<X> >
+(NodeTextColorsTraits<X>(*this,x));
+}
 template<class X> struct EdgeColorsTraits : public T {
 const X &_edgeColors;
 EdgeColorsTraits(const T &t,const X &x) : T(t), _edgeColors(x) {}
 };
 ///Sets the map of the edge colors
 ///Sets the size of the node texts
 ///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 different from the node color
+///Sets the color of the node texts to be as different from the node color
+///as it is possible
+///
+GraphToEps<T> &distantColorNodeTexts()
+{_nodeTextColorType=DIST_COL;return *this;}
+///Sets the color of the node texts to be black or white and always visible.
+///Sets the color of the node texts to be black or white according to
+///which is more
+///different from the node color
+///
+GraphToEps<T> &distantBWNodeTexts()
+{_nodeTextColorType=DIST_BW;return *this;}
 ///Gives a preamble block for node Postscript block.
 ///Gives a preamble block for node Postscript block.
 ///
 ///\sa nodePsTexts()
 if(_showEdges) {
 os << "%Edges:\ngsave\n";
 if(_enableParallel) {
 	std::vector<Edge> el;
 	for(EdgeIt e(g);e!=INVALID;++e)
-	  if(!_undir||g.source(e)<g.target(e)) el.push_back(e);
+	  if((!_undir||g.source(e)<g.target(e))&&_edgeWidths[e]>0)
+	    el.push_back(e);
 	sort(el.begin(),el.end(),edgeLess(g));
 	typename std::vector<Edge>::iterator j;
 	for(typename std::vector<Edge>::iterator i=el.begin();i!=el.end();i=j) {
 	  for(j=i+1;j!=el.end()&&isParallel(*i,*j);++j) ;
 	    sw+=_edgeWidths[*e]*_edgeWidthScale/2.0+_parEdgeDist;
 	  }
 	}
 }
 else for(EdgeIt e(g);e!=INVALID;++e)
-	if(!_undir||g.source(e)<g.target(e))
+	if((!_undir||g.source(e)<g.target(e))&&_edgeWidths[e]>0)
 	  if(_drawArrows) {
 	    xy<double> d(_coords[g.target(e)]-_coords[g.source(e)]);
 	    double rn=_nodeSizes[g.target(e)]*_nodeScale;
 	    int node_shape=_nodeShapes[g.target(e)];
 	    double t1=0,t2=1;
 }
 if(_showNodeText) {
 os << "%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) {
-for(NodeIt n(g);n!=INVALID;++n)
+	switch(_nodeTextColorType) {
+	case DIST_COL:
+	  os << psOut(distantColor(_nodeColors[n])) << " setrgbcolor\n";
+	  break;
+	case DIST_BW:
+	  os << psOut(distantBW(_nodeColors[n])) << " setrgbcolor\n";
+	  break;
+	case CUST_COL:
+	  os << psOut(distantColor(_nodeTextColors[n])) << " setrgbcolor\n";
+	  break;
+	default:
+	  os << "0 0 0 setrgbcolor\n";
+	}
 	os << _coords[n].x << ' ' << _coords[n].y
 	   << " (" << _nodeTexts[n] << ") cshow\n";
+}
 os << "grestore\n";
 }
 if(_showNodePsText) {
 os << "%Node PS blocks:\ngsave\n";
 for(NodeIt n(g);n!=INVALID;++n)
 ///This function also has a lot of
 ///\ref named-templ-func-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)
+/// graphToEps(g,os).scale(10).coords(coords)
 ///              .nodeScale(2).nodeSizes(sizes)
 ///              .edgeWidthScale(.4).run();
 ///\endcode
 ///\warning Don't forget to put the \ref GraphToEps::run() "run()"
 ///to the end of the parameter list.

changeset 1178	3c176c65d33b
parent 1164	80bb73097736
child 1180	f772c360b466