Shapes.h

Go to the documentation of this file.

/* -*- mode: c++ -*- */
#ifndef _BOARD_SHAPES_H_
#define _BOARD_SHAPES_H_

#include "board/Point.h"
#include "board/Rect.h"
#include "board/Path.h"
#include "board/Color.h"
#include "board/PSFonts.h"
#include "board/Tools.h"
#include "board/Transforms.h"
#include <string>
#include <vector>
#include <iostream>
#include <map>
#include <cmath>

#ifndef M_PI
#define M_PI           3.14159265358979323846
#endif

#ifndef M_PI_2
#define M_PI_2         1.57079632679489661923
#endif

#if __cplusplus<201100
#define override
#endif

namespace LibBoard {

struct ShapeVisitor;

struct Shape {

  enum LineCap { ButtCap = 0, RoundCap, SquareCap };
  enum LineJoin { MiterJoin = 0, RoundJoin, BevelJoin };
  enum LineStyle { SolidStyle = 0,
                   DashStyle,
                   DotStyle,
                   DashDotStyle,
                   DashDotDotStyle,
                   DashDotDotDotStyle };

  enum LineWidthFlag { IgnoreLineWidth, UseLineWidth };

  inline Shape( Color penColor, Color fillColor,
                double lineWidth,
                LineStyle style,
                const LineCap cap,
                const LineJoin join,
                int depth );

  virtual ~Shape() { }

  virtual const std::string & name() const;

  virtual Shape * clone() const = 0;

  inline bool filled() const { return _fillColor != Color::Null; }

  virtual Point center(LineWidthFlag lineWidthFlag = IgnoreLineWidth) const;

  virtual Shape & rotate( double angle, const Point & center ) = 0;

  virtual Shape & rotate( double angle ) = 0;

  inline Shape & rotateDeg( double angle, const Point & center );

  inline Shape & rotateDeg( double angle );

  virtual Shape & translate( double dx, double dy ) = 0;

  Shape & moveCenter( double x, double y, LineWidthFlag lineWidthFlag = IgnoreLineWidth);

  Shape & moveCenter( Point p, LineWidthFlag lineWidthFlag = IgnoreLineWidth );

  virtual Shape & scale( double sx, double sy ) = 0;

  virtual Shape & scale( double s ) = 0;

  Shape & scaleToWidth( double w, LineWidthFlag lineWidthFlag );

  Shape & scaleToHeight( double h, LineWidthFlag lineWidthFlag );

  virtual Rect boundingBox( LineWidthFlag ) const = 0;

  inline Rect bbox( LineWidthFlag ) const;

  inline Shape & operator--();

  inline Shape & operator++();

  virtual void scaleAll( double s ) = 0;

  virtual void flushPostscript( std::ostream & stream,
                                const TransformEPS & transform ) const = 0;

  virtual void flushFIG( std::ostream & stream,
                         const TransformFIG & transform,
                         std::map<Color,int> & colormap ) const = 0;

  virtual void flushSVG( std::ostream & stream,
                         const TransformSVG & transform ) const = 0;

  virtual void flushTikZ( std::ostream & stream,
                          const TransformTikZ & transform ) const = 0;


  static void enableLineWidthScaling();

  static void disableLineWidthScaling();

  static void setLineWidthScaling(bool );

  inline int depth() const;

  virtual void depth( int );

  virtual void shiftDepth( int shift );

  inline const Color & penColor() const;

  inline const Color & fillColor() const;

  static void setDefaultLineWidth( double );
  static void setDefaultPenColor( Color );
  static void setDefaultFillColor( Color );
  static void setDefaultLineStyle( Shape::LineStyle );
  static void setDefaultLineCap( Shape::LineCap );
  static void setDefaultLineJoin( Shape::LineJoin );

  static double defaultLineWidth();

  static Color defaultPenColor();

  static Color defaultFillColor();

  static Shape::LineStyle defaultLineStyle();

  static Shape::LineCap defaultLineCap();

  static Shape::LineJoin defaultLineJoin();

  virtual void accept( ShapeVisitor & visitor );

  virtual void accept( const ShapeVisitor & visitor );



private:

  static const std::string _name;       
protected:

  static bool _lineWidthScaling;        
  static double _defaultLineWidth;
  static Color _defaultPenColor;
  static Color _defaultFillColor;
  static Shape::LineStyle _defaultLineStyle;
  static Shape::LineCap _defaultLineCap;
  static Shape::LineJoin _defaultLineJoin;

  inline void updateLineWidth(double s);

  int _depth;          
  Color _penColor;     
  Color _fillColor;    
  double _lineWidth;   
  LineStyle _lineStyle;
  LineCap _lineCap;    
  LineJoin _lineJoin;  
  std::string svgProperties( const TransformSVG & transform ) const;


  std::string postscriptProperties( const TransformEPS & transform ) const;

  std::string tikzProperties( const TransformTikZ & transform ) const;

};

struct Dot : public Shape {

  inline Dot( double x, double y,
              Color color,
              double lineWidth = Shape::defaultLineWidth(),
              int depth = -1 );

  const std::string & name() const override;

  Point center(LineWidthFlag flage = IgnoreLineWidth) const override;

  Dot & rotate( double angle, const Point & center ) override;

  Dot rotated( double angle, const Point & center ) const;

  Dot & rotate( double angle ) override;

  Dot rotated( double angle ) const;

  Dot & translate( double dx, double dy ) override;

  Dot translated( double dx, double dy ) const;

  Dot & scale( double sx, double sy ) override;

  Dot & scale( double s ) override;

  Dot scaled( double sx, double sy ) const;

  Dot scaled( double s ) const;

  void scaleAll( double s ) override;

  void flushPostscript( std::ostream & stream,
                        const TransformEPS & transform ) const override;

  void flushFIG( std::ostream & stream,
                 const TransformFIG & transform,
                 std::map<Color,int> & colormap ) const override;

  void flushSVG( std::ostream & stream,
                 const TransformSVG & transform ) const override;

  void flushTikZ( std::ostream & stream,
                  const TransformTikZ & transform ) const override;

  Rect boundingBox( LineWidthFlag ) const override;

  Dot * clone() const override;

private:

  static const std::string _name; 
protected:
  double _x;  
  double _y;  
};

struct Line : public Shape {

  inline Line( double x1, double y1, double x2, double y2,
               Color color,
               double lineWidth = Shape::defaultLineWidth(),
               const LineStyle lineStyle = Shape::defaultLineStyle(),
               const LineCap cap = Shape::defaultLineCap(),
               const LineJoin join = Shape::defaultLineJoin(),
               int depth = -1 );

  inline Line( Point a,
               Point b,
               Color color,
               double lineWidth = Shape::defaultLineWidth(),
               const LineStyle lineStyle = Shape::defaultLineStyle(),
               const LineCap cap = Shape::defaultLineCap(),
               const LineJoin join = Shape::defaultLineJoin(),
               int depth = -1 );

  const std::string & name() const override;

  Line & rotate( double angle, const Point & center ) override;

  Line rotated( double angle, const Point & center ) const;

  Line & rotate( double angle ) override;

  Line rotated( double angle ) const;


  Line & translate( double dx, double dy ) override;

  Line translated( double dx, double dy ) const;

  Line & scale( double sx, double sy ) override;

  Line & scale( double s ) override;

  Line scaled( double sx, double sy ) const;

  Line scaled( double s ) const;

  void scaleAll( double s ) override;

  Rect boundingBox( LineWidthFlag ) const override;

  Line * clone() const override;

  void flushPostscript( std::ostream & stream,
                        const TransformEPS & transform ) const override;

  void flushFIG( std::ostream & stream,
                 const TransformFIG & transform,
                 std::map<Color,int> & colormap ) const override;

  void flushSVG( std::ostream & stream,
                 const TransformSVG & transform ) const override;

  void flushTikZ( std::ostream & stream,
                  const TransformTikZ & transform ) const override;

private:
  static const std::string _name; 
protected:
  double _x1;   
  double _y1;   
  double _x2;   
  double _y2;   
};

struct Arrow : public Line {

  inline Arrow( double x1, double y1, double x2, double y2,
                Color penColor = Shape::defaultPenColor(),
                Color fillColor = Shape::defaultFillColor(),
                double lineWidth = Shape::defaultLineWidth(),
                const LineStyle lineStyle = Shape::defaultLineStyle(),
                const LineCap cap = Shape::defaultLineCap(),
                const LineJoin join = Shape::defaultLineJoin(),
                int depth = -1 );

  const std::string & name() const override;

  Arrow rotated( double angle, const Point & center ) const;

  Arrow rotated( double angle ) const;

  Arrow translated( double dx, double dy ) const;

  Arrow scaled( double sx, double sy ) const;

  Arrow scaled( double s ) const;

  Rect boundingBox( LineWidthFlag ) const override;

  void flushPostscript( std::ostream & stream,
                        const TransformEPS & transform ) const override;

  void flushFIG( std::ostream & stream,
                 const TransformFIG & transform,
                 std::map<Color,int> & colormap ) const override;

  void flushSVG( std::ostream & stream,
                 const TransformSVG & transform ) const override;

  void flushTikZ( std::ostream & stream,
                  const TransformTikZ & transform ) const override;

  Arrow * clone() const override;

private:
  static const std::string _name; 
};

struct Polyline : public Shape {

  inline Polyline( const std::vector<Point> & points,
                   bool closed,
                   Color penColor = Shape::defaultPenColor(),
                   Color fillColor = Shape::defaultFillColor(),
                   double lineWidth = Shape::defaultLineWidth(),
                   const LineStyle lineStyle = Shape::defaultLineStyle(),
                   const LineCap cap = Shape::defaultLineCap(),
                   const LineJoin join = Shape::defaultLineJoin(),
                   int depth = -1 );

  inline Polyline( const Path & path,
                   Color penColor = Shape::defaultPenColor(),
                   Color fillColor = Shape::defaultFillColor(),
                   double lineWidth = Shape::defaultLineWidth(),
                   const LineStyle lineStyle = Shape::defaultLineStyle(),
                   const LineCap cap = Shape::defaultLineCap(),
                   const LineJoin join = Shape::defaultLineJoin(),
                   int depth = -1 );

  inline Polyline( bool closed,
                   Color penColor = Shape::defaultPenColor(),
                   Color fillColor = Shape::defaultFillColor(),
                   double lineWidth = Shape::defaultLineWidth(),
                   const LineStyle lineStyle = Shape::defaultLineStyle(),
                   const LineCap cap = Shape::defaultLineCap(),
                   const LineJoin join = Shape::defaultLineJoin(),
                   int depth = -1 );

  const std::string & name() const override;

  Polyline & operator<<( const Point & p );

  Point & operator[]( const std::size_t n ) {
    return _path[ n ];
  }

  const Point & operator[]( const std::size_t n ) const {
    return _path[ n ];
  }

  Polyline & rotate( double angle, const Point & center ) override;

  Polyline rotated( double angle, const Point & center ) const;

  Polyline & rotate( double angle ) override;

  Polyline rotated( double angle ) const;

  Polyline & translate( double dx, double dy ) override;

  Polyline translated( double dx, double dy ) const;

  Polyline & scale( double sx, double sy ) override;

  Polyline & scale( double s ) override;

  Polyline scaled( double sx, double sy )  const;

  Polyline scaled( double s )  const;

  void scaleAll( double s ) override;

  void flushPostscript( std::ostream & stream,
                        const TransformEPS & transform ) const override;

  void flushFIG( std::ostream & stream,
                 const TransformFIG & transform,
                 std::map<Color,int> & colormap ) const override;

  void flushSVG( std::ostream & stream,
                 const TransformSVG & transform ) const override;

  void flushTikZ( std::ostream & stream,
                  const TransformTikZ & transform ) const override;

  Rect boundingBox( LineWidthFlag ) const override;

  Polyline * clone() const override;

  inline std::size_t vertexCount() const;

  inline const Path & path() const;

private:
  static const std::string _name; 
protected:
  Path _path;
};

struct Rectangle : public Polyline {

  inline Rectangle( double left, double top, double width, double height,
                    Color penColor = Shape::defaultPenColor(),
                    Color fillColor = Shape::defaultFillColor(),
                    double lineWidth = Shape::defaultLineWidth(),
                    const LineStyle lineStyle = Shape::defaultLineStyle(),
                    const LineCap cap = Shape::defaultLineCap(),
                    const LineJoin join = Shape::defaultLineJoin(),
                    int depth = -1 );

  inline Rectangle( const Rect & rect,
                    Color penColor = Shape::defaultPenColor(),
                    Color fillColor = Shape::defaultFillColor(),
                    double lineWidth = Shape::defaultLineWidth(),
                    const LineStyle lineStyle = Shape::defaultLineStyle(),
                    const LineCap cap = Shape::defaultLineCap(),
                    const LineJoin join = Shape::defaultLineJoin(),
                    int depth = -1 );

  const std::string & name() const override;
  double x() const { return _path[0].x; }
  double y() const { return _path[0].y; }
  double width() const { return (_path[1] - _path[0]).norm(); }
  double height() const { return (_path[0] - _path[3]).norm(); }
  Point topLeft() const { return Point( _path[0].x, _path[0].y ); }
  Point topRight() const { return Point( _path[1].x, _path[1].y ); }
  Point bottomLeft() const { return Point( _path[3].x, _path[3].y ); }
  Point bottomRight() const { return Point( _path[2].x, _path[2].y ); }

  Rectangle rotated( double angle, const Point & center )  const;

  Rectangle rotated( double angle ) const;

  Rectangle translated( double dx, double dy ) const;

  Rectangle scaled( double sx, double sy ) const;

  Rectangle scaled( double s ) const;

  void scaleAll( double s ) override;

  void flushFIG( std::ostream & stream,
                 const TransformFIG & transform,
                 std::map<Color,int> & colormap ) const override;

  void flushSVG( std::ostream & stream,
                 const TransformSVG & transform ) const override;

  void flushTikZ( std::ostream & stream,
                  const TransformTikZ & transform ) const override;

  Rectangle * clone() const override;

private:
  static const std::string _name; 
protected:
  bool _isRectangle;
};


struct Triangle : public Polyline {

  Triangle( const Point & p1, const Point & p2, const Point & p3,
            Color penColor = Shape::defaultPenColor(),
            Color fillColor = Shape::defaultFillColor(),
            double lineWidth = Shape::defaultLineWidth(),
            const LineStyle lineStyle = Shape::defaultLineStyle(),
            const LineCap cap = Shape::defaultLineCap(),
            const LineJoin join = Shape::defaultLineJoin(),
            int depth = -1 )
    : Polyline( std::vector<Point>(), true, penColor, fillColor, lineWidth, lineStyle, cap, join, depth ) {
    _path << p1;
    _path << p2;
    _path << p3;
  }

  Triangle( const double x1, const double y1,
            const double x2, const double y2,
            const double x3, const double y3,
            Color penColor = Shape::defaultPenColor(),
            Color fillColor = Shape::defaultFillColor(),
            double lineWidth = Shape::defaultLineWidth(),
            const LineStyle lineStyle = Shape::defaultLineStyle(),
            const LineCap cap = Shape::defaultLineCap(),
            const LineJoin join = Shape::defaultLineJoin(),
            int depth = -1 )
    : Polyline( std::vector<Point>(), true, penColor, fillColor, lineWidth, lineStyle, cap, join, depth ) {
    _path << Point( x1, y1 );
    _path << Point( x2, y2 );
    _path << Point( x3, y3 );
  }

  const std::string & name() const override;

  Triangle rotated( double angle ) const;

  Triangle translated( double dx, double dy ) const;

  Triangle scaled( double sx, double sy ) const;

  Triangle scaled( double s ) const;

  Triangle * clone() const override;

private:
  static const std::string _name; 
protected:
};


struct GouraudTriangle : public Polyline {


  GouraudTriangle( const Point & p0, const Color & color0,
                   const Point & p1, const Color & color1,
                   const Point & p2, const Color & color2,
                   int subdivisions,
                   int depth = -1 );

  GouraudTriangle( const Point & p0, float brightness0,
                   const Point & p1, float brightness1,
                   const Point & p2, float brightness2,
                   const Color & fillColor,
                   int subdivisions,
                   int depth = -1 );

  const std::string & name() const override;

  GouraudTriangle & rotate( double angle, const Point & center ) override;

  GouraudTriangle rotated( double angle, const Point & center ) const;

  GouraudTriangle & rotate( double angle ) override;

  GouraudTriangle rotated( double angle ) const;

  GouraudTriangle translated( double dx, double dy ) const;

  GouraudTriangle scaled( double sx, double sy ) const;

  GouraudTriangle scaled( double s ) const;


  void scaleAll( double s ) override;

  void flushPostscript( std::ostream & stream,
                        const TransformEPS & transform ) const override;

  void flushFIG( std::ostream & stream,
                 const TransformFIG & transform,
                 std::map<Color,int> & colormap ) const override;

  void flushSVG( std::ostream & stream,
                 const TransformSVG & transform ) const override;

  void flushTikZ( std::ostream & stream,
                  const TransformTikZ & transform ) const override;

  GouraudTriangle * clone() const override;

private:
  static const std::string _name; 
protected:
  Color _color0;
  Color _color1;
  Color _color2;
  int _subdivisions;
};

struct Ellipse : public Shape {

  Ellipse( double x, double y,
           double xRadius, double yRadius,
           Color penColor = Shape::defaultPenColor(),
           Color fillColor = Shape::defaultFillColor(),
           double lineWidth = Shape::defaultLineWidth(),
           const LineStyle lineStyle = Shape::defaultLineStyle(),
           int depth = -1 )
    : Shape( penColor, fillColor,
             lineWidth, lineStyle, ButtCap, MiterJoin, depth ),
      _center( x, y ), _xRadius( xRadius ), _yRadius( yRadius ),
      _angle( 0.0 ),
      _circle( false ) {
    while ( _angle > M_PI_2 ) _angle -= M_PI;
    while ( _angle < -M_PI_2 ) _angle += M_PI;
  }

  Ellipse( Point center,
           double xRadius, double yRadius,
           Color penColor = Shape::defaultPenColor(),
           Color fillColor = Shape::defaultFillColor(),
           double lineWidth = Shape::defaultLineWidth(),
           const LineStyle lineStyle = Shape::defaultLineStyle(),
           int depth = -1 )
    : Shape( penColor, fillColor,
             lineWidth, lineStyle, ButtCap, MiterJoin, depth ),
      _center( center ), _xRadius( xRadius ), _yRadius( yRadius ),
      _angle( 0.0 ),
      _circle( false ) {
    while ( _angle > M_PI_2 ) _angle -= M_PI;
    while ( _angle < -M_PI_2 ) _angle += M_PI;
  }

  const std::string & name() const override;

  Point center(LineWidthFlag lineWidthFlag = IgnoreLineWidth) const override;

  Ellipse & rotate( double angle, const Point & center ) override;

  Ellipse rotated( double angle, const Point & center ) const;

  Ellipse & rotate( double angle ) override;

  Ellipse rotated( double angle ) const;

  Ellipse & translate( double dx, double dy ) override;

  Ellipse translated( double dx, double dy ) const;

  Ellipse & scale( double sx, double sy ) override;

  Ellipse & scale( double s ) override;

  Ellipse scaled( double sx, double sy ) const;

  Ellipse scaled( double s ) const;

  void scaleAll( double s ) override;

  void flushPostscript( std::ostream & stream,
                        const TransformEPS & transform ) const override;

  void flushFIG( std::ostream & stream,
                 const TransformFIG & transform,
                 std::map<Color,int> & colormap ) const override;

  void flushSVG( std::ostream & stream,
                 const TransformSVG & transform ) const override;

  void flushTikZ( std::ostream & stream,
                  const TransformTikZ & transform ) const override;

  Rect boundingBox( LineWidthFlag ) const override;

  Ellipse * clone() const override;

private:
  static const std::string _name; 
protected:
  Point _center;
  double _xRadius;
  double _yRadius;
  double _angle;
  bool _circle;
};

struct Circle : public Ellipse {

  Circle( double x, double y, double radius,
          Color penColor = Shape::defaultPenColor(),
          Color fillColor = Shape::defaultFillColor(),
          double lineWidth = Shape::defaultLineWidth(),
          const LineStyle lineStyle = Shape::defaultLineStyle(),
          int depth = -1 )
    : Ellipse( x, y, radius, radius, penColor, fillColor, lineWidth, lineStyle, depth )
  { _circle = true; }

  Circle( Point center, double radius,
          Color penColor = Shape::defaultPenColor(),
          Color fillColor = Shape::defaultFillColor(),
          double lineWidth = Shape::defaultLineWidth(),
          const LineStyle lineStyle = Shape::defaultLineStyle(),
          int depth = -1 )
    : Ellipse( center, radius, radius, penColor, fillColor, lineWidth, lineStyle, depth )
  { _circle = true; }

  const std::string & name() const override;

  Point center(LineWidthFlag lineWidthFlag = IgnoreLineWidth) const override;

  Circle & rotate( double angle, const Point & center ) override;

  Circle rotated( double angle, const Point & center ) const;

  Circle & rotate( double angle ) override;

  Circle rotated( double angle ) const;

  Circle & translate( double dx, double dy ) override;

  Circle translated( double dx, double dy ) const;

  Circle & scale( double sx, double sy ) override;

  Circle & scale( double s ) override;

  Circle scaled( double sx, double sy ) const;

  Circle scaled( double s ) const;

  void scaleAll( double s ) override;

  void flushSVG( std::ostream & stream,
                 const TransformSVG & transform ) const override;

  void flushTikZ( std::ostream & stream,
                  const TransformTikZ & transform ) const override;

  Circle * clone() const override;

private:
  static const std::string _name; 
};

struct Text : public Shape {

  Text( double x, double y,
        const std::string & text,
        const Fonts::Font font,
        double size,
        Color color = Color::Black,
        int depth = -1 );

  Text( Point p,
        const std::string & text,
        const Fonts::Font font,
        double size,
        Color color = Color::Black,
        int depth = -1 );

  Text( double x, double y,
        const std::string & text,
        const Fonts::Font font,
        const std::string & svgFont,
        double size,
        Color color = Color::Black,
        int depth = -1 );

  Text( Point p,
        const std::string & text,
        const Fonts::Font font,
        const std::string & svgFont,
        double size,
        Color color = Color::Black,
        int depth = -1 );

  const std::string & name() const override;

  Point center(LineWidthFlag lineWidthFlag = IgnoreLineWidth) const override;

  Text & rotate( double angle, const Point & center ) override;

  Text rotated( double angle, const Point & center ) const;

  Text & rotate( double angle ) override;

  Text rotated( double angle ) const;

  Text & translate( double dx, double dy ) override;

  Text translated( double dx, double dy ) const;

  Text & scale( double sx, double sy ) override;

  Text & scale( double s ) override;

  Text scaled( double sx, double sy ) const;

  Text scaled( double s ) const;

  void scaleAll( double s ) override;

  void flushPostscript( std::ostream & stream,
                        const TransformEPS & transform ) const override;

  void flushFIG( std::ostream & stream,
                 const TransformFIG & transform,
                 std::map<Color,int> & colormap ) const override;

  void flushSVG( std::ostream & stream,
                 const TransformSVG & transform ) const override;

  void flushTikZ( std::ostream & stream,
                  const TransformTikZ & transform ) const override;

  Rect boundingBox( LineWidthFlag ) const override;

  Text * clone() const override;

private:

  static const std::string _name; 
  double boxHeight(const Transform &) const;
  double boxLength(const Transform &) const;

  double angle() const;

  Point position() const;

protected:
  std::string _text;
  Fonts::Font _font;
  std::string _svgFont;
  double _size;
  double _xScale;
  double _yScale;
  Path _box;           // Rectangle around the text
};

bool shapeGreaterDepth( const Shape *s1, const Shape *s2 );


} // namespace LibBoard

/*
 * Inline methods
 */
#include "Shapes.ih"

#if __cplusplus<201100
#undef override
#endif


#endif /* _SHAPE_H_ */