RingCylindrical.cpp

Go to the documentation of this file.

#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;
  }

  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);

// cout << " ************ WALK RADIUS ******************\n";
// cout << "MIN RAD: " << m_minimumRingRadius << " MAX RAD: " << m_maximumRingRadius << "\n";
    // 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) {
// cout << "WALKED A STEP - rad: " << rad << "\n";
      rad = rad;
      az = m_minimumRingLongitude;
      XYRangeCheck(rad, az);

      rad = rad;
      az = m_maximumRingLongitude;
      XYRangeCheck(rad, az);
// cout << "MIN RAD: " << m_minimumRingRadius << " MAX RAD: " << m_maximumRingRadius << "\n";
    }

//cout << " ************ WALK AZIMUTH ******************\n";
    // Walk left and right edges
    for (az = m_minimumRingLongitude; az <= m_maximumRingLongitude; az += 0.01) {
      rad = m_minimumRingRadius;
      az = az;
      XYRangeCheck(rad, az);

      rad = m_maximumRingRadius;
      az = az;
      XYRangeCheck(rad, az);
    }

    // Walk the limb 
/*
    for (double angle = 0.0; angle <= 360.0; angle += 0.01) {
      double x = m_equatorialRingRadius * cos(angle * PI / 180.0);
      double y = m_equatorialRingRadius * sin(angle * PI / 180.0);
      if (SetCoordinate(x, y) == 0) {
        if (m_latitude > m_maximumLatitude) {
          continue;
        }
        if (m_longitude > m_maximumRingLongitude) {
          continue;
        }
        if (m_latitude < m_minimumLatitude) {
          continue;
        }
        if (m_longitude < m_minimumRingLongitude) {
          continue;
        }

        if (m_minimumX > x) m_minimumX = x;
        if (m_maximumX < x) m_maximumX = x;
        if (m_minimumY > y) m_minimumY = y;
        if (m_maximumY < y) m_maximumY = y;
        XYRangeCheck(m_latitude, m_longitude);
      }
    } */

    // 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;
  }


  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;
  }

} // end namespace isis

extern "C" Isis::Projection *RingCylindricalPlugin(Isis::Pvl &lab,
    bool allowDefaults) {
  return new Isis::RingCylindrical(lab, allowDefaults);
}