Image.cpp

#include "Image.h"
 
#include <QBuffer>
#include <QDataStream>
#include <QDebug>
#include <QDir>
#include <QFileInfo>
#include <QMutexLocker>
#include <QScopedPointer>
#include <QString>
#include <QUuid>
#include <QXmlStreamWriter>
 
#include <geos/geom/MultiPolygon.h>
#include <geos/io/WKTReader.h>
#include <geos/io/WKTWriter.h>
 
#include "Angle.h"
#include "Cube.h"
#include "CubeAttribute.h"
#include "DisplayProperties.h"
#include "Distance.h"
#include "FileName.h"
#include "ImageDisplayProperties.h"
#include "ImagePolygon.h"
#include "IString.h"
#include "ObservationNumber.h"
#include "PolygonTools.h"
#include "Project.h"
#include "SerialNumber.h"
#include "Target.h"
#include "XmlStackedHandlerReader.h"
 
 
namespace Isis {
 
  Image::Image(QString imageFileName, QObject *parent) : QObject(parent) {
    m_bodyCode = NULL;
    m_cube = NULL;
    m_displayProperties = NULL;
    m_footprint = NULL;
    m_id = NULL;
 
    m_aspectRatio = Null;
    m_resolution = Null;
    m_lineResolution = Null;
    m_sampleResolution = Null;
 
    m_fileName = imageFileName;
 
    cube();
 
    initCamStats();
 
    try {
      initQuickFootprint();
    }
    catch (IException &) {
    }
 
    m_displayProperties = new ImageDisplayProperties(FileName(m_fileName).name(), this);
 
    m_id = new QUuid(QUuid::createUuid());
  }
 
 
  Image::Image(Cube *imageCube, QObject *parent) : QObject(parent) {
    m_fileName = imageCube->fileName();
 
    m_bodyCode = NULL;
    m_cube = imageCube;
    m_displayProperties = NULL;
    m_footprint = NULL;
    m_id = NULL;
 
    m_aspectRatio = Null;
    m_resolution = Null;
    m_lineResolution = Null;
    m_sampleResolution = Null;
 
    initCamStats();
 
    try {
      initQuickFootprint();
    }
    catch (IException &e) {
    }
 
    m_displayProperties = new ImageDisplayProperties(FileName(m_fileName).name(), this);
 
    m_id = new QUuid(QUuid::createUuid());
  }
 
 
  Image::Image(Cube *imageCube, geos::geom::MultiPolygon *footprint, QString id, QObject *parent) :
      QObject(parent) {
    m_fileName = imageCube->fileName();
 
    m_bodyCode = NULL;
    m_cube = imageCube;
    m_displayProperties = NULL;
    m_id = NULL;
 
    m_aspectRatio = Null;
    m_resolution = Null;
    m_lineResolution = Null;
    m_sampleResolution = Null;
 
    initCamStats();
 
    m_footprint = footprint;
 
    m_displayProperties = new ImageDisplayProperties(FileName(m_fileName).name(), this);
 
    setId(id);
  }
 
 
  Image::Image(FileName imageFolder, XmlStackedHandlerReader *xmlReader, QObject *parent) :
      QObject(parent) {
    m_bodyCode = NULL;
    m_cube = NULL;
    m_displayProperties = NULL;
    m_footprint = NULL;
    m_id = NULL;
 
    m_aspectRatio = Null;
    m_resolution = Null;
    m_lineResolution = Null;
    m_sampleResolution = Null;
 
    xmlReader->pushContentHandler(new XmlHandler(this, imageFolder));
  }
 
 
  Image::~Image() {
    delete m_bodyCode;
    m_bodyCode = NULL;
 
    delete m_cube;
    m_cube = NULL;
 
    delete m_footprint;
    m_footprint = NULL;
 
    delete m_id;
    m_id = NULL;
 
    //  Image is a "Qt" parent of display properties, so the Image QObject
    //  destructor will take care of deleting the display props. See call to
    //  DisplayProperties' constructor.
    m_displayProperties = NULL;
  }
 
 
  void Image::fromPvl(const PvlObject &pvl) {
    QString pvlFileName = ((IString)pvl["FileName"][0]).ToQt();
    if (m_fileName != pvlFileName) {
      throw IException(IException::Unknown,
          tr("Tried to load Image [%1] with properties/information from [%2].")
            .arg(m_fileName).arg(pvlFileName),
          _FILEINFO_);
    }
 
    displayProperties()->fromPvl(pvl.findObject("DisplayProperties"));
 
    if (pvl.hasKeyword("ID")) {
      QByteArray hexValues(pvl["ID"][0].toLatin1());
      QDataStream valuesStream(QByteArray::fromHex(hexValues));
      valuesStream >> *m_id;
    }
  }
 
 
  PvlObject Image::toPvl() const {
    PvlObject output("Image");
 
    output += PvlKeyword("FileName", m_fileName);
 
    // Do m_id
    QBuffer dataBuffer;
    dataBuffer.open(QIODevice::ReadWrite);
 
    QDataStream idStream(&dataBuffer);
    idStream << *m_id;
 
    dataBuffer.seek(0);
 
    output += PvlKeyword("ID", QString(dataBuffer.data().toHex()));
 
    output += displayProperties()->toPvl();
 
    return output;
  }
 
 
  bool Image::isFootprintable() const {
    bool result = false;
 
    if (m_footprint) {
      result = true;
    }
 
    if (!result && m_cube) {
      Blob example = ImagePolygon().toBlob();
 
      QString blobType = example.Type();
      QString blobName = example.Name();
 
      Pvl &labels = *m_cube->label();
 
      for (int i = 0; i < labels.objects(); i++) {
        PvlObject &obj = labels.object(i);
 
        if (obj.isNamed(blobType) && obj.hasKeyword("Name") && obj["Name"][0] == blobName)
          result = true;
      }
    }
 
    return result;
  }
 
 
  Cube *Image::cube() {
    if (!m_cube) {
      try {
        m_cube = new Cube(m_fileName);
      }
      catch (IException &e) {
        throw IException(e, IException::Programmer, "Cube cannot be created", _FILEINFO_);
      }
    }
 
    return m_cube;
  }
 
 
  void Image::closeCube() {
    if (m_cube) {
      delete m_cube;
      m_cube = NULL;
    }
  }
 
 
  ImageDisplayProperties *Image::displayProperties() {
    return m_displayProperties;
  }
 
 
  const ImageDisplayProperties *Image::displayProperties() const {
    return m_displayProperties;
  }
 
 
  QString Image::fileName() const {
    return m_fileName;
  }
 
 
  QString Image::observationNumber() {
    if (m_observationNumber.isEmpty()) {
      m_observationNumber = ObservationNumber::Compose(*(cube()));
    }
    return m_observationNumber;
  }
 
 
  QString Image::serialNumber() {
    if (m_serialNumber.isEmpty()) {
      m_serialNumber = SerialNumber::Compose(*(cube()));
    }
    return m_serialNumber;
  }
 
 
  geos::geom::MultiPolygon *Image::footprint() {
    return m_footprint;
  }
 
 
  void Image::setId(QString id) {
    m_id = new QUuid(id);
  }
 
 
  const geos::geom::MultiPolygon *Image::footprint() const {
    return m_footprint;
  }
 
 
  bool Image::initFootprint(QMutex *cameraMutex) {
    if (!m_footprint) {
      try {
        initQuickFootprint();
      }
      catch (IException &e) {
        try {
          m_footprint = createFootprint(cameraMutex);
        }
        catch (IException &e) {
          IString msg = "Could not read the footprint from cube [" +
              displayProperties()->displayName() + "]. Please make "
              "sure footprintinit has been run";
          throw IException(e, IException::Io, msg, _FILEINFO_);
        }
      }
    }
 
    // I'm not sure how this could ever be NULL. -SL
    return (m_footprint != NULL);
  }
 
 
  double Image::aspectRatio() const {
    return m_aspectRatio;
  }
 
 
  QString Image::id() const {
    return m_id->toString().remove(QRegExp("[{}]"));
  }
 
 
  double Image::resolution() const {
    return m_resolution;
  }
 
 
  Angle Image::emissionAngle() const {
    return m_emissionAngle;
  }
 
 
  Angle Image::incidenceAngle() const {
    return m_incidenceAngle;
  }
 
 
  double Image::lineResolution() const {
    return m_lineResolution;
  }
 
 
  Distance Image::localRadius() const {
    return m_localRadius;
  }
 
 
  Angle Image::northAzimuth() const {
    return m_northAzimuth;
  }
 
 
  Angle Image::phaseAngle() const {
    return m_phaseAngle;
  }
 
 
  double Image::sampleResolution() const {
    return m_sampleResolution;
  }
 
 
  void Image::copyToNewProjectRoot(const Project *project, FileName newProjectRoot) {
    if (FileName(newProjectRoot) != FileName(project->projectRoot())) {
      Cube origImage(m_fileName);
 
      // The imageDataRoot will either be PROJECTROOT/images or PROJECTROOT/results/bundle/timestamp/images,
      // depending on how the newProjectRoot points to.
      FileName newExternalLabelFileName(Project::imageDataRoot(newProjectRoot.toString()) + "/" +
          FileName(m_fileName).dir().dirName() + "/" + FileName(m_fileName).name());
 
      if (m_fileName != newExternalLabelFileName.toString()) {
        // This cube copy creates a filename w/ecub extension in the new project root, but looks to
        // be a cube(internal vs external). It changes the DnFile pointer to the old ecub,
        // /tmp/tsucharski_ipce/tmpProject/images/import1/AS15-.ecub, but doing a less on file
        // immediately after the following call indicates it is a binary file.
        QScopedPointer<Cube> newExternalLabel(
            origImage.copy(newExternalLabelFileName, CubeAttributeOutput("+External")));
 
        // If this is an ecub (it should be) and is pointing to a relative file name,
        //   then we want to copy the DN cube also.
        if (!origImage.storesDnData() ) {
          if (origImage.externalCubeFileName().path() == ".") {
            Cube dnFile(
                FileName(m_fileName).path() + "/" + origImage.externalCubeFileName().name());
            FileName newDnFileName = newExternalLabelFileName.setExtension("cub");
            QScopedPointer<Cube> newDnFile(dnFile.copy(newDnFileName, CubeAttributeOutput()));
            newDnFile->close();
            // Changes the ecube's DnFile pointer in the labels.
            newExternalLabel->relocateDnData(newDnFileName.name());
          }
          else {
            //  If the the ecub's external cube is pointing to the old project root, update to new
            //  project root.
            if (origImage.externalCubeFileName().toString().contains(project->projectRoot())) {
              QString newExternalCubeFileName = origImage.externalCubeFileName().toString();
              newExternalCubeFileName.replace(project->projectRoot(), project->newProjectRoot());
              newExternalLabel->relocateDnData(newExternalCubeFileName);
            }
            else {
              newExternalLabel->relocateDnData(origImage.externalCubeFileName());
            }
          }
        }
      }
    }
  }
 
 
  void Image::deleteFromDisk() {
    bool deleteCubAlso = (cube()->externalCubeFileName().path() == ".");
    closeCube();
 
    if (!QFile::remove(m_fileName)) {
      throw IException(IException::Io,
                       tr("Could not remove file [%1]").arg(m_fileName),
                       _FILEINFO_);
    }
 
    if (deleteCubAlso) {
      FileName cubFile = FileName(m_fileName).setExtension("cub");
      if (!QFile::remove(cubFile.expanded() ) ) {
        throw IException(IException::Io,
                         tr("Could not remove file [%1]").arg(m_fileName),
                         _FILEINFO_);
      }
    }
 
    // If we're the last thing in the folder, remove the folder too.
    QDir dir;
    dir.rmdir(FileName(m_fileName).path());
  }
 
 
  void Image::save(QXmlStreamWriter &stream, const Project *project, FileName newProjectRoot)
      const {
    stream.writeStartElement("image");
 
    stream.writeAttribute("id", m_id->toString());
    stream.writeAttribute("fileName", FileName(m_fileName).name());
    stream.writeAttribute("instrumentId", m_instrumentId);
    stream.writeAttribute("spacecraftName", m_spacecraftName);
 
    if (!IsSpecial(m_aspectRatio) ) {
      stream.writeAttribute("aspectRatio", IString(m_aspectRatio).ToQt());
    }
 
    if (!IsSpecial(m_resolution) ) {
      stream.writeAttribute("resolution", IString(m_resolution).ToQt());
    }
 
    if (m_emissionAngle.isValid() ) {
      stream.writeAttribute("emissionAngle", IString(m_emissionAngle.radians()).ToQt());
    }
 
    if (m_incidenceAngle.isValid() ) {
      stream.writeAttribute("incidenceAngle", IString(m_incidenceAngle.radians()).ToQt());
    }
 
    if (!IsSpecial(m_lineResolution) ) {
      stream.writeAttribute("lineResolution", IString(m_lineResolution).ToQt());
    }
 
    if (m_localRadius.isValid() ) {
      stream.writeAttribute("localRadius", IString(m_localRadius.meters()).ToQt());
    }
 
    if (m_northAzimuth.isValid() ) {
      stream.writeAttribute("northAzimuth", IString(m_northAzimuth.radians()).ToQt());
    }
 
    if (m_phaseAngle.isValid() ) {
      stream.writeAttribute("phaseAngle", IString(m_phaseAngle.radians()).ToQt());
    }
 
    if (!IsSpecial(m_sampleResolution) ) {
      stream.writeAttribute("sampleResolution", IString(m_sampleResolution).ToQt());
    }
 
    if (m_footprint) {
      stream.writeStartElement("footprint");
 
      geos::io::WKTWriter wktWriter;
      stream.writeCharacters(QString::fromStdString(wktWriter.write(m_footprint)));
 
      stream.writeEndElement();
    }
 
    m_displayProperties->save(stream, project, newProjectRoot);
 
    stream.writeEndElement();
  }
 
 
  void Image::updateFileName(Project *project) {
    closeCube();
 
    FileName original(m_fileName);
    FileName newName(project->imageDataRoot() + "/" +
                     original.dir().dirName() + "/" + original.name());
    m_fileName = newName.expanded();
  }
 
 
  geos::geom::MultiPolygon *Image::createFootprint(QMutex *cameraMutex) {
    QMutexLocker lock(cameraMutex);
 
    // We need to walk the image to create the polygon...
    ImagePolygon imgPoly;
 
    int sampleStepSize = cube()->sampleCount() / 10;
    if (sampleStepSize <= 0) sampleStepSize = 1;
 
    int lineStepSize = cube()->lineCount() / 10;
    if (lineStepSize <= 0) lineStepSize = 1;
 
    imgPoly.Create(*cube(), sampleStepSize, lineStepSize);
 
    IException e = IException(IException::User,
        tr("Warning: Polygon re-calculated for [%1] which can be very slow")
          .arg(displayProperties()->displayName()),
        _FILEINFO_);
    e.print();
 
    return PolygonTools::MakeMultiPolygon(imgPoly.Polys()->clone().release());
  }
 
 
  void Image::initCamStats() {
    bool hasCamStats = false;
 
    Pvl &label = *cube()->label();
    for (int i = 0; !hasCamStats && i < label.objects(); i++) {
      PvlObject &obj = label.object(i);
 
      try {
        if (obj.name() == "Table") {
          if (obj["Name"][0] == "CameraStatistics") {
            hasCamStats = true;
          }
        }
      }
      catch (IException &) {
      }
    }
 
    if (hasCamStats) {
      Table camStatsTable("CameraStatistics", m_fileName, label);
 
      int numRecords = camStatsTable.Records();
      for (int recordIndex = 0; recordIndex < numRecords; recordIndex++) {
        TableRecord &record = camStatsTable[recordIndex];
 
        // The TableField class gives us a std::string with NULL (\0) characters... be careful not
        //   to keep them when going to QString.
        QString recordName((QString)record["Name"]);
        double avgValue = (double)record["Average"];
 
        if (recordName == "AspectRatio") {
          m_aspectRatio = avgValue;
        }
        else if (recordName == "Resolution") {
          m_resolution = avgValue;
        }
        else if (recordName == "EmissionAngle") {
          m_emissionAngle = Angle(avgValue, Angle::Degrees);
        }
        else if (recordName == "IncidenceAngle") {
          m_incidenceAngle = Angle(avgValue, Angle::Degrees);
        }
        else if (recordName == "LineResolution") {
          m_lineResolution = avgValue;
        }
        else if (recordName == "LocalRadius") {
          m_localRadius = Distance(avgValue, Distance::Meters);
        }
        else if (recordName == "NorthAzimuth") {
          m_northAzimuth = Angle(avgValue, Angle::Degrees);
        }
        else if (recordName == "PhaseAngle") {
          m_phaseAngle = Angle(avgValue, Angle::Degrees);
        }
        else if (recordName == "SampleResolution") {
          m_sampleResolution = avgValue;
        }
      }
    }
 
    for (int i = 0; i < label.objects(); i++) {
      PvlObject &obj = label.object(i);
      try {
        if (obj.hasGroup("Instrument")) {
          PvlGroup instGroup = obj.findGroup("Instrument");
 
          if (instGroup.hasKeyword("SpacecraftName"))
            m_spacecraftName = obj.findGroup("Instrument")["SpacecraftName"][0];
 
          if (instGroup.hasKeyword("InstrumentId"))
            m_instrumentId = obj.findGroup("Instrument")["InstrumentId"][0];
        }
      }
      catch (IException &) {
      }
    }
  }
 
 
  void Image::initQuickFootprint() {
    ImagePolygon poly = cube()->readFootprint();
    m_footprint = PolygonTools::MakeMultiPolygon(poly.Polys()->clone().release());
  }
 
 
  Image::XmlHandler::XmlHandler(Image *image, FileName imageFolder) {
    m_image = image;
    m_imageFolder = imageFolder;
  }
 
 
 
  bool Image::XmlHandler::startElement(const QString &namespaceURI, const QString &localName,
                                       const QString &qName, const QXmlAttributes &atts) {
    m_characters = "";
 
    if (XmlStackedHandler::startElement(namespaceURI, localName, qName, atts)) {
      if (localName == "image") {
        QString id = atts.value("id");
        QString fileName = atts.value("fileName");
        QString instrumentId = atts.value("instrumentId");
        QString spacecraftName = atts.value("spacecraftName");
 
        QString aspectRatioStr = atts.value("aspectRatio");
        QString resolutionStr = atts.value("resolution");
        QString emissionAngleStr = atts.value("emissionAngle");
        QString incidenceAngleStr = atts.value("incidenceAngle");
        QString lineResolutionStr = atts.value("lineResolution");
        QString localRadiusStr = atts.value("localRadius");
        QString northAzimuthStr = atts.value("northAzimuth");
        QString phaseAngleStr = atts.value("phaseAngle");
        QString sampleResolutionStr = atts.value("sampleResolution");
 
        if (!id.isEmpty()) {
          delete m_image->m_id;
          m_image->m_id = NULL;
          m_image->m_id = new QUuid(id.toLatin1());
        }
 
        if (!fileName.isEmpty()) {
          m_image->m_fileName = m_imageFolder.expanded() + "/" + fileName;
        }
 
        if (!instrumentId.isEmpty()) {
          m_image->m_instrumentId = instrumentId;
        }
 
        if (!spacecraftName.isEmpty()) {
          m_image->m_spacecraftName = spacecraftName;
        }
 
        if (!aspectRatioStr.isEmpty()) {
          m_image->m_aspectRatio = aspectRatioStr.toDouble();
        }
 
        if (!resolutionStr.isEmpty()) {
          m_image->m_resolution = resolutionStr.toDouble();
        }
 
        if (!emissionAngleStr.isEmpty()) {
          m_image->m_emissionAngle = Angle(emissionAngleStr.toDouble(), Angle::Radians);
        }
 
        if (!incidenceAngleStr.isEmpty()) {
          m_image->m_incidenceAngle = Angle(incidenceAngleStr.toDouble(), Angle::Radians);
        }
 
        if (!lineResolutionStr.isEmpty()) {
          m_image->m_lineResolution = lineResolutionStr.toDouble();
        }
 
        if (!localRadiusStr.isEmpty()) {
          m_image->m_localRadius = Distance(localRadiusStr.toDouble(), Distance::Meters);
        }
 
        if (!northAzimuthStr.isEmpty()) {
          m_image->m_northAzimuth = Angle(northAzimuthStr.toDouble(), Angle::Radians);
        }
 
        if (!phaseAngleStr.isEmpty()) {
          m_image->m_phaseAngle = Angle(phaseAngleStr.toDouble(), Angle::Radians);
        }
 
        if (!sampleResolutionStr.isEmpty()) {
          m_image->m_sampleResolution = sampleResolutionStr.toDouble();
        }
      }
      else if (localName == "displayProperties") {
        m_image->m_displayProperties = new ImageDisplayProperties(reader());
      }
    }
 
    return true;
  }
 
 
  bool Image::XmlHandler::characters(const QString &ch) {
    m_characters += ch;
 
    return XmlStackedHandler::characters(ch);
  }
 
 
  bool Image::XmlHandler::endElement(const QString &namespaceURI, const QString &localName,
                                     const QString &qName) {
    if (localName == "footprint" && !m_characters.isEmpty()) {
      geos::io::WKTReader wktReader(*globalFactory);
      m_image->m_footprint = PolygonTools::MakeMultiPolygon(
          wktReader.read(m_characters.toStdString()).release());
    }
    else if (localName == "image" && !m_image->m_footprint) {
      QMutex mutex;
      m_image->initFootprint(&mutex);
      m_image->closeCube();
    }
 
    m_characters = "";
    return XmlStackedHandler::endElement(namespaceURI, localName, qName);
  }
}