Displacement.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "Displacement.h"
 
#include "Distance.h"
#include "IException.h"
#include "IString.h"
#include "SpecialPixel.h"
 
namespace Isis {
 
  Displacement::Displacement() {
    setDisplacement(Null, Meters);
  }
 
 
  Displacement::Displacement(const Distance &distanceToCopy) {
    // Use meters because it is the stored format, no precision loss
    setDisplacement(distanceToCopy.meters(), Meters);
  }
 
 
  Displacement::Displacement(double displacement, Units displacementUnit) {
    if(displacementUnit == Pixels)
      displacementUnit = Meters;
 
    setDisplacement(displacement, displacementUnit);
  }
 
 
  Displacement::Displacement(double displacementInPixels,
                             double pixelsPerMeter) {
    setDisplacement(displacementInPixels / pixelsPerMeter, Meters);
  }
 
 
  double Displacement::meters() const {
    return displacement(Meters);
  }
 
 
  void Displacement::setMeters(double displacementInMeters) {
    setDisplacement(displacementInMeters, Meters);
  }
 
 
  double Displacement::kilometers() const {
    return displacement(Kilometers);
  }
 
 
  void Displacement::setKilometers(double displacementInKilometers) {
    setDisplacement(displacementInKilometers, Kilometers);
  }
 
 
  double Displacement::pixels(double pixelsPerMeter) const {
    return displacement(Meters) * pixelsPerMeter;
  }
 
 
  void Displacement::setPixels(double displacementInPixels,
                               double pixelsPerMeter) {
    setDisplacement(displacementInPixels / pixelsPerMeter, Meters);
  }
 
 
  bool Displacement::isValid() const {
    return displacement(Meters) != Null;
  }
 
 
  bool Displacement::operator >(const Displacement &otherDisplacement) const {
    if(!isValid() || !otherDisplacement.isValid()) {
      IString msg = "Displacement has not been initialized, you must initialize "
          "it first before comparing with another displacement using [>]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    return meters() > otherDisplacement.meters();
  }
 
 
  bool Displacement::operator <(const Displacement &otherDisplacement) const {
    if(!isValid() || !otherDisplacement.isValid()) {
      IString msg = "Displacement has not been initialized, you must initialize "
          "it first before comparing with another displacement using [<]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    return meters() < otherDisplacement.meters();
  }
 
 
  Displacement Displacement::operator
                              +(const Displacement &displacementToAdd) const {
    if(!isValid() || !displacementToAdd.isValid()) return Displacement();
 
    return Displacement(meters() + displacementToAdd.meters(), Meters);
  }
 
 
  Displacement Displacement::operator
                               -(const Displacement &displacementToSub) const {
    if(!isValid() || !displacementToSub.isValid()) return Displacement();
 
    Displacement result(meters() - displacementToSub.meters(), Meters);
    return result;
  }
 
 
  Displacement Displacement::operator
                               -(const Distance &distanceToSub) const {
    if(!isValid() || !distanceToSub.isValid()) return Displacement();
 
    Displacement result(meters() - distanceToSub.meters(), Meters);
    return result;
  }
 
 
  double Displacement::operator /(const Displacement &displacementToDiv) const {
    if(!isValid() || !displacementToDiv.isValid()) return Null;
 
    double result = meters() / displacementToDiv.meters();
    return result;
  }
 
 
  Displacement Displacement::operator /(const double &valueToDiv) const {
    if(!isValid() || IsSpecial(valueToDiv)) return Displacement();
 
    Displacement result = Displacement(meters() / valueToDiv, Meters);
    return result;
  }
 
 
  Displacement Displacement::operator *(const double &valueToMult) const {
    if(!isValid() || IsSpecial(valueToMult)) return Displacement();
 
    Displacement result = Displacement(meters() * valueToMult, Meters);
    return result;
  }
 
 
  Displacement operator *(double mult, Displacement displacement) {
    Displacement result = displacement * mult;
    return result;
  }
 
 
  void Displacement::operator +=(const Displacement &displacementToAdd) {
    if(!isValid() || !displacementToAdd.isValid())
      setDisplacement(Null, Meters);
    else
      setDisplacement(meters() + displacementToAdd.meters(), Meters);
  }
 
 
  void Displacement::operator -=(const Displacement &displacementToSub) {
    if(!isValid() || !displacementToSub.isValid())
      setDisplacement(Null, Meters);
    else
      setDisplacement(meters() - displacementToSub.meters(), Meters);
  }
 
 
  void Displacement::operator -=(const Distance &distanceToSub) {
    if(!isValid() || !distanceToSub.isValid())
      setDisplacement(Null, Meters);
    else
      setDisplacement(meters() - distanceToSub.meters(), Meters);
  }
 
 
  void Displacement::operator /=(const double &valueToDiv) {
    if(!isValid() || IsSpecial(valueToDiv))
      setDisplacement(Null, Meters);
    else
      setDisplacement(meters() / valueToDiv, Meters);
  }
 
 
  void Displacement::operator *=(const double &valueToMult) {
    if(!isValid() || IsSpecial(valueToMult))
      setDisplacement(Null, Meters);
    else
      setDisplacement(meters() * valueToMult, Meters);
  }
 
 
  double Displacement::displacement(Units displacementUnit) const {
    double displacementInMeters = m_displacementInMeters;
    double resultingDisplacement = Null;
 
    if(m_displacementInMeters == Null) return Null;
 
    switch(displacementUnit) {
      case Meters:
        resultingDisplacement = displacementInMeters;
        break;
 
      case Kilometers:
        resultingDisplacement = displacementInMeters / 1000.0;
        break;
 
      case Pixels:
        IString msg = "Cannot call displacement with pixels, ask for another "
            "unit";
        throw IException(IException::Programmer, msg, _FILEINFO_);
        break;
    }
 
    if(resultingDisplacement == Null) {
      IString msg = "Displacement does not understand the enumerated value [" +
        IString(displacementUnit) + "] as a unit";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    return resultingDisplacement;
  }
 
 
  void Displacement::setDisplacement(const double &displacement, Units displacementUnit) {
    double displacementInMeters = Null;
 
    if(IsSpecial(displacement)) {
      m_displacementInMeters = Null;
      return;
    }
 
    switch(displacementUnit) {
      case Meters:
        displacementInMeters = displacement;
        break;
 
      case Kilometers:
        displacementInMeters = displacement * 1000.0;
        break;
 
      case Pixels:
        IString msg = "Cannot setDisplacement with pixels, must convert to "
            "another unit first";
        throw IException(IException::Programmer, msg, _FILEINFO_);
        break;
    }
 
    if(displacementInMeters == Null) {
      IString msg = "Displacement does not understand the enumerated value [" +
        IString(displacementUnit) + "] as a unit";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    m_displacementInMeters = displacementInMeters;
  }
}