SO3Point.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program 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 Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#ifndef __SO3_POINT_H__
#define __SO3_POINT_H__
 
#include "SCOLBasic/SO3Prerequisites.h"
 
namespace SO3
{
 
template <typename NUMERIC_TYPE> class SPoint
{
public:
  NUMERIC_TYPE x;
  NUMERIC_TYPE y;
 
  // special points
  static const SPoint ZERO;
  static const SPoint UNIT_X;
  static const SPoint UNIT_Y;
  static const SPoint NEGATIVE_UNIT_X;
  static const SPoint NEGATIVE_UNIT_Y;
  static const SPoint UNIT_SCALE;
protected:
private:
 
public:
  inline SPoint<NUMERIC_TYPE>()
  {
    x = 0;
    y = 0;
  }
 
  inline SPoint<NUMERIC_TYPE>(const NUMERIC_TYPE& fX, const NUMERIC_TYPE& fY) : x(fX), y(fY)
  {
  }
 
  inline explicit SPoint<NUMERIC_TYPE>(const NUMERIC_TYPE& scaler) : x(scaler), y(scaler)
  {
  }
 
  inline explicit SPoint<NUMERIC_TYPE>(const NUMERIC_TYPE afCoordinate[2]) : x(afCoordinate[0]), y(afCoordinate[1])
  {
  }
 
  inline explicit SPoint<NUMERIC_TYPE>(NUMERIC_TYPE* const r) : x(r[0]), y(r[1])
  {
  }
 
  inline float operator [] (const size_t& i) const
  {
    //assert(i < 2);
    return *(&x+i);
  }
 
  inline float& operator [] (const size_t& i)
  {
    //assert(i < 2);
    return *(&x+i);
  }
 
  inline NUMERIC_TYPE* ptr()
  {
          return &x;
  }
 
  inline const NUMERIC_TYPE* ptr() const
  {
          return &x;
  }
 
  inline SPoint<NUMERIC_TYPE>& operator = (const SPoint<NUMERIC_TYPE>& copyPoint)
  {
    x = copyPoint.x;
    y = copyPoint.y;
    return *this;
  }
 
  inline SPoint<NUMERIC_TYPE>& operator = (const float& fScalar)
  {
          x = fScalar;
        y = fScalar;
          return *this;
  }
 
  inline bool operator == (const SPoint<NUMERIC_TYPE>& copyPoint) const
  {
    return (x == copyPoint.x && y == copyPoint.y);
  }
 
  inline bool operator != (const SPoint<NUMERIC_TYPE>& copyPoint) const
  {
    return (x != copyPoint.x || y != copyPoint.y);
  }
 
  inline SPoint<NUMERIC_TYPE> operator + (const SPoint<NUMERIC_TYPE>& copyPoint) const
  {
    return SPoint<NUMERIC_TYPE>(x + copyPoint.x, y + copyPoint.y);
  }
 
  inline SPoint<NUMERIC_TYPE> operator - (const SPoint<NUMERIC_TYPE>& copyPoint) const
  {
    return SPoint<NUMERIC_TYPE>(x - copyPoint.x, y - copyPoint.y);
  }
 
  inline SPoint<NUMERIC_TYPE> operator * (const NUMERIC_TYPE& fScalar) const
  {
    return SPoint<NUMERIC_TYPE>(x * fScalar, y * fScalar);
  }
 
  inline SPoint<NUMERIC_TYPE> operator * (const SPoint<NUMERIC_TYPE>& rhs) const
  {
    return SPoint<NUMERIC_TYPE>(x * rhs.x, y * rhs.y);
  }
 
  inline SPoint<NUMERIC_TYPE> operator / (const float& fScalar) const
  {
    //assert(fScalar != 0.0);
    float fInv = 1.0 / fScalar;
    return SPoint<NUMERIC_TYPE>(x * fInv, y * fInv);
  }
 
  inline SPoint<NUMERIC_TYPE> operator / (const SPoint<NUMERIC_TYPE>& rhs) const
  {
    return SPoint<NUMERIC_TYPE>(x / rhs.x, y / rhs.y);
  }
 
  inline const SPoint<NUMERIC_TYPE>& operator + () const
  {
    return *this;
  }
 
  inline SPoint<NUMERIC_TYPE> operator - () const
  {
    return SPoint<NUMERIC_TYPE>(-x, -y);
  }
 
  inline friend SPoint<NUMERIC_TYPE> operator * (const NUMERIC_TYPE& fScalar, const SPoint<NUMERIC_TYPE>& copyPoint)
  {
    return SPoint<NUMERIC_TYPE>(fScalar * copyPoint.x, fScalar * copyPoint.y);
  }
 
  inline friend SPoint<NUMERIC_TYPE> operator / (const NUMERIC_TYPE& fScalar, const SPoint<NUMERIC_TYPE>& copyPoint)
  {
    return SPoint<NUMERIC_TYPE>(fScalar / copyPoint.x, fScalar / copyPoint.y);
  }
 
  inline friend SPoint<NUMERIC_TYPE> operator + (const SPoint<NUMERIC_TYPE>& lhs, const NUMERIC_TYPE rhs)
  {
    return SPoint<NUMERIC_TYPE>(lhs.x + rhs, lhs.y + rhs);
  }
 
  inline friend SPoint<NUMERIC_TYPE> operator + (const NUMERIC_TYPE& lhs, const SPoint<NUMERIC_TYPE>& rhs)
  {
    return SPoint<NUMERIC_TYPE>(lhs + rhs.x, lhs + rhs.y);
  }
 
  inline friend SPoint<NUMERIC_TYPE> operator - (const SPoint<NUMERIC_TYPE>& lhs, const NUMERIC_TYPE& rhs)
  {
    return SPoint<NUMERIC_TYPE>(lhs.x - rhs, lhs.y - rhs);
  }
 
  inline friend SPoint<NUMERIC_TYPE> operator - (const NUMERIC_TYPE& lhs, const SPoint<NUMERIC_TYPE>& rhs)
  {
    return SPoint<NUMERIC_TYPE>(lhs - rhs.x, lhs - rhs.y);
  }
 
  inline SPoint<NUMERIC_TYPE>& operator += (const SPoint<NUMERIC_TYPE>& copyPoint)
  {
    x += copyPoint.x;
    y += copyPoint.y;
    return *this;
  }
 
  inline SPoint<NUMERIC_TYPE>& operator += (const NUMERIC_TYPE& fScaler)
  {
    x += fScaler;
    y += fScaler;
    return *this;
  }
 
  inline SPoint<NUMERIC_TYPE>& operator -= (const SPoint<NUMERIC_TYPE>& copyPoint)
  {
    x -= copyPoint.x;
    y -= copyPoint.y;
    return *this;
  }
 
  inline SPoint<NUMERIC_TYPE>& operator -= (const NUMERIC_TYPE& fScaler)
  {
    x -= fScaler;
    y -= fScaler;
    return *this;
  }
 
  inline SPoint<NUMERIC_TYPE>& operator *= (const NUMERIC_TYPE& fScalar)
  {
    x *= fScalar;
    y *= fScalar;
    return *this;
  }
 
  inline SPoint<NUMERIC_TYPE>& operator *= (const SPoint<NUMERIC_TYPE>& copyPoint)
  {
    x *= copyPoint.x;
    y *= copyPoint.y;
    return *this;
  }
 
  inline SPoint<NUMERIC_TYPE>& operator /= (const NUMERIC_TYPE& fScalar)
  {
    assert(fScalar != 0.0);
    float fInv = 1.0 / fScalar;
    x *= fInv;
    y *= fInv;
    return *this;
  }
 
  inline SPoint<NUMERIC_TYPE>& operator /= (const SPoint<NUMERIC_TYPE>& copyPoint)
  {
    x /= copyPoint.x;
    y /= copyPoint.y;
    return *this;
  }
 
  inline bool operator < (const SPoint<NUMERIC_TYPE>& rhs) const
  {
    if( x < rhs.x && y < rhs.y )
      return true;
 
    return false;
  }
 
  inline bool operator > (const SPoint<NUMERIC_TYPE>& rhs) const
  {
    if( x > rhs.x && y > rhs.y )
      return true;
 
    return false;
  }
protected:
private:
};
 
typedef SPoint<int> SPointInt;
typedef SPoint<short> SPointShort;
typedef SPoint<long> SPointLong;
typedef SPoint<unsigned int> SPointUInt;
typedef SPoint<unsigned short> SPointUShort;
typedef SPoint<unsigned long> SPointULong;
typedef SPoint<float> SPointFloat;
typedef SPoint<double> SPointDouble;
 
}
 
#endif