CameraPointInfo.cpp

Go to the documentation of this file.

#include "CameraPointInfo.h"

#include "Brick.h"
#include "Camera.h"
#include "CubeManager.h"
#include "Distance.h"
#include "IException.h"
#include "iTime.h"
#include "Longitude.h"
#include "Projection.h"
#include "PvlGroup.h"

using namespace std;

namespace Isis {


  CameraPointInfo::CameraPointInfo() {
    usedCubes = NULL;
    usedCubes = new CubeManager();
    usedCubes->SetNumOpenCubes(50);
    currentCube = NULL;
    camera = NULL;
  }

  CameraPointInfo::~CameraPointInfo() {
    if(usedCubes) {
      delete usedCubes;
      usedCubes = NULL;
    }
  }


  void CameraPointInfo::SetCube(const QString &cubeFileName) {
    currentCube = usedCubes->OpenCube(cubeFileName);
    camera = currentCube->camera();
  }


  PvlGroup *CameraPointInfo::SetImage(const double sample, const double line,
                                      const bool outside, const bool errors) {
    if(CheckCube()) {
      bool passed = camera->SetImage(sample, line);
      return GetPointInfo(passed, outside, errors);
    }
    // Should never get here, error will be thrown in CheckCube()
    return NULL;
  }

  PvlGroup *CameraPointInfo::SetCenter(const bool outside, const bool errors) {
    if(CheckCube()) {
      bool passed = camera->SetImage(currentCube->sampleCount() / 2.0, currentCube->lineCount() / 2.0);
      return GetPointInfo(passed, outside, errors);
    }
    // Should never get here, error will be thrown in CheckCube()
    return NULL;
  }


  PvlGroup *CameraPointInfo::SetSample(const double sample,
                                       const bool outside, const bool errors) {
    if(CheckCube()) {
      bool passed = camera->SetImage(sample, currentCube->lineCount() / 2.0);
      return GetPointInfo(passed, outside, errors);
    }
    // Should never get here, error will be thrown in CheckCube()
    return NULL;
  }


  PvlGroup *CameraPointInfo::SetLine(const double line,
                                     const bool outside, const bool errors) {
    if(CheckCube()) {
      bool passed = camera->SetImage(currentCube->sampleCount() / 2.0, line);
      return GetPointInfo(passed, outside, errors);
    }
    // Should never get here, error will be thrown in CheckCube()
    return NULL;
  }


  PvlGroup *CameraPointInfo::SetGround(const double latitude, const double longitude,
                                       const bool outside, const bool errors) {
    if(CheckCube()) {
      bool passed = camera->SetUniversalGround(latitude, longitude);
      return GetPointInfo(passed, outside, errors);
    }
    // Should never get here, error will be thrown in CheckCube()
    return NULL;
  }


  bool CameraPointInfo::CheckCube() {
    if(currentCube == NULL) {
      string msg = "Please set a cube before setting parameters";
      throw IException(IException::Programmer, msg, _FILEINFO_);
      return false;
    }
    return true;
  }

  PvlGroup *CameraPointInfo::GetPointInfo(bool passed, bool allowOutside, bool allowErrors) {
    PvlGroup *gp = new PvlGroup("GroundPoint");
    {
      gp->AddKeyword(PvlKeyword("Filename"));
      gp->AddKeyword(PvlKeyword("Sample"));
      gp->AddKeyword(PvlKeyword("Line"));
      gp->AddKeyword(PvlKeyword("PixelValue"));
      gp->AddKeyword(PvlKeyword("RightAscension"));
      gp->AddKeyword(PvlKeyword("Declination"));
      gp->AddKeyword(PvlKeyword("PlanetocentricLatitude"));
      gp->AddKeyword(PvlKeyword("PlanetographicLatitude"));
      gp->AddKeyword(PvlKeyword("PositiveEast360Longitude"));
      gp->AddKeyword(PvlKeyword("PositiveEast180Longitude"));
      gp->AddKeyword(PvlKeyword("PositiveWest360Longitude"));
      gp->AddKeyword(PvlKeyword("PositiveWest180Longitude"));
      gp->AddKeyword(PvlKeyword("BodyFixedCoordinate"));
      gp->AddKeyword(PvlKeyword("LocalRadius"));
      gp->AddKeyword(PvlKeyword("SampleResolution"));
      gp->AddKeyword(PvlKeyword("LineResolution"));
      gp->AddKeyword(PvlKeyword("SpacecraftPosition"));
      gp->AddKeyword(PvlKeyword("SpacecraftAzimuth"));
      gp->AddKeyword(PvlKeyword("SlantDistance"));
      gp->AddKeyword(PvlKeyword("TargetCenterDistance"));
      gp->AddKeyword(PvlKeyword("SubSpacecraftLatitude"));
      gp->AddKeyword(PvlKeyword("SubSpacecraftLongitude"));
      gp->AddKeyword(PvlKeyword("SpacecraftAltitude"));
      gp->AddKeyword(PvlKeyword("OffNadirAngle"));
      gp->AddKeyword(PvlKeyword("SubSpacecraftGroundAzimuth"));
      gp->AddKeyword(PvlKeyword("SunPosition"));
      gp->AddKeyword(PvlKeyword("SubSolarAzimuth"));
      gp->AddKeyword(PvlKeyword("SolarDistance"));
      gp->AddKeyword(PvlKeyword("SubSolarLatitude"));
      gp->AddKeyword(PvlKeyword("SubSolarLongitude"));
      gp->AddKeyword(PvlKeyword("SubSolarGroundAzimuth"));
      gp->AddKeyword(PvlKeyword("Phase"));
      gp->AddKeyword(PvlKeyword("Incidence"));
      gp->AddKeyword(PvlKeyword("Emission"));
      gp->AddKeyword(PvlKeyword("NorthAzimuth"));
      gp->AddKeyword(PvlKeyword("EphemerisTime"));
      gp->AddKeyword(PvlKeyword("UTC"));
      gp->AddKeyword(PvlKeyword("LocalSolarTime"));
      gp->AddKeyword(PvlKeyword("SolarLongitude"));
      if(allowErrors) gp->AddKeyword(PvlKeyword("Error"));
    }

    bool noErrors = passed;
    QString error = "";
    if(!camera->HasSurfaceIntersection()) {
      error = "Requested position does not project in camera model; no surface intersection";
      noErrors = false;
      if(!allowErrors) throw IException(IException::Unknown, error, _FILEINFO_);
    }
    if(!camera->InCube() && !allowOutside) {
      error = "Requested position does not project in camera model; not inside cube";
      noErrors = false;
      if(!allowErrors) throw IException(IException::Unknown, error, _FILEINFO_);
    }

    if(!noErrors) {
      for(int i = 0; i < gp->Keywords(); i++) {
        QString name = (*gp)[i].Name();
        // These three keywords have 3 values, so they must have 3 N/As
        if(name == "BodyFixedCoordinate" || name == "SpacecraftPosition" ||
            name == "SunPosition") {
          (*gp)[i].AddValue("N/A");
          (*gp)[i].AddValue("N/A");
          (*gp)[i].AddValue("N/A");
        }
        else {
          (*gp)[i].SetValue("N/A");
        }
      }
      // Set all keywords that still have valid information
      gp->FindKeyword("Error").SetValue(error);
      gp->FindKeyword("FileName").SetValue(currentCube->fileName());
      gp->FindKeyword("Sample").SetValue(toString(camera->Sample()));
      gp->FindKeyword("Line").SetValue(toString(camera->Line()));
      gp->FindKeyword("EphemerisTime").SetValue(toString(camera->time().Et()), "seconds");
      gp->FindKeyword("EphemerisTime").AddComment("Time");
      QString utc = camera->time().UTC();
      gp->FindKeyword("UTC").SetValue(utc);
      gp->FindKeyword("SpacecraftPosition").AddComment("Spacecraft Information");
      gp->FindKeyword("SunPosition").AddComment("Sun Information");
      gp->FindKeyword("Phase").AddComment("Illumination and Other");
    }

    else {

      Brick b(3, 3, 1, currentCube->pixelType());

      int intSamp = (int)(camera->Sample() + 0.5);
      int intLine = (int)(camera->Line() + 0.5);
      b.SetBasePosition(intSamp, intLine, 1);
      currentCube->read(b);

      double pB[3], spB[3], sB[3];
      QString utc;
      double ssplat, ssplon, sslat, sslon, pwlon, oglat;

      {
        gp->FindKeyword("FileName").SetValue(currentCube->fileName());
        gp->FindKeyword("Sample").SetValue(toString(camera->Sample()));
        gp->FindKeyword("Line").SetValue(toString(camera->Line()));
        gp->FindKeyword("PixelValue").SetValue(PixelToString(b[0]));
        gp->FindKeyword("RightAscension").SetValue(toString(camera->RightAscension()));
        gp->FindKeyword("Declination").SetValue(toString(camera->Declination()));
        gp->FindKeyword("PlanetocentricLatitude").SetValue(toString(camera->UniversalLatitude()));

        // Convert lat to planetographic
        Distance radii[3];
        camera->radii(radii);
        oglat = Isis::Projection::ToPlanetographic(camera->UniversalLatitude(),
                radii[0].kilometers(), radii[2].kilometers());
        gp->FindKeyword("PlanetographicLatitude").SetValue(toString(oglat));

        gp->FindKeyword("PositiveEast360Longitude").SetValue(toString(
          camera->UniversalLongitude()));

        //Convert lon to -180 - 180 range
        gp->FindKeyword("PositiveEast180Longitude").SetValue(toString(
          Isis::Projection::To180Domain(
            camera->UniversalLongitude())));

        //Convert lon to positive west
        pwlon = Isis::Projection::ToPositiveWest(camera->UniversalLongitude(),
                360);
        gp->FindKeyword("PositiveWest360Longitude").SetValue(toString(pwlon));

        //Convert pwlon to -180 - 180 range
        gp->FindKeyword("PositiveWest180Longitude").SetValue(toString(
          Isis::Projection::To180Domain(pwlon)));

        camera->Coordinate(pB);
        gp->FindKeyword("BodyFixedCoordinate").AddValue(toString(pB[0]), "km");
        gp->FindKeyword("BodyFixedCoordinate").AddValue(toString(pB[1]), "km");
        gp->FindKeyword("BodyFixedCoordinate").AddValue(toString(pB[2]), "km");

        gp->FindKeyword("LocalRadius").SetValue(toString(camera->LocalRadius().meters()), "meters");
        gp->FindKeyword("SampleResolution").SetValue(toString(camera->SampleResolution()), "meters/pixel");
        gp->FindKeyword("LineResolution").SetValue(toString(camera->LineResolution()), "meters/pixel");

        camera->instrumentPosition(spB);
        gp->FindKeyword("SpacecraftPosition").AddValue(toString(spB[0]), "km");
        gp->FindKeyword("SpacecraftPosition").AddValue(toString(spB[1]), "km");
        gp->FindKeyword("SpacecraftPosition").AddValue(toString(spB[2]), "km");
        gp->FindKeyword("SpacecraftPosition").AddComment("Spacecraft Information");

        gp->FindKeyword("SpacecraftAzimuth").SetValue(toString(camera->SpacecraftAzimuth()));
        gp->FindKeyword("SlantDistance").SetValue(toString(camera->SlantDistance()), "km");
        gp->FindKeyword("TargetCenterDistance").SetValue(toString(camera->targetCenterDistance()), "km");
        camera->subSpacecraftPoint(ssplat, ssplon);
        gp->FindKeyword("SubSpacecraftLatitude").SetValue(toString(ssplat));
        gp->FindKeyword("SubSpacecraftLongitude").SetValue(toString(ssplon));
        gp->FindKeyword("SpacecraftAltitude").SetValue(toString(camera->SpacecraftAltitude()), "km");
        gp->FindKeyword("OffNadirAngle").SetValue(toString(camera->OffNadirAngle()));
        double subspcgrdaz;
        subspcgrdaz = camera->GroundAzimuth(camera->UniversalLatitude(), camera->UniversalLongitude(),
                                            ssplat, ssplon);
        gp->FindKeyword("SubSpacecraftGroundAzimuth").SetValue(toString(subspcgrdaz));

        camera->sunPosition(sB);
        gp->FindKeyword("SunPosition").AddValue(toString(sB[0]), "km");
        gp->FindKeyword("SunPosition").AddValue(toString(sB[1]), "km");
        gp->FindKeyword("SunPosition").AddValue(toString(sB[2]), "km");
        gp->FindKeyword("SunPosition").AddComment("Sun Information");

        gp->FindKeyword("SubSolarAzimuth").SetValue(toString(camera->SunAzimuth()));
        gp->FindKeyword("SolarDistance").SetValue(toString(camera->SolarDistance()), "AU");
        camera->subSolarPoint(sslat, sslon);
        gp->FindKeyword("SubSolarLatitude").SetValue(toString(sslat));
        gp->FindKeyword("SubSolarLongitude").SetValue(toString(sslon));
        double subsolgrdaz;
        subsolgrdaz = camera->GroundAzimuth(camera->UniversalLatitude(), camera->UniversalLongitude(),
                                            sslat, sslon);
        gp->FindKeyword("SubSolarGroundAzimuth").SetValue(toString(subsolgrdaz));

        gp->FindKeyword("Phase").SetValue(toString(camera->PhaseAngle()));
        gp->FindKeyword("Phase").AddComment("Illumination and Other");
        gp->FindKeyword("Incidence").SetValue(toString(camera->IncidenceAngle()));
        gp->FindKeyword("Emission").SetValue(toString(camera->EmissionAngle()));
        gp->FindKeyword("NorthAzimuth").SetValue(toString(camera->NorthAzimuth()));

        gp->FindKeyword("EphemerisTime").SetValue(toString(camera->time().Et()), "seconds");
        gp->FindKeyword("EphemerisTime").AddComment("Time");
        utc = camera->time().UTC();
        gp->FindKeyword("UTC").SetValue(utc);
        gp->FindKeyword("LocalSolarTime").SetValue(toString(camera->LocalSolarTime()), "hour");
        gp->FindKeyword("SolarLongitude").SetValue(toString(camera->solarLongitude().degrees()));
        if(allowErrors) gp->FindKeyword("Error").SetValue("N/A");
      }
    }
    return gp;
  }
}