SimpleCylindrical.cpp

Go to the documentation of this file.

#include "SimpleCylindrical.h"

#include <cmath>
#include <cfloat>

#include "Constants.h"
#include "IException.h"
#include "Projection.h"
#include "Pvl.h"
#include "PvlGroup.h"
#include "PvlKeyword.h"

using namespace std;
namespace Isis {

  SimpleCylindrical::SimpleCylindrical(Pvl &label, bool allowDefaults) :
    Projection::Projection(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("CenterLongitude"))) {
        double lon = (m_minimumLongitude + m_maximumLongitude) / 2.0;
        mapGroup += PvlKeyword("CenterLongitude", toString(lon));
      }

      // Get the center longitude, convert to radians, adjust for longitude
      // direction
      m_centerLongitude = mapGroup["CenterLongitude"];
      m_centerLongitude *= PI / 180.0;
      if (m_longitudeDirection == PositiveWest) m_centerLongitude *= -1.0;
    }
    catch(IException &e) {
      QString message = "Invalid label group [Mapping]";
      throw IException(e, IException::Io, message, _FILEINFO_);
    }
  }

  SimpleCylindrical::~SimpleCylindrical() {
  }

  bool SimpleCylindrical::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;
    SimpleCylindrical *simp = (SimpleCylindrical *) &proj;
    if (simp->m_centerLongitude != m_centerLongitude) return false;
    return true;
  }

  QString SimpleCylindrical::Name() const {
    return "SimpleCylindrical";
  }

  QString SimpleCylindrical::Version() const {
    return "1.0";
  }

  bool SimpleCylindrical::IsEquatorialCylindrical() {
    return true;
  }

  bool SimpleCylindrical::SetGround(const double lat, const double lon) {
    // Convert to radians
    m_latitude = lat;
    m_longitude = lon;
    double latRadians = lat * PI / 180.0;
    double lonRadians = lon * PI / 180.0;
    if (m_longitudeDirection == PositiveWest) lonRadians *= -1.0;

    // Compute the coordinate
    double deltaLon = (lonRadians - m_centerLongitude);
    double x = m_equatorialRadius * deltaLon;
    double y = m_equatorialRadius * latRadians;
    SetComputedXY(x, y);
    m_good = true;
    return m_good;
  }

  bool SimpleCylindrical::SetCoordinate(const double x, const double y) {
    // Save the coordinate
    SetXY(x, y);

    // Compute latitude and make sure it is not above 90
    m_latitude = GetY() / m_equatorialRadius;
    if ((fabs(m_latitude) - HALFPI) > DBL_EPSILON) {
      m_good = false;
      return m_good;
    }

    // Compute longitude
    m_longitude = m_centerLongitude + GetX() / m_equatorialRadius;

    // Convert to degrees
    m_latitude *= 180.0 / PI;
    m_longitude *= 180.0 / PI;

    // Cleanup the longitude
    if (m_longitudeDirection == PositiveWest) m_longitude *= -1.0;
    // Do these if the projection is circular
    //  m_longitude = To360Domain (m_longitude);
    //  if (m_longitudeDomain == 180) m_longitude = To180Domain(m_longitude);

    m_good = true;
    return m_good;
  }

  bool SimpleCylindrical::XYRange(double &minX, double &maxX,
                                  double &minY, double &maxY) {
    // Check the corners of the lat/lon range
    XYRangeCheck(m_minimumLatitude, m_minimumLongitude);
    XYRangeCheck(m_maximumLatitude, m_minimumLongitude);
    XYRangeCheck(m_minimumLatitude, m_maximumLongitude);
    XYRangeCheck(m_maximumLatitude, m_maximumLongitude);

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


  PvlGroup SimpleCylindrical::Mapping() {
    PvlGroup mapping = Projection::Mapping();

    mapping += m_mappingGrp["CenterLongitude"];

    return mapping;
  }

  PvlGroup SimpleCylindrical::MappingLatitudes() {
    PvlGroup mapping = Projection::MappingLatitudes();

    return mapping;
  }

  PvlGroup SimpleCylindrical::MappingLongitudes() {
    PvlGroup mapping = Projection::MappingLongitudes();

    mapping += m_mappingGrp["CenterLongitude"];

    return mapping;
  }

} // end namespace isis

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