Angle.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2012 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
#ifndef GAZEBO_MATH_ANGLE_HH_
#define GAZEBO_MATH_ANGLE_HH_

#include <math.h>
#include <ignition/math/Angle.hh>
#include <iostream>
#include "gazebo/util/system.hh"

#define GZ_RTOD(r) gazebo::math::Angle::RadiansToDegrees(r)

#define GZ_DTOR(d) gazebo::math::Angle::DegreesToRadians(d)

#define GZ_NORMALIZE(a) gazebo::math::Angle::Normalize(a)

namespace gazebo
{

  namespace math
  {

  // cppcheck-suppress noConstructor
  class GZ_MATH_VISIBLE Angle
  {
    public: static const Angle Zero;

    public: static const Angle Pi;

    public: static const Angle HalfPi;

    public: static const Angle TwoPi;

    public: Angle() GAZEBO_DEPRECATED(8.0);

    public: Angle(double _radian) GAZEBO_DEPRECATED(8.0);

    public: Angle(const Angle &_angle) GAZEBO_DEPRECATED(8.0);

    public: Angle(const ignition::math::Angle &_angle) GAZEBO_DEPRECATED(8.0);

    public: virtual ~Angle();

    public: void SetFromRadian(double _radian);

    public: void SetFromDegree(double _degree);

    public: double Radian() const;

    public: double Degree() const;

    public: void Normalize();

    public: inline double operator*() const { return value; }
    public: Angle operator-(const Angle &_angle) const;

    public: Angle operator+(const Angle &_angle) const;

    public: Angle operator*(const Angle &_angle) const;

    public: Angle operator/(const Angle &_angle) const;

    public: Angle operator-=(const Angle &_angle);

    public: Angle operator+=(const Angle &_angle);

    public: Angle operator*=(const Angle &_angle);

    public: Angle operator/=(const Angle &_angle);

    public: ignition::math::Angle Ign() const;

    public: Angle &operator=(const double &_angle);

    public: Angle &operator=(const ignition::math::Angle &_angle);

    public: bool operator ==(const Angle &_angle) const;

    public: bool operator!=(const Angle &_angle) const;

    public: bool operator<(const Angle &_angle) const;

    public: bool operator<=(const Angle &_angle) const;

    public: bool operator>(const Angle &_angle) const;

    public: bool operator>=(const Angle &_angle) const;

    public: friend std::ostream &operator<<(std::ostream &_out,
                                            const gazebo::math::Angle &_a)
    {
      _out << _a.Radian();
      return _out;
    }

    public: static double DegreesToRadians(const double _d)
        GAZEBO_DEPRECATED(8.0)
    {
      return _d * M_PI / 180;
    }

    public: static double RadiansToDegrees(const double _r)
        GAZEBO_DEPRECATED(8.0)
    {
      return _r * 180 / M_PI;
    }

    public: static double Normalize(const double _a)
        GAZEBO_DEPRECATED(8.0)
    {
      return atan2(sin(_a), cos(_a));
    }

    public: friend std::istream &operator>>(std::istream &_in,
                                            gazebo::math::Angle &_a)
    {
      // Skip white spaces
      _in.setf(std::ios_base::skipws);
      _in >> _a.value;
      return _in;
    }

    private: double value;
  };

  }
}

#endif