Board.h

/* -*- mode: c++ -*- */
/*
 * \@copyright This File is part of the Board library which is
 * licensed under the terms of the GNU Lesser General Public Licence.
 * See the LICENCE file for further details.
 */
#ifndef _BOARD_BOARD_H_
#define _BOARD_BOARD_H_
 
#include <ostream>
#include <string>
#include <vector>
 
#include "Board/Point.h"
#include "Board/Path.h"
#include "Board/Shapes.h"
#include "Board/ShapeList.h"
 
#include "DGtal/io/Color.h"
 
namespace LibBoard {
  
class Board : public ShapeList {
  
public:
  
  // cairo
  enum CairoType { CairoPDF, CairoPNG, CairoPS, CairoEPS, CairoSVG };
 
  enum PageSize { BoundingBox, A4, Letter };
  enum Unit { UPoint, UInche, UCentimeter, UMillimeter };
  static const double Degree;
  
  Board( const DGtal::Color & backgroundColor = DGtal::Color::None );
 
  Board( const Board & other );
 
  ~Board();
 
  Board & operator=( const Board & other );
 
 
  Board & operator<<( const Shape & shape );
 
  Board & operator<<( Unit unit );
  
  void clear( const DGtal::Color & color = DGtal::Color::None );
 
  void clear( unsigned char red, unsigned char green, unsigned char blue );
 
  Shape & rotate( double angle, const Point & center );
 
  Shape & rotate( double angle );
 
  Shape & translate( double dx, double dy );
 
  Shape & scale( double sx, double sy );
 
  Shape & scale( double s );
 
  Board rotated( double angle, const Point & center );
 
  Board rotated( double angle );
 
  Board translated( double dx, double dy );
 
  Board scaled( double sx, double sy );
 
  Board scaled( double s );
 
  void setUnit( Unit unit );
 
  void setUnit( double factor, Unit unit );
 
  void drawDot( double x, double y, int depthValue = -1 );
 
  void drawLine( double x1, double y1, double x2, double y2, 
     int depthValue = -1 );
 
  void drawQuadraticBezierCurve( double x1, double y1, double x2, double y2, double x3, double y3,  
     int depthValue = -1 ); 
 
  void drawArrow( double x1, double y1, double x2, double y2,
      bool filled = true,
      int depthValue = -1 );
 
  void drawTriangle( double x1, double y1, 
         double x2, double y2, 
         double x3, double y3, 
         int depthValue = -1 );
 
  void drawTriangle( const Point & p1,
         const Point & p2, 
         const Point & p3, 
         int depthValue = -1 );
 
 
  void drawArc(double x, double y, double radius, double angle1, double angle2, 
               bool neg, int depthValue = -1 );
  
  void fillTriangle( double x1, double y1, 
         double x2, double y2, 
         double x3, double y3, 
         int depthValue = -1 );
 
  void fillGouraudTriangle( const Point & p1,
          const DGtal::Color & color1,
          const Point & p2,
          const DGtal::Color & color2,
          const Point & p3,
          const DGtal::Color & color3,
          unsigned char divisions = 3,
          int depthValue = -1 );
 
  void fillGouraudTriangle( const double x1, const double y1,
          const DGtal::Color & color1,
          const double x2, const double y2, 
          const DGtal::Color & color2,
          const double x3, const double y3,
          const DGtal::Color & color3,
          unsigned char divisions = 3,
          int depthValue = -1 );
  
  void fillGouraudTriangle( const Point & p1,
          const float brightness1,
          const Point & p2,
          const float brightness2,
          const Point & p3,
          const float brightness3,
          unsigned char divisions = 3,
          int depthValue = -1 );
 
  void fillGouraudTriangle( const double x1, const double y1,
          const float brightness1,
          const double x2, const double y2, 
          const float brightness2,
          const double x3, const double y3,
          const float brightness3,
          unsigned char divisions = 3,
          int depthValue = -1 );
  
 
  void fillTriangle( const Point & p1,
         const Point & p2, 
         const Point & p3, 
         int depthValue = -1 );
  
  void drawRectangle( double x, double y, 
          double width, double height,
          int depthValue = -1 );
  void drawImage( std::string filename, double x, double y, 
          double width, double height,
      int depthValue = -1, double alpha=1.0 );
 
  void fillRectangle( double x, double y,
          double width, double height,
          int depthValue = -1 );
 
  void drawCircle( double x, double y, double radius,
       int depthValue = -1 );
 
  void fillCircle( double x, double y, double radius,
       int depthValue = -1);
 
  void drawEllipse( double x, double y, 
        double xRadius, double yRadius,
        int depthValue = -1);
 
  void fillEllipse( double x, double y, 
        double xRadius, double yRadius,
        int depthValue = -1);
 
  void drawPolyline( const std::vector<Point> & points,
         int depthValue = -1 );
  
  void drawClosedPolyline( const std::vector<Point> & points,
         int depthValue = -1 );
 
  void fillPolyline( const std::vector<Point> & points,
         int depthValue = -1 );
    
  void drawText( double x, double y, const char * text, 
     int depthValue = -1 );
 
  void drawText( double x, double y, 
                 const std::string & str, 
     int depthValue = -1 );
 
  Board & setFont( const Fonts::Font font, double fontSize );
  
  Board & setFontSize( double fontSize ); 
 
  Board & setPenColorRGBi( unsigned char red,
         unsigned char green,
         unsigned char blue,
         unsigned char alpha = 255 );
 
  Board & setPenColorRGBf(  float red,
          float green,
          float blue, 
          float alpha = 1.0f );
 
  Board & setPenColor( const DGtal::Color & color );
  
 
  Board & setFillColorRGBi( unsigned char red,
          unsigned char green,
          unsigned char blue,
          unsigned char alpha = 255 );
  
  Board & setFillColorRGBf( float red, float green, float blue, float alpha = 1.0f );
 
  Board & setFillColor( const DGtal::Color & color );
  
  Board & setLineWidth( double width );
 
  Board & setLineStyle( Shape::LineStyle style );
  
  Board & setLineCap( Shape::LineCap cap ); 
 
  Board & setLineJoin( Shape::LineJoin join );
 
  void backgroundColor( const DGtal::Color & color );
 
  void drawBoundingBox( int depthValue = -1 );
 
 
  void setClippingRectangle(  double x, double y, 
            double width, double height );
 
  void setClippingPath(  const std::vector<Point> & points  );
 
  void setClippingPath( const Path & path );
 
  void addDuplicates( const Shape & shape,
          unsigned int times,
          double dx, double dy, double scale = 1.0 );
 
  void addDuplicates( const Shape & shape,
          unsigned int times,
          double dx, double dy,
          double scaleX, 
          double scaleY,
          double angle = 0.0 );
 
  void save( const char * filename, PageSize size = Board::BoundingBox, double margin = 10.0 ) const; 
  
  void save( const char * filename, double pageWidth, double pageHeight, double margin = 10.0 ) const; 
 
  void saveEPS( const char * filename, PageSize size = Board::BoundingBox, double margin = 10.0 ) const ;
 
  void saveEPS(std::ostream &out , PageSize size = Board::BoundingBox, double margin = 10.0 ) const ;
 
 
  void saveEPS( const char * filename, double pageWidth, double pageHeight, double margin = 10.0 ) const ;
 
 
 
  void saveEPS( std::ostream &out, double pageWidth, double pageHeight, double margin = 10.0) const ;
 
  void saveFIG( const char * filename, PageSize size = Board::BoundingBox, double margin = 10.0,
                bool includeFIGHeader=true) const;
 
  void saveFIG( std::ostream &out, PageSize size = Board::BoundingBox, double margin = 10.0,
                bool includeFIGHeader=true) const;
 
  void saveFIG( const char * filename, double pageWidth, double pageHeight, double margin = 10.0,
                bool includeFIGHeader=true) const ;
 
  void saveFIG( std::ostream &out, double pageWidth, double pageHeight, double margin = 10.0,
                bool includeFIGHeader=true ) const ;
 
  void saveSVG( const char * filename, PageSize size = Board::BoundingBox, double margin = 10.0 ) const;
 
  void saveSVG( std::ostream &out, PageSize size = Board::BoundingBox, double margin = 10.0 ) const;
 
  void saveSVG( const char * filename, double pageWidth, double pageHeight, double margin = 10.0 ) const ;
 
  void saveSVG( std::ostream &out, double pageWidth, double pageHeight, double margin = 10.0,
                std::string filename="output.svg") const ;
  
 
#ifdef WITH_CAIRO
  // cairo
  void saveCairo( const char * filename, CairoType type = CairoPNG, 
                  PageSize size = Board::BoundingBox, double margin = 10.0 ) const;
 
  void saveCairo( const char * filename, CairoType type, double pageWidth, double pageHeight, double margin = 10.0 ) const ;
 
 
#endif
 
  void saveTikZ( const char * filename, PageSize size = Board::BoundingBox, double margin = 10.0 ) const;
  void saveTikZ( std::ostream &out, PageSize size = Board::BoundingBox, double margin = 10.0 ) const;
 
  void saveTikZ( const char * filename, double pageWidth, double pageHeight, double margin = 10.0 ) const ;
 
  void saveTikZ( std::ostream &out, double pageWidth, double pageHeight, double margin = 10.0 ) const ;
 
 protected:
 
  struct State {
    DGtal::Color penColor;            
    DGtal::Color fillColor;           
    double lineWidth;        
    Shape::LineStyle lineStyle;  
    Shape::LineCap lineCap;      
    Shape::LineJoin lineJoin;   
    Fonts::Font font;           
    double fontSize;               
    double unitFactor;        
    State();
    double unit( const double & x ) { return x * unitFactor; }
    Point unit( const Point & p ) { return Point( p.x * unitFactor, p.y * unitFactor); }
    void unit( Shape & shape ) {  shape.scaleAll( unitFactor ); }
  };
  State _state;       
  DGtal::Color _backgroundColor;   
  Path _clippingPath;
};
 
} // namespace LibBoard
 
#include "Board.ih"
 
#endif