typeUtils.h

Go to the documentation of this file.

#ifndef TYPE_UTILS_H
#define TYPE_UTILS_H

#include <math.h>
#include "math_util.h"


namespace VXV {
  enum Align {
    Top =       0x01,
    Middle =    0x02,
    Bottom =    0x04,
    Left =      0x08,
    Center =    0x10,
    Right =     0x20,
  };

  const double DEG2RAD = 2.0 * M_PI / 360.0; 
  const double RAD2DEG = 1.0 / DEG2RAD; 
  class Grid {
  public:
    int x;                      
    int y;                      
    Grid(void) : x(0), y(0) {};

    Grid(int x, int y) : x(x), y(y) {};

    Grid(const Grid* rhs) : x(rhs->x), y(rhs->y) {}

    virtual ~Grid(void) {}

    const Grid& operator+=(const Grid& rhs);

    const Grid operator+(const Grid& rhs) const {
      return Grid(this) += rhs;
    }

    const Grid& operator-=(const Grid& rhs);

    Grid operator-(const Grid& rhs) const {
      return Grid(this) -= rhs;
    }

    bool operator==(const Grid& rhs) const {
      return (this->x == rhs.x) && (this->y == rhs.y);
    }
  };


  class Grid3D : public Grid {
  public:
    int z;                      
    Grid3D(void) : z(0) {};

    Grid3D(int x, int y, int z) : Grid(x, y), z(z) {};

    Grid3D(int x, int y) : Grid(x, y), z(0) {};

    Grid3D(const Grid3D* rhs) : Grid(rhs->x, rhs->y), z(rhs->z) {}

    Grid3D(const Grid& rhs) : Grid(rhs.x, rhs.y), z(0) {}

    virtual ~Grid3D(void) {}

    const Grid3D& operator+=(const Grid3D& rhs);

    const Grid3D operator+(const Grid3D& rhs) const {
      return Grid3D(this) += rhs;
    }

    const Grid3D& operator-=(const Grid3D& rhs);

    Grid3D operator-(const Grid3D& rhs) const {
      return Grid3D(this) -= rhs;
    }
  };


  class Direction {
    double inner_radian;
    Direction(const double radian) : inner_radian(radian) {}

  public:
    Direction(void) : inner_radian(0.0) {}

    double getInnerRadian(void) const {
      return inner_radian;
    }

    Direction(const Direction* rhs) : inner_radian(rhs->inner_radian) {}

    virtual ~Direction(void) {}

    const Direction& operator+=(const Direction& rhs) {
      inner_radian += rhs.inner_radian;
      return *this;
    }

    const Direction operator+(const Direction& rhs) const {
      return Direction(this) += rhs;
    }

    bool operator==(const Direction& rhs) const {
      return (this->to_rad() == rhs.to_rad());
    }

    const Direction& operator-=(const Direction& rhs) {
      inner_radian -= rhs.inner_radian;
      return *this;
    }

    Direction operator-(const Direction& rhs) const {
      return Direction(this) -= rhs;
    }


    static Direction deg(int degree) {
      return Direction(2.0 * M_PI * degree / 360.0);
    }

    static Direction rad(double radian) {
      return Direction(radian);
    }

    const int to_deg(void) const;

    const double to_rad(void) const;
  };


  class Rect : public Grid {
  public:
    int w;                      
    int h;                      
    Rect(void) : Grid(0, 0), w(0), h(0) {}

    Rect(int w, int h) : Grid(0, 0), w(w), h(h) {}

    Rect(int x, int y, int w, int h) : VXV::Grid(x, y), w(w), h(h) {}

    virtual ~Rect(void) {}
  };


  class Position : public Grid {
  public:
    Direction zt;                       
    Position(void) {}

    Position(int x, int y, const Direction& zt) : Grid(x, y), zt(zt) {}

    Position(const Position* rhs)
      : Grid(rhs->x, rhs->y), zt(rhs->zt) {}

    bool operator==(const Position& rhs) const {
      return (this->x == rhs.x) && (this->y == rhs.y) && (this->zt == rhs.zt);
    }

    const Position& operator+=(const Position& rhs);

    const Position operator+(const Position& rhs) const {
      return Position(this) += rhs;
    }

    const Position& operator-=(const Position& rhs);

    const Position operator-(const Position& rhs) const {
      return Position(this) -= rhs;
    }

    virtual ~Position(void) {}
  };


  class Position3D : public Position {
  public:
    int z;                      
    Direction xt;               
    Direction yt;               
    Position3D(void) : z(0), xt(Direction()), yt(Direction()) {}

    Position3D(int x, int y, int z, Direction xt, Direction yt, Direction zt)
      : Position(x, y, zt), z(z), xt(xt), yt(yt) {}

    Position3D(const Position3D* rhs)
      : Position(rhs->x, rhs->y, rhs->zt),
        z(rhs->z), xt(rhs->xt), yt(rhs->yt) {}

    Position3D(const Position& rhs)
      : Position(rhs),
        z(0), xt(Direction()), yt(Direction()) {}

    bool operator==(const Position3D& rhs) const {
      return (this->x == rhs.x) && (this->y == rhs.y) && (this->z == rhs.z) &&
        (this->xt == rhs.xt) && (this->yt == rhs.yt) && (this->zt == rhs.zt);
    }

    const Position3D& operator+=(const Position3D& rhs);

    const Position3D operator+(const Position3D& rhs) const {
      return Position3D(this) += rhs;
    }

    const Position3D& operator-=(const Position3D& rhs);

    const Position3D operator-(const Position3D& rhs) const {
      return Position3D(this) -= rhs;
    }

    virtual ~Position3D(void) {}
  };

  extern int length(const Grid3D& position);


  typedef struct {
    double a11;                 
    double a21;                 
    double a31;                 
    double a12;                 
    double a22;                 
    double a32;                 
    double a13;                 
    double a23;                 
    double a33;                 
    int a41;                    
    int a42;                    
    int a43;                    
    int a44;                    
  } Matrix4D;

  extern Matrix4D createConvertMatrix(const Position3D pos);

  extern void convert(Position3D& converted, const Position3D& input,
                      const Matrix4D& matrix);

  extern void convertWithAngle(Position3D& converted, const Position3D& input,
                               const Position3D& forMatrix);
}

#endif /* !TYPE_UTILS_H */