angle.h

Go to the documentation of this file.

/*
 * LibrePCB - Professional EDA for everyone!
 * Copyright (C) 2013 LibrePCB Developers, see AUTHORS.md for contributors.
 * https://librepcb.org/
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef LIBREPCB_CORE_ANGLE_H
#define LIBREPCB_CORE_ANGLE_H
 
/*******************************************************************************
 *  Includes
 ******************************************************************************/
#include "../qtcompat.h"
 
#include <QtCore>
 
/*******************************************************************************
 *  Namespace / Forward Declarations
 ******************************************************************************/
namespace librepcb {
 
/*******************************************************************************
 *  Class Angle
 ******************************************************************************/
 
class Angle {
  Q_DECLARE_TR_FUNCTIONS(Angle)
 
public:
  // Constructors / Destructor
 
  Angle() noexcept : Angle(0) {}
 
  Angle(const Angle& angle) noexcept : mMicrodegrees(angle.mMicrodegrees) {}
 
  explicit Angle(qint32 microdegrees) noexcept
    : mMicrodegrees(microdegrees % 360000000) {}
 
  ~Angle() noexcept {}
 
  // Setters
 
  void setAngleMicroDeg(qint32 microdegrees) noexcept {
    mMicrodegrees = microdegrees % 360000000;
  }
 
  void setAngleDeg(qreal degrees) noexcept {
    const qreal value = std::fmod(degrees * 1e6, 360e6);
    // Note: Don't use qRound() because in Qt5 it is implemented strange.
    setAngleMicroDeg((value >= 0.0) ? qint64(value + qreal(0.5))
                                    : qint64(value - qreal(0.5)));
  }
 
  void setAngleDeg(const QString& degrees) {
    mMicrodegrees = degStringToMicrodeg(degrees) % 360000000;
  }
 
  void setAngleRad(qreal radians) noexcept {
    setAngleDeg(radians * (180.0 / M_PI));
  }
 
  // Conversions
 
  qint32 toMicroDeg() const noexcept { return mMicrodegrees; }
 
  qreal toDeg() const noexcept {
    return static_cast<qreal>(mMicrodegrees) / 1e6;
  }
 
  QString toDegString() const noexcept;
 
  qreal toRad() const noexcept { return toDeg() / (180.0 / M_PI); }
 
  // General Methods
 
  Angle abs() const noexcept;
 
  Angle& makeAbs() noexcept;
 
  Angle inverted() const noexcept;
 
  Angle& invert() noexcept;
 
  Angle rounded(const Angle& interval) const noexcept;
 
  Angle& round(const Angle& interval) noexcept;
 
  Angle mappedTo0_360deg() const noexcept;
 
  Angle& mapTo0_360deg() noexcept;
 
  Angle mappedTo180deg() const noexcept;
 
  Angle& mapTo180deg() noexcept;
 
  // Static Methods
 
  static Angle fromDeg(qreal degrees) noexcept;
 
  static Angle fromDeg(const QString& degrees);
 
  static Angle fromRad(qreal radians) noexcept;
 
  // Static Methods to create often used angles
  static Angle deg0() noexcept { return Angle(0); }  
  static Angle deg45() noexcept { return Angle(45000000); }  
  static Angle deg90() noexcept { return Angle(90000000); }  
  static Angle deg135() noexcept { return Angle(135000000); }  
  static Angle deg180() noexcept { return Angle(180000000); }  
  static Angle deg225() noexcept { return Angle(225000000); }  
  static Angle deg270() noexcept { return Angle(270000000); }  
  static Angle deg315() noexcept { return Angle(315000000); }  
 
  // Operators
  Angle& operator=(const Angle& rhs) {
    mMicrodegrees = rhs.mMicrodegrees;
    return *this;
  }
  Angle& operator+=(const Angle& rhs) {
    mMicrodegrees = (mMicrodegrees + rhs.mMicrodegrees) % 360000000;
    return *this;
  }
  Angle& operator-=(const Angle& rhs) {
    mMicrodegrees = (mMicrodegrees - rhs.mMicrodegrees) % 360000000;
    return *this;
  }
  Angle operator+(const Angle& rhs) const {
    return Angle(mMicrodegrees + rhs.mMicrodegrees);
  }
  Angle operator-() const { return Angle(-mMicrodegrees); }
  Angle operator-(const Angle& rhs) const {
    return Angle(mMicrodegrees - rhs.mMicrodegrees);
  }
  Angle operator*(const Angle& rhs) const {
    return Angle(mMicrodegrees * rhs.mMicrodegrees);
  }
  Angle operator*(qint32 rhs) const { return Angle(mMicrodegrees * rhs); }
  Angle operator/(const Angle& rhs) const {
    return Angle(mMicrodegrees / rhs.mMicrodegrees);
  }
  Angle operator/(qint32 rhs) const { return Angle(mMicrodegrees / rhs); }
  Angle operator%(const Angle& rhs) const {
    return Angle(mMicrodegrees % rhs.mMicrodegrees);
  }
  bool operator>(const Angle& rhs) const {
    return mMicrodegrees > rhs.mMicrodegrees;
  }
  bool operator>(qint32 rhs) const { return mMicrodegrees > rhs; }
  bool operator<(const Angle& rhs) const {
    return mMicrodegrees < rhs.mMicrodegrees;
  }
  bool operator<(qint32 rhs) const { return mMicrodegrees < rhs; }
  bool operator>=(const Angle& rhs) const {
    return mMicrodegrees >= rhs.mMicrodegrees;
  }
  bool operator>=(qint32 rhs) const { return mMicrodegrees >= rhs; }
  bool operator<=(const Angle& rhs) const {
    return mMicrodegrees <= rhs.mMicrodegrees;
  }
  bool operator<=(qint32 rhs) const { return mMicrodegrees <= rhs; }
  bool operator==(const Angle& rhs) const {
    return mMicrodegrees == rhs.mMicrodegrees;
  }
  bool operator==(qint32 rhs) const { return mMicrodegrees == rhs; }
  bool operator!=(const Angle& rhs) const {
    return mMicrodegrees != rhs.mMicrodegrees;
  }
  bool operator!=(qint32 rhs) const { return mMicrodegrees != rhs; }
  explicit operator bool() const { return mMicrodegrees != 0; }
 
private:
  // Private Static Functions
 
  static qint32 degStringToMicrodeg(const QString& degrees);
 
  // Private Member Variables
  qint32 mMicrodegrees;  
};
 
/*******************************************************************************
 *  Non-Member Functions
 ******************************************************************************/
 
inline QDataStream& operator<<(QDataStream& stream, const Angle& angle) {
  stream << angle.toDeg();
  return stream;
}
 
inline QDebug operator<<(QDebug stream, const Angle& angle) {
  stream << QString("Angle(%1°)").arg(angle.toDeg());
  return stream;
}
 
inline QtCompat::Hash qHash(const Angle& key,
                            QtCompat::Hash seed = 0) noexcept {
  return ::qHash(key.toMicroDeg(), seed);
}
 
/*******************************************************************************
 *  Class Angle3D
 ******************************************************************************/
 
using Angle3D = std::tuple<Angle, Angle, Angle>;
 
QDebug operator<<(QDebug stream, const Angle3D& obj);
 
/*******************************************************************************
 *  End of File
 ******************************************************************************/
 
}  // namespace librepcb
 
Q_DECLARE_METATYPE(librepcb::Angle)
 
#endif