Angle.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch)
 *****************************************************************************
 * Project    : Zeus Math Library
 * Module     : Angle
 * Package    : Zeus.ZeusMath.System
 * Author     : Martin Abbuehl
 * Date       : 27.12.2011
 * System     : Zeus-Framework
 *****************************************************************************
 * Licence:                                                                  *
 *   This library 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.1 of the License, or (at your option) any later version.              *
 *                                                                           *
 *   This library 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 library; if not, write to the Free Software     *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA    *
 *****************************************************************************/

/*****************************************************************************
 * Changes:
 *  27.12.2011 bha: created zeus 2.0
 *****************************************************************************/

#ifndef AngleH
#define AngleH

#include <math.h>
#include <zeusmath/System/Interfaces/IAngle.hpp>
#include <zeusmath/System/Constants.h>
#include <zeusbase/System/Float.h>


BEGIN_NAMESPACE_Zeus


/******************************************************************************/
/******************************************************************************/
zeusmath_class TAngle : public IAngle
{
  public:
    inline TAngle() { setRadians(0); }

    TAngle(const Float& fAngle, ESystem eSystem);

    inline TAngle(const TAngle& rAngle) { *this = rAngle; }

    inline TAngle(const IAngle& rAngle) { *this = rAngle; }

    virtual inline ~TAngle() { }

    // Methods of IAngle.
    virtual inline Float MQUALIFIER getRadians() const { return m_fRadians; }
    virtual inline Float MQUALIFIER getDegrees() const { return radiansToDegrees(getRadians()); }

    virtual inline void MQUALIFIER setRadians(const Float& fAngle) { m_fRadians = fAngle; }
    virtual inline void MQUALIFIER setDegrees(const Float& fAngle) { setRadians(degreesToRadians(fAngle)); }

    virtual inline void MQUALIFIER assign(const IAngle& rAngle) { *this = rAngle; }

    virtual bool MQUALIFIER isEqual(const IAngle& rAngle,
                                    bool bNormalizeToSingleCircle = false) const;

    virtual inline Float MQUALIFIER cos() const { return TFloat(getRadians()).cos(); }
    virtual inline Float MQUALIFIER sin() const { return TFloat(getRadians()).sin(); }
    virtual inline Float MQUALIFIER tan() const { return TFloat(getRadians()).tan(); }

    virtual void MQUALIFIER normalizeToInterval(const IAngle& rAngleMin,
                                                const IAngle& rAngleMax,
                                                bool bIncludeMin, bool bIncludeMax);

    virtual void MQUALIFIER normalizeToSingleCircle();

    inline const TAngle& operator=(const IAngle& rAngle) { setRadians(rAngle.getRadians()); return *this; }

    inline const TAngle& operator=(const TAngle& rAngle) { setRadians(rAngle.getRadians()); return *this; }

    //Mathematical operators
    inline       TAngle  operator+ (const IAngle& rAngle) const { return TAngle(getRadians() + rAngle.getRadians(), etRadians); }
    inline       TAngle  operator- (const IAngle& rAngle) const { return TAngle(getRadians() - rAngle.getRadians(), etRadians); }
    inline const TAngle& operator+=(const IAngle& rAngle)       { *this = *this + rAngle; return *this; }
    inline const TAngle& operator-=(const IAngle& rAngle)       { *this = *this - rAngle; return *this; }
    inline       TAngle  operator* (const Float& rFloat) const { return TAngle(getRadians() * rFloat, etRadians); }
    inline       TAngle  operator/ (const Float& rFloat) const { return *this * (Float(1) / rFloat); }

    //Compare operators
    inline bool operator==(const IAngle& rAngle) const         { return TFloat::equalsFloat(getRadians(), rAngle.getRadians()); }
    inline bool operator!=(const IAngle& rAngle) const { return !(*this == rAngle); }

    inline bool operator< (const IAngle& rAngle) const { return (getRadians() <  rAngle.getRadians()); }
    inline bool operator<=(const IAngle& rAngle) const { return (getRadians() <= rAngle.getRadians()); }
    inline bool operator> (const IAngle& rAngle) const { return (getRadians() >  rAngle.getRadians()); }
    inline bool operator>=(const IAngle& rAngle) const { return (getRadians() >= rAngle.getRadians()); }

    /**************************************************************************/
    /**************************************************************************/
    static inline Float radiansToDegrees(const Float& fAngle) { return fAngle * TConstants::RadiansToDegrees; }

    /**************************************************************************/
    /**************************************************************************/
    static inline Float degreesToRadians(const Float& fAngle) { return fAngle * TConstants::DegreesToRadians; }

    Float getValue(ESystem eSystem) const;

  private:
    Float m_fRadians;
};

//Global operators.
/******************************************************************************/
/******************************************************************************/
inline TAngle operator-(const IAngle& rAngle) { return TAngle(-rAngle.getRadians(), IAngle::etRadians); }

/******************************************************************************/
/******************************************************************************/
inline TAngle operator+(const IAngle& rAngle) { return TAngle(rAngle); }


END_NAMESPACE_Zeus

#endif