Image.cpp

#include "Image.h"

#include <QBuffer>
#include <QDataStream>
#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 "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(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) {
      // TODO: Move this to Blob!
      ImagePolygon example;

      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::serialNumber() {
    return SerialNumber::Compose(*(cube()));
  }


  geos::geom::MultiPolygon *Image::footprint() {
    return m_footprint;
  }


  void Image::setId(QString id) {
    *m_id = QUuid(QString("{%1}").arg(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);

      FileName newExternalLabelFileName(Project::imageDataRoot(newProjectRoot.toString()) + "/" +
          FileName(m_fileName).dir().dirName() + "/" + FileName(m_fileName).name());

      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();
          newExternalLabel->relocateDnData(newDnFileName.name());
        }
        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());
  }


  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()->read(poly);
    m_footprint = PolygonTools::MakeMultiPolygon(poly.Polys()->clone());
  }


  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 = m_imageFolder.expanded() + "/" + instrumentId;
        }

        if (!spacecraftName.isEmpty()) {
          m_image->m_spacecraftName = m_imageFolder.expanded() + "/" + 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()));
    }
    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);
  }
}