RingPlaneProjection.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "RingPlaneProjection.h"
 
#include <QObject>
 
#include <cfloat>
#include <cmath>
#include <iomanip>
#include <sstream>
#include <vector>
 
#include <SpiceUsr.h>
 
#include "Constants.h"
#include "Displacement.h"
#include "FileName.h"
#include "IException.h"
#include "IString.h"
#include "Longitude.h"
#include "NaifStatus.h"
#include "Pvl.h"
#include "PvlGroup.h"
#include "PvlKeyword.h"
#include "SpecialPixel.h"
#include "WorldMapper.h"
 
using namespace std;
namespace Isis {
  RingPlaneProjection::RingPlaneProjection(Pvl &label) : Projection::Projection(label) {
    try {
      // Mapping group is read by the parent (Projection)
      // Get the RingLongitude Direction
      if ((QString) m_mappingGrp["RingLongitudeDirection"] == "Clockwise") {
        m_ringLongitudeDirection = Clockwise;
      }
      else if ((QString) m_mappingGrp["RingLongitudeDirection"] == "CounterClockwise") {
        m_ringLongitudeDirection = CounterClockwise;
      }
      else {
        QString msg = "Projection failed. Invalid value for keyword "
                      "[RingLongitudeDirection] must be "
                      "[Clockwise or CounterClockwise]";
        throw IException(IException::Unknown, msg, _FILEINFO_);
      }
 
      // Get the RingLongitudeDomain
      if ((QString) m_mappingGrp["RingLongitudeDomain"] == "360") {
        m_ringLongitudeDomain = 360;
      }
      else if ((QString) m_mappingGrp["RingLongitudeDomain"] == "180") {
        m_ringLongitudeDomain = 180;
      }
      else {
        QString msg = "Projection failed. Invalid value for keyword "
                      "[RingLongitudeDomain] must be [180 or 360]";
        throw IException(IException::Unknown, msg, _FILEINFO_);
      }
 
      // Get the ground range if it exists
      m_groundRangeGood = false;
 
      if ((m_mappingGrp.hasKeyword("MinimumRingLongitude")) &&
          (m_mappingGrp.hasKeyword("MaximumRingLongitude")) &&
          (m_mappingGrp.hasKeyword("MaximumRingRadius")) &&
          (m_mappingGrp.hasKeyword("MinimumRingRadius"))) {
        m_minimumRingLongitude = m_mappingGrp["MinimumRingLongitude"];
        m_maximumRingLongitude = m_mappingGrp["MaximumRingLongitude"];
        m_minimumRingRadius = m_mappingGrp["MinimumRingRadius"];
        m_maximumRingRadius = m_mappingGrp["MaximumRingRadius"];
 
        if (m_minimumRingRadius < 0) {
          IString msg = "Projection failed. "
                        "[MinimumRingRadius] of ["+ IString(m_minimumRingRadius) +  "] is not "
                        + "valid";
          throw IException(IException::Unknown, msg, _FILEINFO_);
        }
 
        if (m_maximumRingRadius < 0) {
          IString msg = "Projection failed. "
                        "[MaximumRingRadius] of ["+ IString(m_maximumRingRadius) +  "] is not "
                        + "valid";
          throw IException(IException::Unknown, msg, _FILEINFO_);
        }
 
        if (m_minimumRingRadius >= m_maximumRingRadius) {
          IString msg = "Projection failed. "
                        "[MinimumRingRadius,MaximumRingRadius] of ["
                        + IString(m_minimumRingRadius) + ","
                        + IString(m_maximumRingRadius) + "] are not "
                        + "properly ordered";
          throw IException(IException::Unknown, msg, _FILEINFO_);
        }
 
        if (m_minimumRingLongitude >= m_maximumRingLongitude) {
          IString msg = "Projection failed. "
                        "[MinimumRingLongitude,MaximumRingLongitude] of ["
                        + IString(m_minimumRingLongitude) + ","
                        + IString(m_maximumRingLongitude) + "] are not "
                        + "properly ordered";
          throw IException(IException::Unknown, msg, _FILEINFO_);
        }
 
        m_groundRangeGood = true;
      }
      else {
        // if no ground range is given, initialize the min/max ring rad/lon to 0
        m_minimumRingRadius  = 0.0;
        m_maximumRingRadius  = 0.0;
        m_minimumRingLongitude = 0.0;
        m_maximumRingLongitude = 0.0;
      }
 
      // Initialize miscellaneous protected data elements
      // initialize the rest of the x,y,ring rad,ring lon
      // member variables
      m_ringRadius = Null;
      m_ringLongitude = Null;
 
      // If we made it to this point, we have what we need for a ring plane projection
      setProjectionType(RingPlane);
    }
    catch(IException &e) {
      IString msg = "Projection failed.  Invalid label group [Mapping]";
      throw IException(e, IException::Unknown, msg, _FILEINFO_);
    }
  }
 
  RingPlaneProjection::~RingPlaneProjection() {
  }
 
  bool RingPlaneProjection::operator== (const Projection &proj) {
    if (!Projection::operator==(proj)) return false;
    RingPlaneProjection *rproj = (RingPlaneProjection *) &proj;
    if (IsClockwise() != rproj->IsClockwise()) return false;
    if (Has180Domain() != rproj->Has180Domain()) return false;
    return true;
  }
 
 
  double RingPlaneProjection::TrueScaleRingRadius() const {
    return 0.0;
  }
 
 
  bool RingPlaneProjection::IsClockwise() const {
    return m_ringLongitudeDirection == Clockwise;
  }
 
  bool RingPlaneProjection::IsCounterClockwise() const {
    return m_ringLongitudeDirection == CounterClockwise;
  }
 
  double RingPlaneProjection::ToClockwise(const double ringLongitude, const int domain) {
    if (ringLongitude == Null) {
      throw IException(IException::Unknown,
                       "Unable to convert to Clockwise. The given ring longitude value ["
                       + Isis::toString(ringLongitude) + "] is invalid.",
                       _FILEINFO_);
    }
    double myRingLongitude = ringLongitude;
 
    myRingLongitude *= -1;
 
    if (domain == 360) {
      myRingLongitude = To360Domain(myRingLongitude);
    }
    else if (domain == 180) {
      myRingLongitude = To180Domain(myRingLongitude);
    }
    else {
      IString msg = "Unable to convert ring longitude.  Domain [" + Isis::toString(domain)
                    + "] is not 180 or 360.";
      throw IException(IException::Unknown, msg, _FILEINFO_);
    }
 
    return myRingLongitude;
  }
 
  double RingPlaneProjection::ToCounterClockwise(const double ringLongitude, const int domain) {
    if (ringLongitude == Null) {
      throw IException(IException::Unknown,
                       "Unable to convert to CounterClockwise. The given ring longitude value ["
                       + IString(ringLongitude) + "] is invalid.",
                       _FILEINFO_);
    }
    double myRingLongitude = ringLongitude;
 
    myRingLongitude *= -1;
 
    if (domain == 360) {
      myRingLongitude = To360Domain(myRingLongitude);
    }
    else if (domain == 180) {
      myRingLongitude = To180Domain(myRingLongitude);
    }
    else {
      IString msg = "Unable to convert ring longitude.  Domain [" + IString(domain)
                    + "] is not 180 or 360.";
      throw IException(IException::Unknown, msg, _FILEINFO_);
    }
 
    return myRingLongitude;
  }
 
 
  string RingPlaneProjection::RingLongitudeDirectionString() const {
    if (m_ringLongitudeDirection == Clockwise) return "Clockwise";
    return "CounterClockwise";
  }
 
  bool RingPlaneProjection::Has180Domain() const {
    return m_ringLongitudeDomain == 180;
  }
 
  bool RingPlaneProjection::Has360Domain() const {
    return m_ringLongitudeDomain == 360;
  }
 
  double RingPlaneProjection::To180Domain(const double ringLongitude) {
    if (ringLongitude == Null) {
      throw IException(IException::Unknown,
                       "Unable to convert to 180 degree domain. The given ring longitude value ["
                       + IString(ringLongitude) + "] is invalid.",
                       _FILEINFO_);
    }
    return Isis::Longitude(ringLongitude, Angle::Degrees).force180Domain().degrees();
  }
 
  double RingPlaneProjection::To360Domain(const double ringLongitude) {
    if (ringLongitude == Null) {
      throw IException(IException::Unknown,
                       "Unable to convert to 360 degree domain. The given ring longitude value ["
                       + IString(ringLongitude) + "] is invalid.",
                       _FILEINFO_);
    }
    double result = ringLongitude;
 
    if ( (ringLongitude < 0.0 || ringLongitude > 360.0) &&
        !qFuzzyCompare(ringLongitude, 0.0) && !qFuzzyCompare(ringLongitude, 360.0)) {
     result = Isis::Longitude(ringLongitude, Angle::Degrees).force360Domain().degrees();
    }
 
    return result;
  }
 
  string RingPlaneProjection::RingLongitudeDomainString() const {
    if (m_ringLongitudeDomain == 360) return "360";
    return "180";
  }
 
  double RingPlaneProjection::MinimumRingRadius() const {
    return m_minimumRingRadius;
  }
 
  double RingPlaneProjection::MaximumRingRadius() const {
    return m_maximumRingRadius;
  }
 
  double RingPlaneProjection::MinimumRingLongitude() const {
    return m_minimumRingLongitude;
  }
 
  double RingPlaneProjection::MaximumRingLongitude() const {
    return m_maximumRingLongitude;
  }
 
  bool RingPlaneProjection::SetGround(const double ringRadius, const double ringLongitude) {
    if (ringRadius == Null || ringLongitude == Null) {
      m_good = false;
      return m_good;
    }
    else {
      m_ringRadius = ringRadius;
      m_ringLongitude = ringLongitude;
      m_good = true;
      SetComputedXY(ringLongitude, ringRadius);
    }
    return m_good;
  }
 
  bool RingPlaneProjection::SetCoordinate(const double x, const double y) {
    if (x == Null || y == Null) {
      m_good = false;
    }
    else {
      m_good = true;
      SetXY(x, y);
      m_ringRadius = XCoord();
      m_ringLongitude = YCoord();
    }
    return m_good;
  }
 
 
  double RingPlaneProjection::RingRadius() const {
    return m_ringRadius;
  }
 
 
  double RingPlaneProjection::LocalRadius() const {
    return m_ringRadius;
  }
 
  double RingPlaneProjection::RingLongitude() const {
    return m_ringLongitude;
  }
 
  bool RingPlaneProjection::SetUniversalGround(const double ringRadius, const double ringLongitude) {
    if (ringRadius == Null || ringLongitude == Null) {
      m_good = false;
      return m_good;
    }
    // Deal with the ring longitude first
    m_ringLongitude = ringLongitude;
    if (m_ringLongitudeDirection == Clockwise) m_ringLongitude = -ringLongitude;
    if (m_ringLongitudeDomain == 180) {
      m_ringLongitude = To180Domain(m_ringLongitude);
    }
    else {
      // Do this because RingLongitudeDirection could cause (-360,0)
      m_ringLongitude = To360Domain(m_ringLongitude);
    }
 
    // Nothing to do with radius
 
    m_ringRadius = ringRadius;
 
    // Now the rad/ring longitude are in user defined coordinates so set them
    return SetGround(m_ringRadius, m_ringLongitude);
    }
 
  double RingPlaneProjection::UniversalRingRadius() {
    double ringRadius = m_ringRadius;
    return ringRadius;
  }
 
 
  double RingPlaneProjection::UniversalRingLongitude() {
    double ringLongitude = m_ringLongitude;
    if (m_ringLongitudeDirection == Clockwise) ringLongitude = -ringLongitude;
    ringLongitude = To360Domain(ringLongitude);
    return ringLongitude;
  }
 
 
  double RingPlaneProjection::Scale() const {
    if (m_mapper != NULL) {
      double localRadius = TrueScaleRingRadius();
      return localRadius / m_mapper->Resolution() * DEG2RAD;
     // return localRadius / m_mapper->Resolution();
    }
    else {
      return 1.0;
    }
  }
 
 
  bool RingPlaneProjection::XYRange(double &minX, double &maxX,
                           double &minY, double &maxY) {
    if (minX == Null || maxX == Null || minY == Null || maxY == Null) {
      return false;
    }
    if (m_groundRangeGood) {
      minX = m_minimumRingLongitude;
      maxX = m_maximumRingLongitude;
      minY = m_minimumRingRadius;
      maxY = m_maximumRingRadius;
      return true;
    }
    return false;
  }
 
  void RingPlaneProjection::XYRangeCheck(const double ringRadius, const double ringLongitude) {
    if (ringRadius == Null || ringLongitude == Null) {
      m_good = false;
      return;
    }
    SetGround(ringRadius, ringLongitude);
    if (!IsGood()) return;
 
    if (XCoord() < m_minimumX) m_minimumX = XCoord();
    if (XCoord() > m_maximumX) m_maximumX = XCoord();
    if (YCoord() < m_minimumY) m_minimumY = YCoord();
    if (YCoord() > m_maximumY) m_maximumY = YCoord();
    return;
  }
 
  // bool Projection::xyRangeOblique(double &minX, double &maxX,
  //                                 double &minY, double &maxY) {
  //   if (minX == Null || maxX == Null || minY == Null || maxY == Null) {
  //     return false;
  //   }
  //   //For oblique, we'll have to walk all 4 sides to find out min/max x/y values
  //   if (!HasGroundRange()) return false; // Don't have min/max ring rad/lon,
  //                                       //can't continue
 
  //   m_specialLatCases.clear();
  //   m_specialLonCases.clear();
 
  //   // First, search ring longitude for
  //   min X/Y double minFoundX1, minFoundX2;
  //   double minFoundY1, minFoundY2;
 
  //   // Search for minX between minlat and maxlat along minlon
  //   doSearch(MinimumLatitude(), MaximumLatitude(),
  //            minFoundX1, MinimumLongitude(), true, true, true);
  //   // Search for minX between minlat and maxlat along maxlon
  //   doSearch(MinimumLatitude(), MaximumLatitude(),
  //            minFoundX2, MaximumLongitude(), true, true, true);
  //   // Search for minY between minlat and maxlat along minlon
  //   doSearch(MinimumLatitude(), MaximumLatitude(),
  //            minFoundY1, MinimumLongitude(), false, true, true);
  //   // Search for minY between minlat and maxlat along maxlon
  //   doSearch(MinimumLatitude(), MaximumLatitude(),
  //            minFoundY2, MaximumLongitude(), false, true, true);
 
  //   // Second, search latitude for min X/Y
  //   double minFoundX3, minFoundX4;
  //   double minFoundY3, minFoundY4;
 
  //   // Search for minX between minlon and maxlon along minlat
  //   doSearch(MinimumLongitude(), MaximumLongitude(),
  //            minFoundX3, MinimumLatitude(), true, false, true);
  //   // Search for minX between minlon and maxlon along maxlat
  //   doSearch(MinimumLongitude(), MaximumLongitude(),
  //            minFoundX4, MaximumLatitude(), true, false, true);
  //   // Search for minY between minlon and maxlon along minlat
  //   doSearch(MinimumLongitude(), MaximumLongitude(),
  //            minFoundY3, MinimumLatitude(), false, false, true);
  //   // Search for minY between minlon and maxlon along maxlat
  //   doSearch(MinimumLongitude(), MaximumLongitude(),
  //            minFoundY4, MaximumLatitude(), false, false, true);
 
  //   // We've searched all possible minimums, go ahead and store the lowest
  //   double minFoundX5 = min(minFoundX1, minFoundX2);
  //   double minFoundX6 = min(minFoundX3, minFoundX4);
  //   m_minimumX = min(minFoundX5, minFoundX6);
 
  //   double minFoundY5 = min(minFoundY1, minFoundY2);
  //   double minFoundY6 = min(minFoundY3, minFoundY4);
  //   m_minimumY = min(minFoundY5, minFoundY6);
 
  //   // Search ring longitude for
  //   max X/Y double maxFoundX1,
  //   maxFoundX2; double maxFoundY1,
  //   maxFoundY2;
 
  //   // Search for maxX between minlat and maxlat along minlon
  //   doSearch(MinimumLatitude(), MaximumLatitude(),
  //            maxFoundX1, MinimumLongitude(), true, true, false);
  //   // Search for maxX between minlat and maxlat along maxlon
  //   doSearch(MinimumLatitude(), MaximumLatitude(),
  //            maxFoundX2, MaximumLongitude(), true, true, false);
  //   // Search for maxY between minlat and maxlat along minlon
  //   doSearch(MinimumLatitude(), MaximumLatitude(),
  //            maxFoundY1, MinimumLongitude(), false, true, false);
  //   // Search for maxY between minlat and maxlat along maxlon
  //   doSearch(MinimumLatitude(), MaximumLatitude(),
  //            maxFoundY2, MaximumLongitude(), false, true, false);
 
  //   // Search latitude for max X/Y
  //   double maxFoundX3, maxFoundX4;
  //   double maxFoundY3, maxFoundY4;
 
  //   // Search for maxX between minlon and maxlon along minlat
  //   doSearch(MinimumLongitude(), MaximumLongitude(),
  //            maxFoundX3, MinimumLatitude(), true, false, false);
  //   // Search for maxX between minlon and maxlon along maxlat
  //   doSearch(MinimumLongitude(), MaximumLongitude(),
  //            maxFoundX4, MaximumLatitude(), true, false, false);
  //   // Search for maxY between minlon and maxlon along minlat
  //   doSearch(MinimumLongitude(), MaximumLongitude(),
  //            maxFoundY3, MinimumLatitude(), false, false, false);
  //   // Search for maxY between minlon and maxlon along maxlat
  //   doSearch(MinimumLongitude(), MaximumLongitude(),
  //            maxFoundY4, MaximumLatitude(), false, false, false);
 
  //   // We've searched all possible maximums, go ahead and store the highest
  //   double maxFoundX5 = max(maxFoundX1, maxFoundX2);
  //   double maxFoundX6 = max(maxFoundX3, maxFoundX4);
  //   m_maximumX = max(maxFoundX5, maxFoundX6);
 
  //   double maxFoundY5 = max(maxFoundY1, maxFoundY2);
  //   double maxFoundY6 = max(maxFoundY3, maxFoundY4);
  //   m_maximumY = max(maxFoundY5, maxFoundY6);
 
  //   // Look along discontinuities for more extremes
  //   vector<double> specialLatCases = m_specialLatCases;
  //   for (unsigned int specialLatCase = 0;
  //       specialLatCase < specialLatCases.size();
  //       specialLatCase ++) {
  //     double minX, maxX, minY, maxY;
 
  //     // Search for minX between minlon and maxlon along latitude discontinuities
  //     doSearch(MinimumLongitude(), MaximumLongitude(),
  //              minX, specialLatCases[specialLatCase], true,  false, true);
  //     // Search for minY between minlon and maxlon along latitude discontinuities
  //     doSearch(MinimumLongitude(), MaximumLongitude(),
  //              minY, specialLatCases[specialLatCase], false, false, true);
  //     // Search for maxX between minlon and maxlon along latitude discontinuities
  //     doSearch(MinimumLongitude(), MaximumLongitude(),
  //              maxX, specialLatCases[specialLatCase], true,  false, false);
  //     // Search for maxX between minlon and maxlon along latitude discontinuities
  //     doSearch(MinimumLongitude(), MaximumLongitude(),
  //              maxY, specialLatCases[specialLatCase], false, false, false);
 
  //     m_minimumX = min(minX, m_minimumX);
  //     m_maximumX = max(maxX, m_maximumX);
  //     m_minimumY = min(minY, m_minimumY);
  //     m_maximumY = max(maxY, m_maximumY);
  //   }
 
  //   vector<double> specialLonCases = m_specialLonCases;
  //   for (unsigned int specialLonCase = 0;
  //       specialLonCase < specialLonCases.size();
  //       specialLonCase ++) {
  //     double minX, maxX, minY, maxY;
 
  //     // Search for minX between minlat and maxlat along longitude discontinuities
  //     doSearch(MinimumLatitude(), MaximumLatitude(),
  //              minX, specialLonCases[specialLonCase], true,  true, true);
  //     // Search for minY between minlat and maxlat along longitude discontinuities
  //     doSearch(MinimumLatitude(), MaximumLatitude(),
  //              minY, specialLonCases[specialLonCase], false, true, true);
  //     // Search for maxX between minlat and maxlat along longitude discontinuities
  //     doSearch(MinimumLatitude(), MaximumLatitude(),
  //              maxX, specialLonCases[specialLonCase], true,  true, false);
  //     // Search for maxY between minlat and maxlat along longitude discontinuities
  //     doSearch(MinimumLatitude(), MaximumLatitude(),
  //              maxY, specialLonCases[specialLonCase], false, true, false);
 
  //     m_minimumX = min(minX, m_minimumX);
  //     m_maximumX = max(maxX, m_maximumX);
  //     m_minimumY = min(minY, m_minimumY);
  //     m_maximumY = max(maxY, m_maximumY);
  //   }
 
  //   m_specialLatCases.clear();
  //   m_specialLonCases.clear();
 
  //   // Make sure everything is ordered
  //   if (m_minimumX >= m_maximumX) return false;
  //   if (m_minimumY >= m_maximumY) return false;
 
  //   // Return X/Y min/maxs
  //   minX = m_minimumX;
  //   maxX = m_maximumX;
  //   minY = m_minimumY;
  //   maxY = m_maximumY;
 
  //   return true;
  // }
 
  // void Projection::doSearch(double minBorder, double maxBorder,
  //                           double &extremeVal, const double constBorder,
  //                           bool searchX, bool searchRingLongitude, bool findMin) {
  //   if (minBorder == Null || maxBorder == Null || constBorder == Null) {
  //     return;
  //   }
  //   const double TOLERANCE = m_pixelResolution/2;
  //   const int NUM_ATTEMPTS = (unsigned int)DBL_DIG; // It's unsafe to go past
  //                                                   // this precision
 
  //   double minBorderX, minBorderY, maxBorderX, maxBorderY;
  //   int attempts = 0;
 
  //   do {
  //     findExtreme(minBorder, maxBorder, minBorderX, minBorderY, maxBorderX,
  //                 maxBorderY, constBorder, searchX, searchLongitude, findMin);
  //     if (minBorderX == Null && maxBorderX == Null
  //         && minBorderY == Null && maxBorderY == Null ) {
  //       attempts = NUM_ATTEMPTS;
  //       continue;
  //     }
  //     attempts ++;
  //   }
  //   while ((fabs(minBorderX - maxBorderX) > TOLERANCE
  //          || fabs(minBorderY - maxBorderY) > TOLERANCE)
  //          && (attempts < NUM_ATTEMPTS));
  //   // check both x and y distance in case symmetry of map
  //   // For example, if minBorderX = maxBorderX but minBorderY = -maxBorderY,
  //   // these points may not be close enough.
 
  //   if (attempts >= NUM_ATTEMPTS) {
  //     // We zoomed in on a discontinuity because our range never shrank, this
  //     // will need to be rechecked later.
  //     // *min and max border should be nearly identical, so it doesn't matter
  //     //  which is used here
  //     if (searchLongitude) {
  //       m_specialLatCases.push_back(minBorder);
  //     }
  //     else {
  //       m_specialLonCases.push_back(minBorder);
  //     }
  //   }
 
  //   // These values will always be accurate, even over a discontinuity
  //   if (findMin) {
  //     if (searchX) extremeVal = min(minBorderX, maxBorderX);
  //     else         extremeVal = min(minBorderY, maxBorderY);
  //   }
  //   else {
  //     if (searchX) extremeVal = max(minBorderX, maxBorderX);
  //     else         extremeVal = max(minBorderY, maxBorderY);
  //   }
  //   return;
  // }
 
  // void Projection::findExtreme(double &minBorder,  double &maxBorder,
  //                              double &minBorderX, double &minBorderY,
  //                              double &maxBorderX, double &maxBorderY,
  //                              const double constBorder, bool searchX,
  //                              bool searchRingLongitude, bool findMin) {
  //   if (minBorder == Null || maxBorder == Null || constBorder == Null) {
  //     minBorderX = Null;
  //     minBorderY = minBorderX;
  //     minBorderX = minBorderX;
  //     minBorderY = minBorderX;
  //     return;
  //   }
  //   if (!searchRingLongitude && (fabs(fabs(constBorder) - 90.0) < DBL_EPSILON)) {
  //     // it is impossible to search "along" a pole
  //     setSearchGround(minBorder, constBorder, searchRingLongitude);
  //     minBorderX = XCoord();
  //     minBorderY = YCoord();
  //     maxBorderX = minBorderX;
  //     maxBorderY = minBorderY;
  //     return;
  //   }
  //   // Always do 10 steps
  //   const double STEP_SIZE = (maxBorder - minBorder) / 10.0;
  //   const double LOOP_END = maxBorder + (STEP_SIZE / 2.0); // This ensures we do
  //                                                          // all of the steps
  //                                                          // properly
  //   double currBorderVal = minBorder;
  //   setSearchGround(minBorder, constBorder, searchRingLongitude);
 
  //   // this makes sure that the initial currBorderVal is valid before entering
  //   // the loop below
  //   if (!m_good){
  //     // minBorder = currBorderVal+STEP_SIZE < LOOP_END until setGround is good?
  //     // then, if still not good return?
  //     while (!m_good && currBorderVal <= LOOP_END) {
  //       currBorderVal+=STEP_SIZE;
  //       if (searchRingLongitude && (currBorderVal - 90.0 > DBL_EPSILON)) {
  //         currBorderVal = 90.0;
  //       }
  //       setSearchGround(currBorderVal, constBorder, searchRingLongitude);
  //     }
  //     if (!m_good) {
  //       minBorderX = Null;
  //       minBorderY = minBorderX;
  //       minBorderX = minBorderX;
  //       minBorderY = minBorderX;
  //       return;
  //     }
  //   }
 
  //   // save the values of three consecutive steps from the minBorder towards
  //   // the maxBorder along the constBorder. initialize these three border
  //   // values (the non-constant lat or lon)
  //   double border1 = currBorderVal;
  //   double border2 = currBorderVal;
  //   double border3 = currBorderVal;
 
  //   // save the coordinate (x or y) values that correspond to the first
  //   // two borders that are being saved.
  //   // initialize these two coordinate values (x or y)
  //   double value1 = (searchX) ? XCoord() : YCoord();
  //   double value2 = value1;
 
  //   // initialize the extreme coordinate value
  //   // -- this is the largest coordinate value found so far
  //   double extremeVal2 = value2;
 
  //   // initialize the extreme border values
  //   // -- these are the borders on either side of the extreme coordinate value
  //   double extremeBorder1 = minBorder;
  //   double extremeBorder3 = minBorder;
 
  //   while (currBorderVal <= LOOP_END) {
 
  //     // this conditional was added to prevent trying to SetGround with an
  //     // invalid latitude greater than 90 degrees. There is no need check for
  //     // latitude less than -90 since we start at the minBorder (already
  //     // assumed to be valid) and step forward toward (and possibly past)
  //     // maxBorder
  //     if (searchRingLongitude && (currBorderVal - 90.0 > DBL_EPSILON)) {
  //       currBorderVal = 90.0;
  //     }
 
  //     // update the current border value along constBorder
  //     currBorderVal += STEP_SIZE;
  //     setSearchGround(currBorderVal, constBorder, searchRingLongitude);
  //     if (!m_good){
  //       continue;
  //     }
 
  //     // update the border and coordinate values
  //     border3 = border2;
  //     border2 = border1;
  //     border1 = currBorderVal;
  //     value2 = value1;
  //     value1 = (searchX) ? XCoord() : YCoord();
 
  //     if ((findMin && value2 < extremeVal2)
  //         || (!findMin && value2 > extremeVal2)) {
  //       // Compare the coordinate value associated with the center border with
  //       // the current extreme. If the updated coordinate value is more extreme
  //       // (smaller or larger, depending on findMin), then we update the
  //       // extremeVal and it's borders.
  //       extremeVal2 = value2;
 
  //       extremeBorder3 = border3;
  //       extremeBorder1 = border1;
  //     }
  //   }
 
  //   // update min/max border values to the values on either side of the most
  //   // extreme coordinate found in this call to this method
 
  //   minBorder = extremeBorder3; // Border 3 is lagging and thus smaller
 
  //   // since the loop steps past the original maxBorder, we want to retain
  //   // the original maxBorder value so we don't go outside of the original
  //   // min/max range given
  //   if (extremeBorder1 <= maxBorder ) {
  //     maxBorder = extremeBorder1; // Border 1 is leading and thus larger
  //   }
 
  //   // update minBorder coordinate values
  //   setSearchGround(minBorder, constBorder, searchRingLongitude);
  //   // if (!m_good){
  //   //   this should not happen since minBorder has already been verified in
  //   //   the while loop above
  //   // }
 
  //   minBorderX = XCoord();
  //   minBorderY = YCoord();
 
  //   // update maxBorder coordinate values
  //   setSearchGround(maxBorder, constBorder, searchRingLongitude);
  //   // if (!m_good){
  //   //   this should not happen since maxBorder has already been verified in
  //   //   the while loop above
  //   // }
 
  //   maxBorderX = XCoord();
  //   maxBorderY = YCoord();
  //   return;
  // }
 
  // void Projection::setSearchGround(const double variableBorder,
  //                                  const double constBorder,
  //                                  bool variableIsLat) {
  //   if (variableBorder == Null || constBorder == Null) {
  //     return;
  //   }
  //   double lat, lon;
  //   if (variableIsLat) {
  //     lat = variableBorder;
  //     lon = constBorder;
  //   }
  //   else {
  //     lat = constBorder;
  //     lon = variableBorder;
  //   }
  //   SetGround(lat, lon);
  //   return;
  // }
 
 
  PvlGroup RingPlaneProjection::Mapping() {
    PvlGroup mapping("Mapping");
 
    if (m_mappingGrp.hasKeyword("TargetName")) {
      mapping += m_mappingGrp["TargetName"];
    }
 
    mapping += m_mappingGrp["ProjectionName"];
    mapping += m_mappingGrp["RingLongitudeDirection"];
    mapping += m_mappingGrp["RingLongitudeDomain"];
 
    if (m_mappingGrp.hasKeyword("PixelResolution")) {
      mapping += m_mappingGrp["PixelResolution"];
    }
    if (m_mappingGrp.hasKeyword("Scale")) {
      mapping += m_mappingGrp["Scale"];
    }
    if (m_mappingGrp.hasKeyword("UpperLeftCornerX")) {
      mapping += m_mappingGrp["UpperLeftCornerX"];
    }
    if (m_mappingGrp.hasKeyword("UpperLeftCornerY")) {
      mapping += m_mappingGrp["UpperLeftCornerY"];
    }
 
    if (HasGroundRange()) {
      mapping += m_mappingGrp["MinimumRingRadius"];
      mapping += m_mappingGrp["MaximumRingRadius"];
      mapping += m_mappingGrp["MinimumRingLongitude"];
      mapping += m_mappingGrp["MaximumRingLongitude"];
    }
 
    if (m_mappingGrp.hasKeyword("Rotation")) {
      mapping += m_mappingGrp["Rotation"];
    }
 
    return mapping;
  }
 
  PvlGroup RingPlaneProjection::MappingRingRadii() {
    PvlGroup mapping("Mapping");
 
    if (HasGroundRange()) {
      mapping += m_mappingGrp["MinimumRingRadius"];
      mapping += m_mappingGrp["MaximumRingRadius"];
    }
 
    return mapping;
  }
 
 
  PvlGroup RingPlaneProjection::MappingRingLongitudes() {
    PvlGroup mapping("Mapping");
 
    if (HasGroundRange()) {
      mapping += m_mappingGrp["MinimumRingLongitude"];
      mapping += m_mappingGrp["MaximumRingLongitude"];
    }
 
    return mapping;
  }
 
} //end namespace isis