angle.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_MATHS_ANGLE_H
#define BALL_MATHS_ANGLE_H

#ifndef BALL_COMMON_EXCEPTION_H
# include <BALL/COMMON/exception.h>
#endif

#ifndef BALL_COMMON_DEBUG_H
# include <BALL/COMMON/debug.h>
#endif

#ifndef BALL_COMMON_CREATE_H
# include <BALL/COMMON/create.h>
#endif

#ifndef BALL_MATHS_COMMON_H
# include <BALL/MATHS/common.h>
#endif

namespace BALL 
{
  template <typename T>
  class TAngle;

  template <typename T>
  BALL_INLINE
  TAngle<T> operator * (const T& val, const TAngle<T>& angle);

  template <typename T>
  BALL_INLINE
  TAngle<T> operator + (const T& val, const TAngle<T>& angle);

  template <typename T>
  BALL_INLINE
  TAngle<T> operator - (const T& val, const TAngle<T>& angle);

  template <typename T>
  class TAngle
  {
    public:

    BALL_CREATE(TAngle<T>)

    

    enum Range
    {
      // no limitations
      RANGE__UNLIMITED = 0, 
      // 0 <= angle <= 360, 0 <= angle <= (Constants::PI * 2)
      RANGE__UNSIGNED  = 1, 
      // -180 <= angle <= 180, -Constants::PI <= angle <= Constants::PI
      RANGE__SIGNED    = 2 
    };


    TAngle();

    TAngle(const TAngle& angle);

    explicit TAngle(const T& new_value, bool radian = true);

    virtual ~TAngle()
    {
    }

    virtual void clear()
    {
      value = (T)0;
    }


    void swap(TAngle& angle);

    void set(const T& new_value, bool radian = true);

    void set(const TAngle& angle);

    TAngle& operator = (const TAngle& angle);

    TAngle& operator = (const T& new_value);

    void get(TAngle& angle) const;

    void get(T& val, bool radian = true) const;



    operator T () const;

    T toRadian() const
  ;

    static T toRadian(const T& degree);

    T toDegree() const;

    static T toDegree(const T& radian);

    void normalize(Range range);

    void negate();

    TAngle operator + () const;

    TAngle operator - () const;

    TAngle& operator += (const TAngle& angle);

    TAngle& operator += (const T& val);

    TAngle operator + (const TAngle& angle);

    TAngle& operator -= (const TAngle& angle);

    TAngle& operator -= (const T& val);

    TAngle operator - (const TAngle& angle);

    TAngle& operator *= (const TAngle& angle);

    TAngle& operator *= (const T& val);

    TAngle& operator /= (const TAngle& angle);

    TAngle& operator /= (const T& val);

    TAngle operator / (const TAngle& val);



    bool operator == (const TAngle& angle) const;

    bool operator != (const TAngle& angle) const;

    bool operator < (const TAngle& angle) const;

    bool operator < (const T& val) const;

    bool operator <= (const TAngle& angle) const;

    bool operator >= (const TAngle& angle) const;

    bool operator > (const TAngle& angle) const;

    bool isEquivalent(TAngle angle) const;



    bool isValid () const;

    void dump(std::ostream& s = std::cout, Size depth = 0) const;



    T value;

  };

  template <typename T>
  TAngle<T>::TAngle()
    : value((T)0)
  {
  }

  template <typename T>
  TAngle<T>::TAngle(const TAngle& angle)
    : value((T)angle.value)
  {
  }

  template <typename T>
  TAngle<T>::TAngle(const T& new_value, bool radian)
    : value((radian == true)
       ? (T)new_value 
       : (T)BALL_ANGLE_DEGREE_TO_RADIAN((double)new_value))
  {
  }

  template <typename T>
  void TAngle<T>::swap(TAngle& angle)
  {
    T temp = value;
    value = angle.value;
    angle.value = temp;
  }

  template <typename T>
  void TAngle<T>::set(const TAngle& angle)
  {
    value = angle.value;
  }

  template <typename T>
  void TAngle<T>::set(const T& new_value, bool radian)
  {
    value = (radian == true)
       ? new_value 
       : BALL_ANGLE_DEGREE_TO_RADIAN(new_value);
  }

  template <typename T>
  TAngle<T>& TAngle<T>::operator = (const TAngle& angle)
  {
    value = angle.value;
    return *this;
  }

  template <typename T>
  TAngle<T>& TAngle<T>::operator = (const T& new_value)
  {
    value = new_value;
    return *this;
  }

  template <typename T>
  void TAngle<T>::get(TAngle& angle) const
  {
    angle.value = value;
  }

  template <typename T>
  void TAngle<T>::get(T& val, bool radian) const
  {
    val = (radian == true)
           ? value 
           : BALL_ANGLE_RADIAN_TO_DEGREE(value);
  }

  template <typename T>
  TAngle<T>::operator T () const
  {
    return value;
  }

  template <typename T>
  T TAngle<T>::toRadian() const
  {
    return value;
  }

  template <typename T>
  T TAngle<T>::toRadian(const T& degree)
  {
    return BALL_ANGLE_DEGREE_TO_RADIAN(degree);
  }

  template <typename T>
  T TAngle<T>::toDegree() const
  {
    if (value == (T) 0.0) return (T) 0.0;
    return BALL_ANGLE_RADIAN_TO_DEGREE(value);
  }

  template <typename T>
  T TAngle<T>::toDegree(const T& radian)
  {
    if (radian == (T) 0.0) return (T) 0.0;
    return BALL_ANGLE_RADIAN_TO_DEGREE(radian);
  }

  template <typename T>
  void TAngle<T>::normalize(Range range)
  {
    if (range == RANGE__UNLIMITED)
    {
      return;
    }

    long mod_factor = (long)(value / (2 * Constants::PI));
    value -= mod_factor * (Constants::PI * 2);

    while (Maths::isGreater(value, (Constants::PI * 2)))
    {
      value -= (Constants::PI * 2);
    }
    while (Maths::isLess(value, -(Constants::PI * 2)))
    {
      value += (Constants::PI * 2);
    }
    if (range == RANGE__SIGNED) // invariant: -180 to 180:
    {
      if (Maths::isGreater(value, Constants::PI)) 
      {
        value -= (Constants::PI * 2);
      }
    } 
    else 
    { // invariant: 0 to 360:
      if (Maths::isLess(value, 0)) 
      {
        value += (Constants::PI * 2);
      }
    }
  }

  template <typename T>
  void TAngle<T>::negate() 
  {
    value = -value;
  }

  template <typename T>
  TAngle<T> TAngle<T>::operator + () const 
  {
    return *this;
  }

  template <typename T>
  TAngle<T> TAngle<T>::operator - () const 
  {
    return TAngle(-value);
  }

  template <typename T>
  TAngle<T>& TAngle<T>::operator += (const TAngle& angle) 
  {
    value += angle.value;
    return *this;
  }

  template <typename T>
  TAngle<T>& TAngle<T>::operator += (const T& val) 
  {
    value += val;
    return *this;
  }

  template <typename T>
  TAngle<T> TAngle<T>::operator + (const TAngle& angle)
  {
    return TAngle(value + angle.value);
  }

  template <typename T>
  TAngle<T>& TAngle<T>::operator -= (const TAngle& angle)
  {
    value -= angle.value;
    return *this;
  }

  template <typename T>
  TAngle<T>& TAngle<T>::operator -= (const T& val)
  {
    value -= val;
    return *this;
  }

  template <typename T>
  TAngle<T> TAngle<T>::operator - (const TAngle& angle) 
  {
    return TAngle(value - angle.value);
  }

  template <typename T>
  TAngle<T>& TAngle<T>::operator *= (const TAngle& angle)
  {
    value *= angle.value;
    return *this;
  }

  template <typename T>
  TAngle<T>& TAngle<T>::operator *= (const T& val)
  {
    value *= val;
    return *this;
  }

  template <typename T>
  TAngle<T>& TAngle<T>::operator /= (const TAngle& angle)
  {
    if (angle.value == 0)
    {
      throw Exception::DivisionByZero(__FILE__, __LINE__);
    }
    value /= angle.value;
    return *this;
  }


  template <typename T>
  TAngle<T>& TAngle<T>::operator /= (const T& val) 
  {
    if (val == 0)
    {
      throw Exception::DivisionByZero(__FILE__, __LINE__);
    }

    value /= val;
    return *this;
  }


  template <typename T>
  TAngle<T> TAngle<T>::operator / (const TAngle<T>& val) 
  {
    if (val.value == 0)
    {
      throw Exception::DivisionByZero(__FILE__, __LINE__);
    }

    return TAngle(value / val.value);
  }

  template <typename T>
  bool TAngle<T>::operator == (const TAngle& angle) const
  {
    return Maths::isEqual(value, angle.value);
  }

  template <typename T>
  bool TAngle<T>::operator != (const TAngle& angle) const 
  {
    return Maths::isNotEqual(value, angle.value);
  }

  template <typename T>
  bool TAngle<T>::operator < (const TAngle& angle) const
  {
    return Maths::isLess(value, angle.value);
  }

  template <typename T>
  bool TAngle<T>::operator < (const T& val) const
  {
    return Maths::isLess(value, val);
  }

  template <typename T>
  bool TAngle<T>::operator <= (const TAngle& angle) const
  {
    return Maths::isLessOrEqual(value, angle.value);
  }

  template <typename T>
  bool TAngle<T>::operator >= (const TAngle& angle) const 
  {
    return Maths::isGreaterOrEqual(value, angle.value);
  }

  template <typename T>
  bool TAngle<T>::operator > (const TAngle& angle) const 
    
  {
    return Maths::isGreater(value, angle.value);
  }

  template <typename T>
  bool TAngle<T>::isEquivalent(TAngle angle) const
  {
    TAngle this_angle(*this);

    this_angle.normalize(RANGE__UNSIGNED);
    angle.normalize(RANGE__UNSIGNED);

    return (this_angle == angle);
  }

  template <typename T>
  bool TAngle<T>::isValid() const 
  {
    return true;
  }

  template <typename T>
  void TAngle<T>::dump(std::ostream& s, Size depth) const
  {
    BALL_DUMP_STREAM_PREFIX(s);

    BALL_DUMP_HEADER(s, this, this);

    BALL_DUMP_DEPTH(s, depth);
    s << "  value: " << value << std::endl;

    BALL_DUMP_STREAM_SUFFIX(s);
  }

  typedef TAngle<float> Angle;

  template <typename T>
  BALL_INLINE
  TAngle<T> operator * (const T& val, const TAngle<T>& angle)
  {
    return TAngle<T>(val * angle.value);
  }

  template <typename T>
  BALL_INLINE
  TAngle<T> operator + (const T& val, const TAngle<T>& angle) 
  {
    return TAngle<T>(val + angle.value);
  }

  template <typename T>
  BALL_INLINE
  TAngle<T> operator - (const T& val, const TAngle<T>& angle) 
  {
    return TAngle<T>(val - angle.value);
  }

  template <typename T>
  std::istream& operator >> (std::istream& s, TAngle<T>& angle)
  {
    char c;
    s >> c >> angle.value >> c;
    return s;
  }

  template <typename T>
  std::ostream& operator << (std::ostream& s, const TAngle<T>& angle)
  {
    s << '(' << angle.value << ')';

    return s;
  }

} // namespace BALL

#endif // BALL_MATHS_ANGLE_H