Angle.cpp

Go to the documentation of this file.

#include "Angle.h"

#include <cmath>

#include <QDebug>

#include "Constants.h"
#include "IString.h"
#include "IException.h"
#include "SpecialPixel.h"

namespace Isis {
  Angle::Angle() {
    m_radians = Null;
  }

  Angle::Angle(double angle, Units unit) {
    setAngle(angle, unit);
  }


  Angle::Angle(const Angle& fromAngle) {
    m_radians = fromAngle.m_radians;
  }


  Angle::Angle(QString angle) {
    QString::SectionFlag flag = QString::SectionSkipEmpty;
    bool degreesSucceeded, minutesSucceeded, secondsSucceeded; 

    double degrees = angle.section(' ', 0, 0, flag).toDouble(&degreesSucceeded);
    double minutes = angle.section(' ', 1, 1, flag).toDouble(&minutesSucceeded);
    double seconds = angle.section(' ', 2, 2, flag).toDouble(&secondsSucceeded);

    if (!(degreesSucceeded && minutesSucceeded && secondsSucceeded) ) {
      QString msg = QObject::tr("[%1] is not a vaid input to Angle. It needs to be of the form: "
                    "\"dd mm ss.ss\"").arg(angle);
      throw IException(IException::Programmer, msg, _FILEINFO_); 
    }

    //if the first digit is '-', everything should be negative
    if (degrees < 0) { 
      minutes = -minutes;
      seconds = -seconds; 
    }

    double decimalDegrees = degrees + minutes/60.0 + seconds/3600.0;
    setAngle(decimalDegrees, Angle::Degrees);
  }


  Angle::~Angle() {
    // Help prevent any accidental reuse of an Angle object
    m_radians = Null;
  }


  bool Angle::isValid() const {
    return m_radians != Isis::Null; // returns false if the value is Null or any other special value
//    return IsValidPixel(m_radians); // returns false if the value is Null or any other special value
  }


  Angle Angle::fullRotation() {
    return Angle(360, Degrees);
  }


  Angle Angle::operator+(const Angle& angle2) const {
    if(!isValid() || !angle2.isValid()) return Angle();

    double ourAngle   = radians();
    double otherAngle = angle2.radians();

    return Angle(ourAngle + otherAngle, Radians);
  }


  Angle Angle::operator-(const Angle& angle2) const {
    if(!isValid() || !angle2.isValid()) return Angle();

    double ourAngle   = radians();
    double otherAngle = angle2.radians();

    return Angle(ourAngle - otherAngle, Radians);
  }


  Angle Angle::operator*(double value) const {
    if(!isValid()) return Angle();

    return Angle(radians() * value, Radians);
  }


  Angle operator *(double mult, Angle angle) {
    return angle * mult;
  }


  Angle Angle::operator/(double value) const {
    if(!isValid()) return Angle();

    return Angle(radians() / value, Radians);
  }


  double Angle::operator/(Angle value) const {
    if(!isValid() || !value.isValid()) return Null;

    return radians() / value.radians();
  }


  bool Angle::operator<(const Angle& angle2) const {
    if(!isValid() || !angle2.isValid()) {
      IString msg = "Cannot compare a invalid angles with the < operator";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    // != comparison allows for angles that are considered equal to be treated
    // as being equal. == operator override uses qFuzzyCompare().
    return (angle(Radians) < angle2.angle(Radians)) && *this != angle2;
  }


  bool Angle::operator>(const Angle& angle2) const {
    if(!isValid() || !angle2.isValid()) {
      IString msg = "Cannot compare a invalid angles with the > operator";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    // != comparison allows for angles that are considered equal to be treated
    // as being equal. == operator override uses qFuzzyCompare().
    return (angle(Radians) > angle2.angle(Radians)) && *this != angle2;
  }


  QString Angle::toString(bool includeUnits) const {
    QString textResult = "";

    if (isValid()) {
      textResult = Isis::toString(degrees());

      if (includeUnits)
        textResult += " degrees";
    }

    return textResult;
  }


  double Angle::unitWrapValue(const Units& unit) const {
    switch (unit) {
      case Radians:
        return PI * 2.;
        break;

      case Degrees:
        return 360.;
        break;
    }

    IString msg = "Angle can not interpret the enumerated value ["  +
      IString(unit) + "] as a unit";
    throw IException(IException::Programmer, msg, _FILEINFO_);
  }


  double Angle::angle(const Units& unit) const {
    // Don't do math on special pixels
    if(m_radians == Null) {
      return Null;
    }

    double angleValue = Null;

    switch (unit) {
      case Radians:
        angleValue = m_radians;
        break;

      case Degrees:
        angleValue = m_radians * RAD2DEG;
        break;
    }

    if(angleValue == Null) {
      IString msg = "Angle can not interpret the enumerated value ["  +
        IString(unit) + "] as a unit";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    return angleValue;
  }


  void Angle::setAngle(const double &angle,const Units& unit) {
    // Don't allow non-Null special pixels, Null means no value
    if (IsSpecial(angle) && angle != Null) {
      IString msg = "Angle cannot be a non-Null special pixel";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    // Don't do math on special pixels
    if(angle == Null) {
      m_radians = Null;
      return;
    }

    switch (unit) {
      case Radians:
        m_radians = angle;
        break;

      case Degrees:
        m_radians = angle * DEG2RAD;
        break;

      default:
        IString msg = "Angle can not interpret the enumerated value ["  +
          IString(unit) + "] as a unit";
        throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }

}


QDebug operator<<(QDebug dbg, const Isis::Angle &angleToPrint) {
  dbg.nospace() << angleToPrint.radians() << " <radians> ("
                << angleToPrint.degrees() << " <degrees>)";

  return dbg.space();
}