DraWinObj.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno    
//
// This file is part of MIP.
//
// MIP is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// MIP is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------



#ifndef __DRA_WIN_OBJ_H_
#define __DRA_WIN_OBJ_H_

#ifdef MIP_HOST_APPLE
#include <applePatch.h>
#endif

#include <assert.h>
#include <algorithm>

#include <baselib.h>


using namespace std;

namespace MipResources{
 /* @{ */


// /// \class DraWinBoundBox
// /// \brief DraWin bounding box, represents 2D margins of the drawing scene.
// /// \author Antonio Franchi
// ///
// class DraWinBoundBox : public BoundBox{
//  private:
//   friend class DraWinGL;
//   
//  public:
//   
//   /// Default constructor
//   DraWinBoundBox() : BoundBox(){};
//   
//   /// Constructor with parameters
//   /// \param xm desired BB xmin
//   /// \param ym desired BB ymin
//   /// \param xM desired BB xmax
//   /// \param yM desired BB xmax
//   DraWinBoundBox(Decimal xm,Decimal ym,Decimal xM,Decimal yM) : BoundBox(xm,ym,xM,yM){};
//   
//   /// Constructor with parameters
//   /// \param p1 desired BB (xmin,ymin)
//   /// \param p2 desired BB (xmax,ymax)
//   DraWinBoundBox(Position p1,Position p2) : BoundBox(p1,p2){} ;
//   
//   
// 
//    DraWinBoundBox& operator=(const DraWinBoundBox& f){
//    if (this != &f){      // Not necessary in this case but it is useful to don't forget it
//     xm = f.xm; ///< current BB xmin
//     ym = f.ym; ///< current BB ymin
//     xM = f.x; ///< current BB xmax
//     yM = f.xm; ///< current BB xmax
//    }
//    return *this;
//   };
//   
// };



class DraWinBoundBox{
 private:
  friend class DraWinGL;
  
  static const Decimal DRA_WIN_BB_DEFAULT_XMIN; 
  static const Decimal DRA_WIN_BB_DEFAULT_YMIN; 
  static const Decimal DRA_WIN_BB_DEFAULT_XMAX; 
  static const Decimal DRA_WIN_BB_DEFAULT_YMAX; 
  bool _clear;  
  bool _locked; 
  
  inline void clear(){
   _clear = true;
   unlock();
  }
  inline void unlock(){
   _locked = false;
  }
  inline void lock(){
   _locked = true;
  }
  
 public:
  Decimal xm; 
  Decimal ym; 
  Decimal xM; 
  Decimal yM; 
  
  DraWinBoundBox();
  
  DraWinBoundBox(Decimal xm,Decimal ym,Decimal xM,Decimal yM);
  
  DraWinBoundBox(Position p1,Position p2);
  
  void extend(DraWinBoundBox bb);
  
  void extend(Position p);
  
  inline Decimal diameter(){
   return sqrt((xM-xm)*(xM-xm) + (yM-ym)*(yM-ym));
  }
  
  inline Position center(){
   return Position( (xM+xm)/2.0 , (yM-ym)/2.0 );
  }
  
  const DraWinBoundBox operator*(Pose p);
};

class ColorComponent{
 private:
  Decimal _value;
 public:
  inline ColorComponent(){
   _value = 0.0;
  }
  inline ColorComponent(Decimal c){
   _value=min(Decimal(1.0),max(Decimal(0.0),c));
  }
  inline ColorComponent(const ColorComponent& c){
   _value = c._value;
  }
  ColorComponent& operator =(const ColorComponent& c);
  
  string print();
  
  inline operator Decimal(){
   return _value;
  }
};

class Color{
 private:
  ColorComponent _red;
  ColorComponent _green;
  ColorComponent _blue;
 public:
  Color(){}
  Color(Decimal r,Decimal g,Decimal b);
  
  Color(const Color& c);
  
  Color& operator =(const Color& c);
  
  inline ColorComponent red(){
   return _red;
  }
  inline ColorComponent green(){
   return _green;
  }
  inline ColorComponent blue(){
   return _blue;
  }
  string print();
};


class Colors{
 private:
  static const Decimal NONE;
  static const Decimal DARK;
  static const Decimal MEDIUM;
  static const Decimal LIGHT;
 public:
  static const Color black()   {return Color(NONE,NONE,NONE);}
  static const Color white()   {return Color(LIGHT,LIGHT,LIGHT);}
  /*grey*/
  static const Color darkGrey()  {return Color(DARK,DARK,DARK);}
  static const Color lightGrey() {return Color(MEDIUM,MEDIUM,MEDIUM);}
  /*red*/
  static const Color lightRed()  {return Color(LIGHT,NONE,NONE);}
  static const Color red()    {return Color(MEDIUM,NONE,NONE);}
  static const Color darkRed()  {return Color(DARK,NONE,NONE);}
  /*green*/
  static const Color lightGreen() {return Color(NONE,LIGHT,NONE);}
  static const Color green()   {return Color(NONE,MEDIUM,NONE);}
  static const Color darkGreen() {return Color(NONE,DARK,NONE);}
  /*blue*/
  static const Color lightBlue() {return Color(NONE,NONE,LIGHT);}
  static const Color blue()    {return Color(NONE,NONE,MEDIUM);}
  static const Color darkBlue()  {return Color(NONE,NONE,DARK);}
  /*magenta*/
  static const Color lightMagenta() {return Color(LIGHT,NONE,LIGHT);}
  static const Color magenta()   {return Color(MEDIUM,NONE,MEDIUM);}
  static const Color darkMagenta() {return Color(DARK,NONE,DARK);}
  /*cyan*/
  static const Color lightCyan() {return Color(NONE,LIGHT,LIGHT);}
  static const Color cyan()    {return Color(NONE,MEDIUM,MEDIUM);}
  static const Color darkCyan()  {return Color(NONE,DARK,DARK);}
  /*yellow*/
  static const Color lightYellow(){return Color(LIGHT,LIGHT,NONE);}
  static const Color yellow()   {return Color(MEDIUM,MEDIUM,NONE);}
  static const Color darkYellow() {return Color(DARK,DARK,NONE);}
  /*orange*/
  static const Color orange()   {return Color(LIGHT,MEDIUM,NONE);}
  static const Color darkOrange() {return Color(MEDIUM,DARK,NONE);}
  /******/
  
  
};

enum DraWinObjPlate{
 DRA_WIN_OBJ_NULL,
 DRA_WIN_OBJ_POINT_2D,
 DRA_WIN_OBJ_POINTS_2D,
 DRA_WIN_OBJ_POLYGON_2D,
 DRA_WIN_OBJ_SEG_2D,
 DRA_WIN_OBJ_DISK_2D,
 DRA_WIN_OBJ_MOBROB_2D,
 DRA_WIN_OBJ_KHEPERA_2D,
 DRA_WIN_OBJ_QUAD_3D,
 DRA_WIN_OBJ_PAR_3D,
 DRA_WIN_OBJ_HLINE_2D,
 DRA_WIN_OBJ_CMD_BB_2D,
 DRA_WIN_OBJ_COV_ELLIPSE_2D,
 DRA_WIN_OBJ_NUM
};

static const char* draWinObjNames[DRA_WIN_OBJ_NUM]={
 "DraWinObjNull",
 "DraWinObjPoint2D",
 "DraWinObjPoints2D",
 "DraWinObjPolygon2D",
 "DraWinObjSeg2D",
 "DraWinObjDisk2D",
 "DraWinObjMobRob2D",
 "DraWinObjKhepera2D",
 "DraWinObjQuad3D",
 "DraWinObjParallelepiped3D",
 "DraWinObjHalfLine2D",
 "DraWinObjCovEllipse2D",
 "DraWinObjCmdBB2D"
};

class DraWinObj{
 protected:
  Color _color;
  Pose _pose;
 public:
  virtual DraWinObjPlate plate()=0;

  inline void setPose(Pose p){
   _pose = p;
  }
  inline Pose pose(void){
   return _pose;
  }
  inline void setColor(Color c){
   _color = c;
  }
  void setColor(int num);
  
  inline Color color(void){
   return _color;
  }
  
  virtual void boundBox(DraWinBoundBox& bb)=0;
};

class CmdDraWinObj : public DraWinObj{};

class FigDraWinObj : public DraWinObj{};


typedef  vector<DraWinObj*> DraWinList;


typedef  vector<DraWinList> DraWinLists;


class Point2D : public FigDraWinObj{
 private:
  Position _point;
  Decimal  _pointSize;
 public:
  Point2D(Position p,Decimal pS=1.0);
  
  inline DraWinObjPlate plate(){
   return DRA_WIN_OBJ_POINT_2D;
  }
  
  inline Position point(){
   return _point;
  }
  
  inline Decimal pointSize(){
   return _pointSize;
  }
  
  void boundBox(DraWinBoundBox& bb);
};

class Points2D : public FigDraWinObj{
 private:
  vector<Position> _points;
  Decimal   _pointsSize;
  unsigned int _size;
  DraWinBoundBox _bb;
 public:
  Points2D(unsigned int projectedSize,Decimal pS = 1.0);
  
  unsigned int  push_back(Position p);
  
  inline Position point(unsigned int i){
   assert(i<_size);
   return _points[i];
  }
  
  inline DraWinObjPlate plate(){
   return DRA_WIN_OBJ_POINTS_2D;
  }
  
  inline unsigned int size(){
   return _size;
  }
  
  inline Decimal pointsSize(){
   return _pointsSize;
  }
  
  inline void boundBox(DraWinBoundBox& bb){
   bb = _bb*pose();
  }
};


class Polygon2D : public Points2D{
 private:
  bool   _contour/*,_fillAndContour*/;
  Decimal  _thickness;
 public:
  
  inline Polygon2D(unsigned int projectedSize, bool contour=false, Decimal thickness=1.0/*, bool fillAndContour=false*/) : Points2D(projectedSize){
   _contour = contour;
   _thickness = thickness;
//    _fillAndContour = fillAndContour;
  }
  
  inline bool contour(){
   return _contour;
  }
  
  inline Decimal thickness(){
   return _thickness;
  }

  inline DraWinObjPlate plate(){
   return DRA_WIN_OBJ_POLYGON_2D;
  }
};


class Segment2D : public FigDraWinObj{
 private:
  Position _p1,_p2;
 public:
  
  Segment2D(Position v1,Position v2){
   _p1 = v1;
   _p2 = v2;
  }
  
  DraWinObjPlate plate(){
   return DRA_WIN_OBJ_SEG_2D;
  }
  
  Position p1(){
   return _p1;
  }
  
  Position p2(){
   return _p2;
  }
  
  void boundBox(DraWinBoundBox& bb);
};

class Disk2D : public FigDraWinObj{
 private:
  Position _center;
  Decimal   _extRadius;
  Decimal   _intRadius;
  
 public:
  Disk2D(Position c,Decimal er,Decimal ir=0.0);
  
  inline DraWinObjPlate plate(){
   return DRA_WIN_OBJ_DISK_2D;
  }
  
  inline Position center(){
   return _center;
  }
  
  inline Decimal intRadius(){
   return _intRadius;
  }
  
  inline Decimal extRadius(){
   return _extRadius;
  }
  
  inline Decimal radius(){
   return extRadius();
  }
  
  void boundBox(DraWinBoundBox& bb);
};


class MobileRob2D : public FigDraWinObj{
 private:
  Pose _pose;
  Decimal _radius;
 public:

  MobileRob2D(Pose q,Decimal r);
  
  inline DraWinObjPlate plate(){
   return DRA_WIN_OBJ_MOBROB_2D;
  }
  
  inline Pose pose(){
   return _pose;
  }
  
  inline Decimal radius(){
   return _radius;
  }
  
  void boundBox(DraWinBoundBox& bb);
};




class Khepera2D : public FigDraWinObj{
 private:
  Pose _pose;
  Decimal _radius;
 public:

  Khepera2D(Pose q);
  
  inline DraWinObjPlate plate(){
   return DRA_WIN_OBJ_KHEPERA_2D;
  }
  
  inline Pose pose(){
   return _pose;
  }
  
  inline Decimal radius(){
   return _radius;
  }
  
  void boundBox(DraWinBoundBox& bb);
};

class Quad3D : public FigDraWinObj{
 private:
  Pose3D _pose;
  Decimal _radius;
 public:

  Quad3D(Pose3D q,Decimal rad);
  
  inline DraWinObjPlate plate(){
   return DRA_WIN_OBJ_QUAD_3D;
  }
  
  inline Pose3D pose(){
   return _pose;
  }
  
  inline Decimal radius(){
   return _radius;
  }
  
  void boundBox(DraWinBoundBox& bb);
};

class Parallelepiped3D : public FigDraWinObj{
 private:
  Position3D _x1;
  Position3D _x2;
  Position3D _trasl;
  Orientation3D _ori;
  Decimal _red; 
  Decimal _green;
  Decimal _blue;
  
 public:

  Parallelepiped3D(Decimal x1,Decimal x2,Decimal y1,Decimal y2,Decimal z1,Decimal z2, Position3D trasl, Orientation3D ori,Decimal red,Decimal green,Decimal blue);
  
  Parallelepiped3D(Position3D startPoint,Position3D endPoint,Position3D trasl, Orientation3D ori,Decimal red,Decimal green,Decimal blue);
  
  inline DraWinObjPlate plate(){
   return DRA_WIN_OBJ_PAR_3D;
  }
  
  inline Position3D initPos(){
   return _x1;
  }
  
  inline Position3D endingPos(){
   return _x2;
  }
  
  inline Decimal getRed(){
   return _red;
  }
  
  inline Decimal getGreen(){
   return _green;
  }
  
  inline Decimal getBlue(){
   return _blue;
  }
  
  inline Position3D getTrasl(){
   return _trasl;
  }
  
  inline Orientation3D getOri(){
   return _ori;
  }
  
  void boundBox(DraWinBoundBox& bb);
};



class HLine2D : public FigDraWinObj{
 private:
  Pose _p;
 public:
  
  inline HLine2D(Position orig,Angle dir){
   _p = Pose(orig,dir);
  }
  
  inline DraWinObjPlate plate(){
   return DRA_WIN_OBJ_HLINE_2D;
  }
  
  inline Position origin(){
   return _p.pos();
  }
  
  inline Angle direction(){
   return _p.ori();
  }
  
  void boundBox(DraWinBoundBox& bb);
};


class CmdBB2D : public CmdDraWinObj{
 private:
  Position _pm,_pM;
 public:
  
  inline CmdBB2D(Position p1,Position p2){
   _pm = Position(min(p1.x(),p2.x()),min(p1.y(),p2.y()));
   _pM = Position(max(p1.x(),p2.x()),max(p1.y(),p2.y()));
  }
  
  CmdBB2D(Position center,Decimal halfLx,Decimal halfLy);
  
  inline DraWinObjPlate plate(){
   return DRA_WIN_OBJ_CMD_BB_2D;
  }
  
  void boundBox(DraWinBoundBox& bb);
};


class CovEllipse2D: public FigDraWinObj{
 private:
  Position  _mean;
  Decimal   _cov[2][2];
  
  Decimal   _eigenval[2];
  Position  _eigenvec[2];
  
  int     _samples;
  
 public:
  CovEllipse2D(Position m, Decimal c[2][2], int s=20);
  
  inline DraWinObjPlate plate(){
   return DRA_WIN_OBJ_COV_ELLIPSE_2D;
  }
  
  inline Position mean(){
   return _mean;
  }
  
  inline Decimal eigenvalue1(){
   return _eigenval[0];
  }
  
  inline Decimal eigenvalue2(){
   return _eigenval[1];
  }
  
  inline Position eigenvector1(){
   return _eigenvec[0];
  }
  
  inline Position eigenvector2(){
   return _eigenvec[1];
  }
  
  inline int samples(){
   return _samples;
  }
  
  void boundBox(DraWinBoundBox& bb);
};
 


/* @} */
 
};// end namespace MipResources{


#endif