Distance.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "Distance.h"
 
#include "Displacement.h"
#include "IException.h"
#include "IString.h"
#include "SpecialPixel.h"
 
namespace Isis {
 
  Distance::Distance() {
    setDistance(Null, Meters);
  }
 
 
  Distance::Distance(double distance, Units distanceUnit) {
    if(distanceUnit == Pixels)
      distanceUnit = Meters;
 
    setDistance(distance, distanceUnit);
  }
 
 
  Distance::Distance(double distanceInPixels, double pixelsPerMeter) {
    setDistance(distanceInPixels / pixelsPerMeter, Meters);
  }
 
 
  Distance::Distance(const Distance &distanceToCopy) {
    // Use meters because it is the stored format, no precision loss
    setDistance(distanceToCopy.meters(), Meters);
  }
 
 
  Distance::~Distance() {
    // This will help debug memory problems, better to reset to obviously bad
    //   values in case we're used after we're deleted.
    m_distanceInMeters = Null;
  }
 
 
  double Distance::meters() const {
    return distance(Meters);
  }
 
 
  void Distance::setMeters(double distanceInMeters) {
    setDistance(distanceInMeters, Meters);
  }
 
 
  double Distance::kilometers() const {
    return distance(Kilometers);
  }
 
 
  void Distance::setKilometers(double distanceInKilometers) {
    setDistance(distanceInKilometers, Kilometers);
  }
 
 
  double Distance::pixels(double pixelsPerMeter) const {
    return distance(Meters) * pixelsPerMeter;
  }
 
 
  void Distance::setPixels(double distanceInPixels, double pixelsPerMeter) {
    setDistance(distanceInPixels / pixelsPerMeter, Meters);
  }
 
 
  double Distance::solarRadii() const {
    return distance(SolarRadii);
  }
 
 
  void Distance::setSolarRadii(double distanceInSolarRadii) {
    setDistance(distanceInSolarRadii, SolarRadii);
  }
 
 
  QString Distance::toString() const {
    QString string;
 
    if (isValid())
      string = Isis::toString(meters()) + " meters";
 
    return string;
  }
 
 
  bool Distance::isValid() const {
    return distance(Meters) != Null;
  }
 
 
  bool Distance::operator >(const Distance &otherDistance) const {
    if(!isValid() || !otherDistance.isValid()) {
      IString msg = "Distance has not been initialized, you must initialize "
          "it first before comparing with another distance using [>]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    return meters() > otherDistance.meters();
  }
 
 
  bool Distance::operator <(const Distance &otherDistance) const {
    if(!isValid() || !otherDistance.isValid()) {
      IString msg = "Distance has not been initialized, you must initialize "
          "it first before comparing with another distance using [<]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    return meters() < otherDistance.meters();
  }
 
 
  Distance &Distance::operator =(const Distance &distanceToCopy) {
    if(this == &distanceToCopy) return *this;
 
    setDistance(distanceToCopy.meters(), Meters);
 
    return *this;
  }
 
 
  Distance Distance::operator +(const Distance &distanceToAdd) const {
    if(!isValid() || !distanceToAdd.isValid()) return Distance();
 
    return Distance(meters() + distanceToAdd.meters(), Meters);
  }
 
 
  Displacement Distance::operator -(const Distance &distanceToSub) const {
    if(!isValid() || !distanceToSub.isValid()) return Displacement();
 
    Displacement result(meters() - distanceToSub.meters(),
        Displacement::Meters);
 
    return result;
  }
 
 
  double Distance::operator /(const Distance &distanceToDiv) const {
    if(!isValid() || !distanceToDiv.isValid()) return Null;
 
    double result = meters() / distanceToDiv.meters();
    return result;
  }
 
 
  Distance Distance::operator /(const double &valueToDiv) const {
    if(!isValid() || IsSpecial(valueToDiv)) return Distance();
 
    Distance result = Distance(meters() / valueToDiv, Meters);
 
    return result;
  }
 
 
  Distance Distance::operator *(const double &valueToMult) const {
    if(!isValid() || IsSpecial(valueToMult)) return Distance();
 
    Distance result = Distance(meters() * valueToMult, Meters);
 
    return result;
  }
 
 
  Distance operator *(double mult, Distance dist) {
    Distance result = dist * mult;
    return result;
  }
 
 
  void Distance::operator +=(const Distance &distanceToAdd) {
    if(!isValid() || !distanceToAdd.isValid()) {
      setDistance(Null, Meters);
    }
    else {
      setDistance(meters() + distanceToAdd.meters(), Meters);
    }
  }
 
 
  void Distance::operator -=(const Distance &distanceToSub) {
    if(!isValid() || !distanceToSub.isValid()) {
      setDistance(Null, Meters);
    }
    else {
      setDistance(meters() - distanceToSub.meters(), Meters);
    }
  }
 
 
  void Distance::operator /=(const double &valueToDiv) {
    if(!isValid() || IsSpecial(valueToDiv)) {
      setDistance(Null, Meters);
    }
    else {
      setDistance(meters() / valueToDiv, Meters);
    }
  }
 
 
  void Distance::operator *=(const double &valueToMult) {
    if(!isValid() || IsSpecial(valueToMult)) {
      setDistance(Null, Meters);
    }
    else {
      setDistance(meters() * valueToMult, Meters);
    }
  }
 
 
  double Distance::distance(Units distanceUnit) const {
    double distanceInMeters = m_distanceInMeters;
    double resultingDistance = Null;
 
    if(m_distanceInMeters == Null) return Null;
 
    switch(distanceUnit) {
      case Meters:
        resultingDistance = distanceInMeters;
        break;
 
      case Kilometers:
        resultingDistance = distanceInMeters / 1000.0;
        break;
 
      case Pixels: {
        IString msg = "Cannot call distance() with pixels, ask for another "
                      "unit";
        throw IException(IException::Programmer, msg, _FILEINFO_);
        break;
      }
 
      case SolarRadii:
        resultingDistance = distanceInMeters / 6.9599e8;
        break;
    }
 
    if(resultingDistance == Null) {
      IString msg = "Distance does not understand the enumerated value [" +
          IString(distanceUnit) + "] as a unit";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    return resultingDistance;
  }
 
 
  void Distance::setDistance(const double &distance, Units distanceUnit) {
    double distanceInMeters = Null;
 
    if(IsSpecial(distance)) {
      m_distanceInMeters = Null;
      return;
    }
 
    switch(distanceUnit) {
      case Meters:
        distanceInMeters = distance;
        break;
 
      case Kilometers:
        distanceInMeters = distance * 1000.0;
        break;
 
      case Pixels: {
        IString msg = "Cannot setDistance with pixels, must convert to another "
            "unit first";
        throw IException(IException::Programmer, msg, _FILEINFO_);
        break;
      }
 
      case SolarRadii:
        distanceInMeters = distance * 6.9599e8;
        break;
    }
 
    if(distanceInMeters == Null) {
      IString msg = "Distance does not understand the enumerated value [" +
        IString(distanceUnit) + "] as a unit";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    if (distanceInMeters < 0.0) {
      IString msg = "Negative distances are not supported, the value [" +
        IString(distanceInMeters) + " meters] cannot be stored in the Distance "
        "class";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    m_distanceInMeters = distanceInMeters;
  }
}