source: lemon-0.x/lemon/eps.h @ 2008:0820d8168cbb

/* -*- C++ -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library
 *
 * Copyright (C) 2003-2006
 * 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.
 *
 */

#ifndef LEMON_EPS_H
#define LEMON_EPS_H

#include<string>
#include<iostream>
#include<fstream>
#include<sstream>
#include<lemon/color.h>
#include<lemon/xy.h>

  ///\ingroup io_group
  ///\file
  ///\brief Simple tool to create \c .eps files
  ///
  ///\author Alpar Juttner

namespace lemon {
  
  ///\ingroup io_group
  ///\brief A simple tool to create \c .eps files
  ///
  ///A simple tool to create \c .eps files
  ///\author Alpar Juttner
  class EpsDrawer
  {
    void defMacros();
    void init(int x1,int y1,int x2,int y2);
    void init(double x1,double y1,double x2,double y2);
    bool local_stream;
  public:
    
    std::ostream &out;
    
    ///Node shapes
    ///
    enum NodeShapes { 
      /// = 0
      ///\image html nodeshape_0.png
      ///\image latex nodeshape_0.eps "CIRCLE shape (0)" width=2cm
      CIRCLE=0, 
      /// = 1
      ///\image html nodeshape_1.png
      ///\image latex nodeshape_1.eps "SQUARE shape (1)" width=2cm
      ///
      SQUARE=1, 
      /// = 2
      ///\image html nodeshape_2.png
      ///\image latex nodeshape_2.eps "DIAMOND shape (2)" width=2cm
      ///
      DIAMOND=2,
      /// = 3
      ///\image html nodeshape_3.png
      ///\image latex nodeshape_2.eps "MALE shape (4)" width=2cm
      ///
      ///\warning Not implemented
      MALE=3,
      /// = 4
      ///\image html nodeshape_4.png
      ///\image latex nodeshape_2.eps "FEMALE shape (4)" width=2cm
      ///
      ///\warning Not implemented
      FEMALE=4
    };
    ///\e 

    ///The generated file is put to \c os.
    ///
    /// \c x and \c y determine the upper
    ///right corner of the bounding box. The lower left corner is (0,0).
    EpsDrawer(std::ostream &os,int x,int y);
    ///\e

    ///The generated file is put to \c os.
    ///
    ///(x1,y1) and (x2,y2)
    /// determine the lower left and the upper right corners of
    ///the bounding box, respectively.
    EpsDrawer(std::ostream &os,int x1,int y1,int x2,int y2);
    ///\e

    ///The generated file is put to \c os.
    ///
    ///\c s determines the upper
    ///right corner of the bounding box. The lower left corner is (0,0).
    EpsDrawer(std::ostream &os,xy<double> s);
    ///\e

    ///The generated file is put to \c os.
    ///
    ///\c a and \c b
    /// determine the lower left and the upper right corners of
    ///the bounding box, respectively.
    EpsDrawer(std::ostream &os,xy<double> a, xy<double> b);
    ///\e

    ///The generated picture is put to the file \c name.
    ///
    ///\c x and \c y determine the upper
    ///right corner of the bounding box. The lower left corner is (0,0).
    EpsDrawer(const std::string &name,int x,int y);
    ///\e

    ///The generated picture is put to the file \c name.
    ///
    ///(x1,y1) and (x2,y2)
    /// determine the lower left and the upper right corners of
    ///the bounding box, respectively.
    EpsDrawer(const std::string &name,int x1,int y1,int x2,int y2);
    ///\e

    ///The generated picture is put to the file \c name.
    ///
    ///\c s determines the upper
    ///right corner of the bounding box. The lower left corner is (0,0).
    EpsDrawer(const std::string &name,xy<double> s);
    ///\e

    ///The generated picture is put to the file \c name.
    ///
    ///\c a and \c b
    /// determine the lower left and the upper right corners of
    ///the bounding box, respectively.
    EpsDrawer(const std::string &name,xy<double> a, xy<double> b);

//     template<class T> EpsDrawer(std::ostream &os,BoundingBox<T> b) 
//     template<class T> EpsDrawer(std::ostream &os,BoundingBox<T> b);
    
    ~EpsDrawer();
    
    ///Save the current graphic state.

    ///This function saves the current coordinate system, and the parameters
    ///set by \ref color(), \ref lineWidth() etc.
    ///The can be \ref restore "restore()"d later.
    ///
    ///The \ref save() - \ref restore() pairs can be nested.
    ///
    EpsDrawer &save();
    ///Restore the saves graphic state.

    EpsDrawer &restore();
    
    ///Draw a line
    EpsDrawer &line(double x1,double y1,double x2,double y2);
    ///Draw a line from the current point
    EpsDrawer &lineTo(double x1,double y1);
    ///Move the current point
    EpsDrawer &moveTo(double x1,double y1);
    ///Draw a circle
    EpsDrawer &circle(double x,double y, double r);
    
    ///Draw a line
    template<class T> EpsDrawer &line(xy<T> p1,xy<T> p2) 
    {
      return line(p1.x,p1.y,p2.x,p2.y);
    }
    ///Draw a line from the current point
    template<class T> EpsDrawer &lineTo(xy<T> p)
    {
      return lineTo(p.x,p.y);
    }
    ///Move the current point
    template<class T> EpsDrawer &moveTo(xy<T> p)
    {
      return moveTo(p.x,p.y);
    }
    ///Draw a circle
    template<class T> EpsDrawer &circle(xy<T> p, double r)
    {
      return circle(p.x,p.y,r);
    }
    
    ///Set the font size
    EpsDrawer &fontSize(double si);
    ///Set the fint type
    EpsDrawer &font(std::string );
    ///Sets whether text output is centerized of not

    ///Sets whether text output is centerized of not.
    ///
    ///\warning \ref save() doesn't save this setting.
    ///
    EpsDrawer &centerMode(bool m);
    ///Turn to collect mode.

    ///If you call this function, then the drawing operations like \ref line(),
    ///\ref lineTo(), \ref moveTo() will not take place immediately, but istead
    ///they
    ///are collected. These operations form a \e path.
    ///Then you can \ref stroke(), \ref fill(), \ref eofill(), \ref clip() or
    ///\ref eoclip() it.
    ///When drawing, you can also use \ref closePath() to - surprise - close the
    ///current path.
    ///
    ///This example draws a red filled diamond.
    ///\code
    ///  EpsDraw ed("diamond.eps",-1,-1,1,1);
    ///  ed.color(1,0,0,).collect().line(0,-1,1,0).lineTo(0,1)
    ///    .lineTo(-1,0).closePath().fill();
    ///\endcode
    EpsDrawer &collect();
    ///Close the current drawing path
    EpsDrawer &closePath();
    ///Stroke (draw) a path

    ///Stroke (draw) a path.
    ///\sa collect
    ///
    EpsDrawer &stroke();
    ///Fill a path

    ///Fill a path.
    ///\sa collect
    ///
    EpsDrawer &fill();
    ///Even-odd fill a path

    ///Even-odd fill a path.
    ///\sa collect
    ///
    EpsDrawer &eoFill();
    ///Set a clipping area.

    ///This function sets a clipping area. After that, the drawing operations
    ///will affect only this area.
    ///\sa collect
    ///
    EpsDrawer &clip();
    ///Set a clipping area using even-odd rule.

    ///This function sets a clipping area using even-odd rule.
    ///After that, the drawing operations
    ///will affect only this area.
    ///\sa collect
    ///
    EpsDrawer &eoClip();
    
    ///Set the line width.
    EpsDrawer &lineWidth(double w);
    ///Set the style of the line ends

    ///\param i It can be 0, 1 or 2
    ///
    EpsDrawer &lineCap(int i);
    ///Set the style of the line joins

    ///\param i It can be 0, 1 or 2
    ///
    EpsDrawer &lineJoin(int i);
    ///Set the cut length of near parallel joining lines.
    EpsDrawer &miterLimit(double w);
    
    ///Set the drawing color
    EpsDrawer &color(double r, double g, double b);
    ///Set the drawing color
    EpsDrawer &color(Color c)
    {
      return color(c.red(),c.green(),c.blue());
    }
    
    ///Draw a node shape

    ///Draw a node shape.
    ///
    ///\param t The shape of the drawn object
    ///\param x The \c x coordinate of the node
    ///\param y The \c y coordinate of the node
    ///\param col Color of the node. The default color is white
    ///\param brd Color of the node border. The default color is black
    EpsDrawer &node(NodeShapes t, double x, double y, double r,
                    Color col=Color(1,1,1), Color brd=Color(0,0,0));
    ///Draw a node shape
    
    ///Draw a node shape.
    ///
    ///\param t The shape of the drawn object
    ///\param pos Position of the node
    ///\param col Color of the node. The default color is white
    ///\param brd Color of the node border. The default color is black
    template<class T>
    EpsDrawer &node(NodeShapes t, xy<T> pos, double r,
                    Color col=Color(1,1,1), Color brd=Color(0,0,0))
    {
      return node(t,pos.x,pos.y,r,col,brd);
    }

    ///Translate the coordinate system
    EpsDrawer &translate(double x,double y);
    ///Translate the coordinate system
    template<class T> EpsDrawer &translate(xy<T> p)
    {
      return translate(p.x,p.y);
    }
    ///Rotate the coordinate system
    EpsDrawer &rotate(double r);
    ///Scale the coordinate system
    EpsDrawer &scale(double sx, double sy);
    ///Scale the coordinate system
    EpsDrawer &scale(double s) { return scale(s,s); }
    ///Scale the coordinate system
    template<class T> EpsDrawer &scale(xy<T> p)
    {
      return scale(p.x,p.y);
    }
    
    ///\e
    EpsDrawer &flush();
    ///Clear the image
    EpsDrawer &clear();
    
    ///Print a text at the current point
    EpsDrawer &operator<<(const std::string &s);
    ///Print a text at the current point
    EpsDrawer &operator<<(const char *s);
    ///Print a number at the current point
    EpsDrawer &operator<<(int i);
    ///Print a number at the current point
    EpsDrawer &operator<<(double d);
    ///Print a coordinate at the current point
    template<class T>
    EpsDrawer &operator<<(xy<T> p) 
    {
      out << "((" << p.x << ',' << p.y <<")) show\n";
      return *this;
    }
    
  };
  
}

#endif