RingCylindrical.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "RingCylindrical.h"
 
#include <cmath>
#include <cfloat>
 
#include "Constants.h"
#include "IException.h"
#include "Pvl.h"
#include "PvlGroup.h"
#include "PvlKeyword.h"
#include "RingPlaneProjection.h"
#include "SpecialPixel.h"
 
using namespace std;
namespace Isis {
 
  RingCylindrical::RingCylindrical(Pvl &label, bool allowDefaults) :
    RingPlaneProjection::RingPlaneProjection(label) {
    try {
      // Try to read the mapping group
      PvlGroup &mapGroup = label.findGroup("Mapping", Pvl::Traverse);
 
      // Compute the default value if allowed and needed
      if ((allowDefaults) && (!mapGroup.hasKeyword("CenterRingLongitude"))) {
        double az = (m_minimumRingLongitude + m_maximumRingLongitude) / 2.0;
        mapGroup += PvlKeyword("CenterRingLongitude", toString(az));
      }
 
      // Compute and write the default center radius if allowed and
      // necessary
      if ((allowDefaults) && (!mapGroup.hasKeyword("CenterRingRadius"))) {
        double radius = (m_minimumRingRadius + m_maximumRingRadius) / 2.0;
        mapGroup += PvlKeyword("CenterRingRadius", toString(radius));
      }
 
      // Get the center ring radius and center ring longitude.
      m_centerRingLongitude = mapGroup["CenterRingLongitude"];
      m_centerRingRadius = mapGroup["CenterRingRadius"];
 
      // Because the center radius is used to scale the y values of the projection, it cannot be 0.
      // For now, we will reset the center to the radius of Saturn.
      // Perhaps we should fail and issue an error message??? TODO
      if (m_centerRingRadius == 0.0) {
        m_centerRingRadius = 18000.;
      }
 
      //  Convert to radians, adjust for azimuth direction
      m_centerRingLongitude *= DEG2RAD;
      if (m_ringLongitudeDirection == Clockwise) m_centerRingLongitude *= -1.0;
    }
    catch (IException &e) {
      string message = "Invalid label group [Mapping]";
      throw IException(e, IException::Io, message, _FILEINFO_);
    }
  }
 
  RingCylindrical::~RingCylindrical() {
  }
 
  bool RingCylindrical::operator== (const Projection &proj) {
    if (!Projection::operator==(proj)) return false;
    // dont do the below it is a recusive plunge
    //  if (Projection::operator!=(proj)) return false;
    RingCylindrical *ringCyl = (RingCylindrical *) &proj;
    if ((ringCyl->m_centerRingLongitude != m_centerRingLongitude) ||
        (ringCyl->m_centerRingRadius != m_centerRingRadius)) return false;
    return true;
  }
 
  QString RingCylindrical::Name() const {
    return "RingCylindrical";
  }
 
  QString RingCylindrical::Version() const {
    return "1.0";
  }
 
 
  bool RingCylindrical::IsEquatorialCylindrical() {
    return true;
  }
 
 
  double RingCylindrical::TrueScaleRingRadius() const {
    return m_centerRingRadius;
  }
 
 
  double RingCylindrical::CenterRingLongitude() const {
    double dir = 1.0;
    if (m_ringLongitudeDirection == Clockwise) dir = -1.0;
    return m_centerRingLongitude * RAD2DEG * dir;
  }
 
 
  double RingCylindrical::CenterRingRadius() const {
    return m_centerRingRadius;
  }
 
 
  bool RingCylindrical::SetGround(const double ringRadius, const double ringLongitude) {
    //TODO Add  scalar to make azimuth distance equivalent to radius distance at center rad
    // Convert to azimuth to radians and adjust
    m_ringLongitude = ringLongitude;
    double ringLongitudeRadians = ringLongitude * DEG2RAD;
    if (m_ringLongitudeDirection == Clockwise) ringLongitudeRadians *= -1.0;
 
    // Check to make sure radius is valid
    if (ringRadius <= 0) {
      m_good = false;
      // cout << "Unable to set radius. The given radius value ["
      //      << IString(ringRadius) << "] is invalid." << endl;
      // throw IException(IException::Unknown,
      //                  "Unable to set radius. The given radius value ["
      //                  + IString(ringRadius) + "] is invalid.",
      //                  _FILEINFO_);
      return m_good;
    }
    m_ringRadius = ringRadius;
 
    // Compute helper variable
    double deltaAz = (ringLongitudeRadians - m_centerRingLongitude);
 
    // Compute the coordinates
    if (ringRadius ==0) {
      // TODO How should we handle this case? We should use epsilon probably instead of 0 too
      m_good = false;
      return m_good;
    }
    double x = deltaAz *  m_centerRingRadius;
    double y =  m_centerRingRadius - ringRadius;
    SetComputedXY(x, y);
    m_good = true;
    return m_good;
  }
 
  bool RingCylindrical::SetCoordinate(const double x, const double y) {
    // Save the coordinate
    SetXY(x, y);
 
    // Compute radius and make sure it is valid
    // m_ringRadius = GetY() + m_centerRingRadius;
    m_ringRadius = m_centerRingRadius - GetY();
    if (m_ringRadius < m_minimumRingRadius || m_ringRadius > m_maximumRingRadius) {
      m_good = false;
      return m_good;
    }
 
    // Compute azimuth
    m_ringLongitude =  m_centerRingLongitude + GetX() / m_centerRingRadius;
 
    // Convert to degrees
    m_ringLongitude *= RAD2DEG;
 
    // Cleanup the azimuth
    if (m_ringLongitudeDirection == Clockwise) m_ringLongitude *= -1.0;
    // Do these if the projection is circular
    // m_ringLongitude = To360Domain (m_ringLongitude);
    // if (m_ringLongitudeDomain == 180) m_ringLongitude = To180Domain(m_ringLongitude);
 
    m_good = true;
    return m_good;
  }
 
 
  PvlGroup RingCylindrical::Mapping() {
    PvlGroup mapping = RingPlaneProjection::Mapping();
 
    mapping += PvlKeyword("CenterRingRadius", toString(m_centerRingRadius));
    double dir = 1.0;
    if (m_ringLongitudeDirection == Clockwise) dir = -1.0;
    double lonDegrees = m_centerRingLongitude*RAD2DEG*dir;
    mapping += PvlKeyword("CenterRingLongitude", toString(lonDegrees));
 
    return mapping;
  }
 
  PvlGroup RingCylindrical::MappingRingRadii() {
    PvlGroup mapping = RingPlaneProjection::MappingRingRadii();
 
    if (HasGroundRange())
      mapping += m_mappingGrp["CenterRingRadius"];
 
    return mapping;
  }
 
 
  PvlGroup RingCylindrical::MappingRingLongitudes() {
    PvlGroup mapping = RingPlaneProjection::MappingRingLongitudes();
 
    if (HasGroundRange())
      mapping += m_mappingGrp["CenterRingLongitude"];
 
    return mapping;
  }
 
 
      bool RingCylindrical::XYRange(double &minX, double &maxX,
                               double &minY, double &maxY) {
 
        double rad, az;
 
        // Check the corners of the rad/az range
        XYRangeCheck(m_minimumRingRadius, m_minimumRingLongitude);
        XYRangeCheck(m_maximumRingRadius, m_minimumRingLongitude);
        XYRangeCheck(m_minimumRingRadius, m_maximumRingLongitude);
        XYRangeCheck(m_maximumRingRadius, m_maximumRingLongitude);
 
        // Walk top and bottom edges in half pixel increments
        double radiusInc = 2. * (m_maximumRingRadius - m_minimumRingRadius) / PixelResolution();
 
        for (rad = m_minimumRingRadius; rad <= m_maximumRingRadius; rad += radiusInc) {
          az = m_minimumRingLongitude;
          XYRangeCheck(rad, az);
 
          az = m_maximumRingLongitude;
          XYRangeCheck(rad, az);
        }
 
        // Walk left and right edges
        for (az = m_minimumRingLongitude; az <= m_maximumRingLongitude; az += 0.01) {
          rad = m_minimumRingRadius;
          XYRangeCheck(rad, az);
 
          rad = m_maximumRingRadius;
          XYRangeCheck(rad, az);
        }
 
        // Make sure everything is ordered
        if (m_minimumX >= m_maximumX) return false;
        if (m_minimumY >= m_maximumY) return false;
 
        // Return X/Y min/maxs
        // m_maximumX = m_maximumRingRadius*cos(m_maximumRingLongitude);
        // m_minimumX = -m_maximumX;
        // m_maximumY = m_maximumRingRadius*sin(m_maximumRingLongitude);
        // m_minimumY = -m_maximumY;
 
        minX = m_minimumX;
        maxX = m_maximumX;
        minY = m_minimumY;
        maxY = m_maximumY;
 
        return true;
      }
} // end namespace isis
 
extern "C" Isis::Projection *RingCylindricalPlugin(Isis::Pvl &lab,
    bool allowDefaults) {
  return new Isis::RingCylindrical(lab, allowDefaults);
}