Longitude.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "Longitude.h"
 
#include <cmath>
 
#include <QtCore>
#include <QDebug>
 
#include "Constants.h"
#include "IException.h"
#include "IString.h"
#include "PvlGroup.h"
#include "SpecialPixel.h"
 
namespace Isis {
  Longitude::Longitude() : Angle() {
    m_currentDomain = Domain360;
  }
 
 
  Longitude::Longitude(double longitude, PvlGroup mapping,
                       Angle::Units longitudeUnits) :
      Angle(longitude, longitudeUnits) {
    if(mapping["LongitudeDomain"][0] == "360") {
      m_currentDomain = Domain360;
    }
    else if(mapping["LongitudeDomain"][0] == "180") {
      m_currentDomain = Domain180;
    }
    else {
      IString msg = "Longitude domain [" +
          IString(mapping["LongitudeDomain"][0]) + "] not recognized";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    if(mapping["LongitudeDirection"][0] == "PositiveEast") {
      setPositiveEast(longitude, longitudeUnits);
    }
    else if(mapping["LongitudeDirection"][0] == "PositiveWest") {
      setPositiveWest(longitude, longitudeUnits);
    }
    else {
      IString msg = "Longitude direction [" +
          IString(mapping["LongitudeDirection"][0]) + "] not recognized";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }
 
 
  Longitude::Longitude(Angle longitude,
                       Direction lonDir, Domain lonDomain) :
      Angle(longitude) {
    m_currentDomain = lonDomain;
 
    if(lonDir == PositiveEast) {
      setPositiveEast(longitude.radians(), Radians);
    }
    else if(lonDir == PositiveWest) {
      setPositiveWest(longitude.radians(), Radians);
    }
    else {
      IString msg = "Longitude direction [" + IString(lonDir) + "] not valid";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }
 
 
  Longitude::Longitude(double longitude, Angle::Units longitudeUnits,
                       Direction lonDir, Domain lonDomain) :
      Angle(longitude, longitudeUnits) {
    m_currentDomain = lonDomain;
 
    if(lonDir == PositiveEast) {
      setPositiveEast(longitude, longitudeUnits);
    }
    else if(lonDir == PositiveWest) {
      setPositiveWest(longitude, longitudeUnits);
    }
    else {
      IString msg = "Longitude direction [" + IString(lonDir) + "] not valid";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }
 
 
  Longitude::Longitude(const Longitude &longitudeToCopy)
      : Angle(longitudeToCopy) {
    m_currentDomain = longitudeToCopy.m_currentDomain;
  }
 
 
  Longitude::~Longitude() {
  }
 
 
  double Longitude::positiveEast(Angle::Units units) const {
    return angle(units);
  }
 
 
  double Longitude::positiveWest(Angle::Units units) const {
    double longitude = angle(units);
 
    if (!IsSpecial(longitude)) {
      if(m_currentDomain == Domain360) {
        double wrapPoint = unitWrapValue(units);
        double halfWrap = wrapPoint / 2.0;
 
        int numPlanetWraps = qFloor(longitude / wrapPoint);
 
        // If the input is 360, then we want numPlanetWraps == 0. Compare the input to the border
        //   case (wraps * wrapPoint == longitude) and bring the number of wraps down if it's true.
        //   If it's false, then the rounding already took care of this border case.
        if (numPlanetWraps != 0 && qFuzzyCompare(numPlanetWraps * wrapPoint, longitude)) {
          if (numPlanetWraps > 0)
            numPlanetWraps--;
          else
            numPlanetWraps++;
        }
 
        longitude -= numPlanetWraps * wrapPoint;
        longitude = -(longitude - halfWrap) + halfWrap;
        longitude -= numPlanetWraps * wrapPoint;
      }
      else {
        // 180 domain is just a negation in this conversion,
        //   no more work needs done
        longitude = -1 * longitude;
      }
    }
 
    return longitude;
  }
 
 
  void Longitude::setPositiveEast(double longitude, Angle::Units units) {
    setAngle(longitude, units);
  }
 
 
  void Longitude::setPositiveWest(double longitude, Angle::Units units) {
    if(!IsSpecial(longitude)) {
      if(m_currentDomain == Domain360) {
        // Same as positiveWest
        double wrapPoint = unitWrapValue(units);
        double halfWrap = wrapPoint / 2.0;
 
        int numPlanetWraps = qFloor(longitude / wrapPoint);
 
        // If the input is 360, then we want numPlanetWraps == 0. Compare the input to the border
        //   case (wraps * wrapPoint == longitude) and bring the number of wraps down if it's true.
        //   If it's false, then the rounding already took care of this border case.
        if (numPlanetWraps != 0 && qFuzzyCompare(numPlanetWraps * wrapPoint, longitude)) {
          if (numPlanetWraps > 0)
            numPlanetWraps--;
          else
            numPlanetWraps++;
        }
 
 
        longitude -= numPlanetWraps * wrapPoint;
        longitude = -(longitude - halfWrap) + halfWrap;
        longitude -= numPlanetWraps * wrapPoint;
      }
      else {
        // 180 domain is just a negation in this conversion,
        //   no more work needs done
        longitude = -1 * longitude;
      }
    }
 
    setAngle(longitude, units);
  }
 
 
  Longitude& Longitude::operator=(const Longitude & longitudeToCopy) {
    if(this == &longitudeToCopy) return *this;
 
    m_currentDomain = longitudeToCopy.m_currentDomain;
    setPositiveEast(longitudeToCopy.positiveEast());
 
    return *this;
  }
 
 
  Longitude Longitude::force360Domain() const {
    if(!isValid()) return Longitude();
 
    double resultantLongitude = angle(Angle::Degrees);
 
    // Bring the number in the 0 to 360 range
    if (qFuzzyCompare(degrees(), 360.0)) {
      resultantLongitude = 360.0;
    }
    else {
      resultantLongitude -= 360 * qFloor(resultantLongitude / 360);
    }
 
    return Longitude(resultantLongitude, Angle::Degrees);
  }
 
 
  Longitude Longitude::force180Domain() const {
    if(!isValid()) return Longitude();
 
    Longitude forced = force360Domain();
 
    if(forced.degrees() > 180.0)
      forced -= Angle(360.0, Angle::Degrees);
 
    return forced;
  }
 
 
  bool Longitude::inRange(Longitude min, Longitude max) const {
    bool result = false;
    
    QList< QPair<Longitude, Longitude> > ranges = to360Range(min, max);
 
    Longitude thisLon = force360Domain();
    
    QPair<Longitude, Longitude> range;
    foreach (range, ranges) {
      if (thisLon >= range.first && thisLon <= range.second) {
        result = true;
      }
 
      double thisLonRadians = thisLon.radians();
      double rangeStartRadians = range.first.radians();
      double rangeEndRadians = range.second.radians();
      // Check equality on edges of range
      if (qFuzzyCompare(thisLonRadians, rangeStartRadians) ||
          qFuzzyCompare(thisLonRadians, rangeEndRadians)) {
        result = true;
      }
 
      // Be very careful at the 0-360 boundary
      if ((qFuzzyCompare(thisLonRadians, 0.0) || qFuzzyCompare(thisLonRadians, 2.0 * PI)) &&
          (qFuzzyCompare(rangeStartRadians, 0.0) ||
           qFuzzyCompare(rangeEndRadians, 2.0 * PI))) {
        result = true;
      }
    }
 
    return result;
  }
 
  QList< QPair<Longitude, Longitude> > Longitude::to360Range(Longitude startLon, Longitude endLon) {
 
    QList< QPair<Longitude, Longitude> > range;
    
    if (startLon.isValid() && endLon.isValid() && startLon < endLon) {
        
      int multiplier = floor(startLon / fullRotation());
 
      startLon -= multiplier * fullRotation();
      endLon -= multiplier * fullRotation();
 
      if (endLon > fullRotation()) {
 
        Longitude startLon2(0, Angle::Degrees);
        Longitude endLon2(endLon - fullRotation());
 
        if (endLon2 < startLon) {
          range.append(qMakePair(startLon2, endLon2));
        }
        else {
          startLon = Longitude(0, Angle::Degrees);
        }
        endLon = Longitude(360, Angle::Degrees);
      }
      startLon = Longitude((Angle)startLon);
      endLon = Longitude((Angle)endLon);
      
      range.append(qMakePair(startLon, endLon));
    }
    return range;
  }
}