RingPlaneProjection.cpp

Go to the documentation of this file.

#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 [" 
                       + 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;
  }

  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