Cube.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "Cube.h"
 
#include <sstream>
#include <unistd.h>
 
#include <QDebug>
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QMutex>
 
#include "Application.h"
#include "Blob.h"
#include "Camera.h"
#include "CameraFactory.h"
#include "CubeAttribute.h"
#include "CubeBsqHandler.h"
#include "CubeTileHandler.h"
#include "CubeStretch.h"
#include "Endian.h"
#include "FileName.h"
#include "History.h"
#include "ImageHistogram.h"
#include "ImagePolygon.h"
#include "IException.h"
#include "LineManager.h"
#include "Message.h"
#include "OriginalLabel.h"
#include "OriginalXmlLabel.h"
#include "Preference.h"
#include "ProgramLauncher.h"
#include "Projection.h"
#include "SpecialPixel.h"
#include "Statistics.h"
#include "Table.h"
#include "TProjection.h"
#include "Longitude.h"
 
 
using namespace std;
 
namespace Isis {
  Cube::Cube() {
    construct();
  }
  Cube::Cube() {…}

  Cube::Cube(const FileName &fileName, QString access) {
    construct();
    open(fileName.toString(), access);
  }
  Cube::Cube(const FileName &fileName, QString access) {…}

  void Cube::fromLabel(const FileName &fileName, Pvl &label, QString access) {
    initCoreFromLabel(label);
    create(fileName.expanded());
 
    PvlObject cubeLabel = label.findObject("IsisCube");
    for (auto grpIt = cubeLabel.beginGroup(); grpIt!= cubeLabel.endGroup(); grpIt++) {
      putGroup(*grpIt);
    }
 
    close();
    open(fileName.toString(), access);
  }
  void Cube::fromLabel(const FileName &fileName, Pvl &label, QString access) {…}

  void Cube::fromIsd(const FileName &fileName, Pvl &label, nlohmann::json &isd, QString access) {
    fromLabel(fileName, label, access);
 
    PvlGroup &instGrp = label.findGroup("Instrument", Pvl::Traverse);
    if (isd.contains("line_scan_rate") && (QString)instGrp["InstrumentId"] == "HRSC") {
      attachLineScanTableFromIsd(isd);
    }
    
    attachSpiceFromIsd(isd);
 
    close();
    open(fileName.toString(), access);
  }
  void Cube::fromIsd(const FileName &fileName, Pvl &label, nlohmann::json &isd, QString access) {…}

  void Cube::fromIsd(const FileName &fileName, FileName &labelFile, FileName &isdFile, QString access) {
    std::ifstream isdStream(isdFile.expanded().toStdString());
    std::ifstream labelStream(labelFile.expanded().toStdString());
 
    if (isdStream.fail()) {
      QString msg = QString("failed to open isd stream: %1").arg(isdFile.expanded());
      throw IException(IException::Io, msg,
                 isdFile.baseName().toStdString().c_str(), 153);
    }
 
    if (labelStream.fail()) {
      QString msg = "failed to open file stream";
      throw IException(IException::Io, msg,
                 fileName.baseName().toStdString().c_str(), 153);
    }
 
    Pvl label;
    nlohmann::json isd;
 
    try {
      labelStream >> label;
    }
    catch (std::exception &ex) {
      QString msg = QString("Failed to open label file, %1, %2").arg(labelFile.expanded()).arg(ex.what());
      throw IException(IException::Io, msg,
                 fileName.baseName().toStdString().c_str(), 153);
    }
 
 
    try {
      isdStream >> isd;
    }
    catch (std::exception &ex) {
      QString msg = QString("Failed to open ISD file, %1, %2").arg(isdFile.expanded()).arg(ex.what());
      throw IException(IException::Io, msg,
                 fileName.baseName().toStdString().c_str(), 145);
    }
 
    fromIsd(fileName, label, isd, access);
    reopen("rw");
  }
  void Cube::fromIsd(const FileName &fileName, FileName &labelFile, FileName &isdFile, QString access) {…}

  Cube::~Cube() {
    close();
 
    delete m_mutex;
    m_mutex = NULL;
 
    delete m_camera;
    m_camera = NULL;
 
 
    delete m_projection;
    m_projection = NULL;
 
    delete m_formatTemplateFile;
    m_formatTemplateFile = NULL;
  }
  Cube::~Cube() {…}
 

  bool Cube::isOpen() const {
    bool open = (m_ioHandler != NULL);
 
    return open;
  }
  bool Cube::isOpen() const  {…}
 

  bool Cube::isProjected() const {
    return label()->findObject("IsisCube").hasGroup("Mapping");
  }
  bool Cube::isProjected() const  {…}
 

  bool Cube::isReadOnly() const {
    bool readOnly = false;
 
    if (!isOpen()) {
      QString msg = "No cube opened";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    if ((m_labelFile->openMode() & QIODevice::ReadWrite) != QIODevice::ReadWrite)
      readOnly = true;
 
    return readOnly;
  }
  bool Cube::isReadOnly() const  {…}
 

  bool Cube::isReadWrite() const {
    return !isReadOnly();
  }
  bool Cube::isReadWrite() const  {…}
 

  bool Cube::labelsAttached() const {
    return m_attached;
  }
  bool Cube::labelsAttached() const  {…}
 

  void Cube::close(bool removeIt) {
    if (isOpen() && isReadWrite())
      writeLabels();
 
    cleanUp(removeIt);
  }
  void Cube::close(bool removeIt) {…}
 

  Cube *Cube::copy(FileName newFile, const CubeAttributeOutput &newFileAttributes) {
    if (!isOpen()) {
      throw IException(IException::Unknown,
                       QObject::tr("Cube::copy requires the originating cube to be open"),
                       _FILEINFO_);
    }
 
 
    Cube *result = new Cube;
 
    if (newFileAttributes.labelAttachment() != ExternalLabel) {
      result->setDimensions(sampleCount(), lineCount(), bandCount());
      result->setByteOrder(newFileAttributes.byteOrder());
      result->setFormat(newFileAttributes.fileFormat());
 
      if (newFileAttributes.labelAttachment() == DetachedLabel) {
        result->setLabelsAttached(false);
      }
 
      if (newFileAttributes.propagatePixelType()) {
        result->setPixelType(pixelType());
      }
      else {
        result->setPixelType(newFileAttributes.pixelType());
      }
 
      if (newFileAttributes.propagateMinimumMaximum()) {
        if(result->pixelType() == Isis::Real) {
          result->setBaseMultiplier(0.0, 1.0);
        }
        else if(result->pixelType() >= pixelType()) {
          result->setBaseMultiplier(base(), multiplier());
        }
        else {
          QString msg =
              QObject::tr("Cannot reduce the output PixelType for [%1] from [%2] without output "
                          "pixel range").arg(newFile.original()).arg(fileName());
          throw IException(IException::User, msg, _FILEINFO_);
        }
      }
      else {
        // Not propagating so either the user entered or the programmer did
        result->setMinMax(newFileAttributes.minimum(), newFileAttributes.maximum());
      }
 
      result->setLabelSize(labelSize(true) + (1024 * 6));
    }
    else {
      if (isReadWrite()) {
        writeLabels();
        m_ioHandler->clearCache(true);
      }
 
      result->setExternalDnData(fileName());
    }
 
    // Allocate the cube
    result->create(newFile.expanded());
 
    PvlObject &isisCube = label()->findObject("IsisCube");
    PvlObject &outIsisCube = result->label()->findObject("IsisCube");
    for(int i = 0; i < isisCube.groups(); i++) {
      outIsisCube.addGroup(isisCube.group(i));
    }
 
    if (label()->hasObject("NaifKeywords")) {
      result->label()->addObject(
          label()->findObject("NaifKeywords"));
    }
 
    for (int i = 0; i < m_label->objects(); i++) {
      PvlObject &obj = m_label->object(i);
      if (obj.isNamed("Table") || obj.isNamed("Polygon") || obj.isNamed("OriginalLabel") ||
          obj.isNamed("History")) {
        Isis::Blob t((QString)obj["Name"], obj.name());
        read(t);
        result->write(t);
      }
    }
 
    if (newFileAttributes.labelAttachment() != ExternalLabel) {
      BufferManager input(sampleCount(), lineCount(), bandCount(),
                          sampleCount(), 1,              1,
                          pixelType());
      BufferManager output(sampleCount(), lineCount(), bandCount(),
                           sampleCount(), 1,              1,
                           result->pixelType());
 
      input.begin();
      output.begin();
 
      while (!input.end()) {
        read(input);
        output.Copy(input, false);
 
        result->write(output);
 
        input.next();
        output.next();
      }
    }
 
//   Just in case the orig label doesn't work... here's original code:
//       if((p_propagateOriginalLabel) && (InputCubes.size() > 0)) {
//         Isis::Pvl &inlab = *InputCubes[0]->label();
//         for(int i = 0; i < inlab.objects(); i++) {
//           if(inlab.Object(i).isNamed("OriginalLabel")) {
//             Isis::OriginalLabel ol;
//             InputCubes[0]->read(ol);
//             cube->write(ol);
//           }
//         }
//       }
 
    return result;
  }
  Cube *Cube::copy(FileName newFile, const CubeAttributeOutput &newFileAttributes) {…}
 

  void Cube::create(const QString &cubeFileName) {
    // Already opened?
    if (isOpen()) {
      string msg = "You already have a cube opened";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    if (m_samples < 1 || m_lines < 1 || m_bands < 1) {
      QString msg = "Number of samples [" + toString(m_samples) +
          "], lines [" + toString(m_lines) + "], or bands [" + toString(m_bands) +
          "] cannot be less than 1";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    if (m_pixelType == None) {
      throw IException(IException::Unknown,
          QString("Cannot create the cube [%1] with a pixel type set to None")
            .arg(cubeFileName),
          _FILEINFO_);
    }
 
    if (m_storesDnData) {
      // Make sure the cube is not going to exceed the maximum size preference
      BigInt size = (BigInt)m_samples * m_lines *
                    (BigInt)m_bands * (BigInt)SizeOf(m_pixelType);
 
      size = size / 1024; // kb
      size = size / 1024; // mb
      size = size / 1024; // gb
 
      int maxSizePreference = 0;
 
      maxSizePreference =
          Preference::Preferences().findGroup("CubeCustomization")["MaximumSize"];
 
      if (size > maxSizePreference) {
        QString msg;
        msg += "The cube you are attempting to create [" + cubeFileName + "] is ["
               + toString(size) + "GB]. This is larger than the current allowed "
               "size of [" + toString(maxSizePreference) + "GB]. The cube "
               "dimensions were (S,L,B) [" + toString(m_samples) + ", " +
               toString(m_lines) + ", " + toString(m_bands) + "] with [" +
               toString(SizeOf(m_pixelType)) + "] bytes per pixel. If you still "
               "wish to create this cube, the maximum value can be changed in your personal "
               "preference file located in [~/.Isis/IsisPreferences] within the group "
               "CubeCustomization, keyword MaximumSize. If you do not have an ISISPreference file, "
               "please refer to the documentation 'Environment and Preference Setup'. Error ";
        throw IException(IException::User, msg, _FILEINFO_);
      }
    }
 
    // Expand output name
    FileName cubFile(cubeFileName);
    PvlObject isiscube("IsisCube");
    PvlObject core("Core");
 
    if (m_storesDnData) {
      cubFile = cubFile.addExtension("cub");
 
      // See if we have attached or detached labels
      if (m_attached) {
        // StartByte is 1-based (why!!) so we need to do + 1
        core += PvlKeyword("StartByte", toString(m_labelBytes + 1));
        m_labelFileName = new FileName(cubFile);
        m_dataFileName = new FileName(cubFile);
        m_labelFile = new QFile(m_labelFileName->expanded());
      }
      else {
        core += PvlKeyword("StartByte", toString(1));
        core += PvlKeyword("^Core", cubFile.name());
        m_dataFileName = new FileName(cubFile);
        m_dataFile = new QFile(realDataFileName().expanded());
 
        FileName labelFileName(cubFile);
        labelFileName = labelFileName.setExtension("lbl");
        m_labelFileName = new FileName(labelFileName);
        m_labelFile = new QFile(m_labelFileName->expanded());
      }
 
      // Create the size of the core
      PvlGroup dims("Dimensions");
      dims += PvlKeyword("Samples", toString(m_samples));
      dims += PvlKeyword("Lines",   toString(m_lines));
      dims += PvlKeyword("Bands",   toString(m_bands));
      core.addGroup(dims);
 
      // Create the pixel type
      PvlGroup ptype("Pixels");
      ptype += PvlKeyword("Type", PixelTypeName(m_pixelType));
 
      // And the byte ordering
      ptype += PvlKeyword("ByteOrder", ByteOrderName(m_byteOrder));
      ptype += PvlKeyword("Base", toString(m_base));
      ptype += PvlKeyword("Multiplier", toString(m_multiplier));
      core.addGroup(ptype);
    }
    else {
      cubFile = cubFile.addExtension("ecub");
 
      core += PvlKeyword("^DnFile", m_dataFileName->original());
//       m_dataFileName = new FileName(cubFile);
      m_dataFile = new QFile(realDataFileName().expanded());
 
      m_labelFileName = new FileName(cubFile);
      m_labelFile = new QFile(cubFile.expanded());
    }
 
    isiscube.addObject(core);
 
    m_label = new Pvl;
    m_label->addObject(isiscube);
 
    // Setup storage reserved for the label
    PvlObject lbl("Label");
    lbl += PvlKeyword("Bytes", toString(m_labelBytes));
    m_label->addObject(lbl);
 
    const PvlGroup &pref =
        Preference::Preferences().findGroup("CubeCustomization");
    bool overwrite = pref["Overwrite"][0].toUpper() == "ALLOW";
    if (!overwrite && m_labelFile->exists() && m_labelFile->size()) {
      QString msg = "Cube file [" + m_labelFileName->original() + "] exists, " +
                   "user preference does not allow overwrite";
      throw IException(IException::User, msg, _FILEINFO_);
    }
 
    if (!m_labelFile->open(QIODevice::Truncate | QIODevice::ReadWrite)) {
      QString msg = "Failed to create [" + m_labelFile->fileName() + "]. ";
      msg += "Verify the output path exists and you have permission to write to the path.";
      cleanUp(false);
      throw IException(IException::Io, msg, _FILEINFO_);
    }
 
    if (m_dataFile) {
      if (m_storesDnData && !m_dataFile->open(QIODevice::Truncate | QIODevice::ReadWrite)) {
        QString msg = "Failed to create [" + m_dataFile->fileName() + "]. ";
        msg += "Verify the output path exists and you have permission to write to the path.";
        cleanUp(false);
        throw IException(IException::Io, msg, _FILEINFO_);
      }
      else if (!m_storesDnData && !m_dataFile->open(QIODevice::ReadOnly)) {
        QString msg = "Failed to open [" + m_dataFile->fileName() + "] for reading. ";
        msg += "Verify the output path exists and you have permission to read from the path.";
        cleanUp(false);
        throw IException(IException::Io, msg, _FILEINFO_);
      }
    }
 
    bool dataAlreadyOnDisk = m_storesDnData ? false : true;
 
    if (m_format == Bsq) {
      m_ioHandler = new CubeBsqHandler(dataFile(), m_virtualBandList, realDataFileLabel(),
                                       dataAlreadyOnDisk);
    }
    else {
      m_ioHandler = new CubeTileHandler(dataFile(), m_virtualBandList, realDataFileLabel(),
                                        dataAlreadyOnDisk);
    }
 
    if (m_storesDnData)
      m_ioHandler->updateLabels(*m_label);
 
    // Write the labels
    writeLabels();
  }
  void Cube::create(const QString &cubeFileName) {…}
 

  void Cube::create(
      const QString &cubeFileName, const CubeAttributeOutput &att) {
 
    setByteOrder(att.byteOrder());
    setFormat(att.fileFormat());
    setLabelsAttached(att.labelAttachment() == AttachedLabel);
    if (!att.propagatePixelType())
      setPixelType(att.pixelType());
    setMinMax(att.minimum(), att.maximum());
 
    // Allocate the cube
    create(cubeFileName);
  }
  void Cube::create( {…}
 

  void Cube::open(const QString &cubeFileName, QString access) {
 
    // Already opened?
    if (isOpen()) {
      string msg = "You already have a cube opened";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    initLabelFromFile(cubeFileName, (access == "rw"));
 
    try {
      Isis::CubeAttributeInput att(cubeFileName);
      if(att.bands().size() != 0) {
        vector<QString> bands = att.bands();
        setVirtualBands(bands);
      }
    } catch(IException& e) {
      // Either the cube is an output cube that has already been opened or 
      // there is an exception parsing and adding an attribute
    }
 
    // Figure out the name of the data file
    try {
      PvlObject &core = m_label->findObject("IsisCube").findObject("Core");
      // Detached labels
      if (core.hasKeyword("^Core")) {
        FileName temp(core["^Core"][0]);
 
        if (!temp.originalPath().startsWith("/")) {
          m_dataFileName = new FileName(m_labelFileName->path() + "/" + temp.original());
        }
        else {
          m_dataFileName = new FileName(temp);
        }
 
        m_attached = false;
        m_storesDnData = true;
 
        m_dataFile = new QFile(realDataFileName().expanded());
      }
      // External cube files (ecub), ecub contains all labels and SPICE blobs, history
      else if (core.hasKeyword("^DnFile")) {
        FileName dataFileName(core["^DnFile"][0]);
 
        if (dataFileName.originalPath() == ".") {
          m_dataFileName = new FileName(m_labelFileName->path() + "/" + dataFileName.name());
        }
        else {
          m_dataFileName = new FileName(dataFileName);
        }
 
        m_attached = true;
        m_storesDnData = false;
        *m_dataFileName = FileName(realDataFileName().expanded());
        m_dataFile = new QFile(realDataFileName().expanded());
      }
      // Typical cube containing labels, SPICE, history and dn data
      else {
        m_dataFileName = new FileName(*m_labelFileName);
        m_attached = true;
        m_storesDnData = true;
      }
    }
    catch (IException &e) {
      cleanUp(false);
      throw;
    }
 
    if (access == "r") {
      if (!m_labelFile->open(QIODevice::ReadOnly)) {
        QString msg = "Failed to open [" + m_labelFile->fileName() + "] with "
            "read only access";
        cleanUp(false);
        throw IException(IException::Io, msg, _FILEINFO_);
      }
 
      if (m_dataFile) {
        if (!m_dataFile->open(QIODevice::ReadOnly)) {
          QString msg = "Failed to open [" + m_dataFile->fileName() + "] with "
              "read only access";
          cleanUp(false);
          throw IException(IException::Io, msg, _FILEINFO_);
        }
      }
    }
 
    else if (access == "rw") {
      if (!m_labelFile->open(QIODevice::ReadWrite)) {
        QString msg = "Failed to open [" + m_labelFile->fileName() + "] with "
            "read/write access";
        cleanUp(false);
        throw IException(IException::Io, msg, _FILEINFO_);
      }
 
      if (m_dataFile) {
        if (m_storesDnData && !m_dataFile->open(QIODevice::ReadWrite)) {
          QString msg = "Failed to open [" + m_dataFile->fileName() + "] with "
              "read/write access";
          cleanUp(false);
          throw IException(IException::Io, msg, _FILEINFO_);
        }
        else if (!m_storesDnData && !m_dataFile->open(QIODevice::ReadOnly)) {
          QString msg = "Failed to open [" + m_dataFile->fileName() + "] with "
              "read access";
          cleanUp(false);
          throw IException(IException::Io, msg, _FILEINFO_);
        }
      }
    }
    else {
      QString msg = "Unknown value for access [" + access + "]. Expected 'r' "
                    " or 'rw'";
      cleanUp(false);
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    initCoreFromLabel(*m_label);
 
    // Determine the number of bytes in the label
    if (m_attached) {
      m_labelBytes = m_label->findObject("Label")["Bytes"];
    }
    else {
      m_labelBytes = labelSize(true);
    }
 
    QPair<bool, Pvl *> dataLabel = qMakePair(false, m_label);
    if (!m_storesDnData) {
      dataLabel = qMakePair(true, new Pvl(m_dataFileName->expanded()));
    }
 
    // Now examine the format to see which type of handler to create
    if (m_format == Bsq) {
      m_ioHandler = new CubeBsqHandler(dataFile(), m_virtualBandList,
          realDataFileLabel(), true);
    }
    else {
      m_ioHandler = new CubeTileHandler(dataFile(), m_virtualBandList,
          realDataFileLabel(), true);
    }
 
    if (dataLabel.first) {
      delete dataLabel.second;
      dataLabel.second = NULL;
    }
 
    applyVirtualBandsToLabel();
  }
  void Cube::open(const QString &cubeFileName, QString access) {…}
 

  void Cube::reopen(QString access) {
    if (!m_labelFile) {
      QString msg = "Cube has not been opened yet. The filename to re-open is "
          "unknown";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    // Preserve filename and virtual bands when re-opening
    FileName filename = *m_labelFileName;
    QList<int> virtualBandList;
 
    if (m_virtualBandList)
      virtualBandList = *m_virtualBandList;
 
    close();
    open(filename.expanded(), access);
 
    if (virtualBandList.size()) {
      if (m_virtualBandList)
        *m_virtualBandList = virtualBandList;
      else
        m_virtualBandList = new QList<int>(virtualBandList);
    }
  }
  void Cube::reopen(QString access) {…}
 

  void Cube::read(Blob &blob, const std::vector<PvlKeyword> keywords) const {
    if (!isOpen()) {
      string msg = "The cube is not opened so you can't read a blob from it";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    FileName cubeFile = *m_labelFileName;
    if (m_tempCube)
      cubeFile = *m_tempCube;
 
    QMutexLocker locker(m_mutex);
    QMutexLocker locker2(m_ioHandler->dataFileMutex());
    blob.Read(cubeFile.toString(), *label(), keywords);
  }
  void Cube::read(Blob &blob, const std::vector<PvlKeyword> keywords) const  {…}
 

  void Cube::read(Buffer &bufferToFill) const {
    if (!isOpen()) {
      string msg = "Try opening a file before you read it";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    QMutexLocker locker(m_mutex);
    m_ioHandler->read(bufferToFill);
  }
  void Cube::read(Buffer &bufferToFill) const  {…}
 

  History Cube::readHistory(const QString &name) const {
    Blob historyBlob(name, "History");
    try {
      // read history from cube, if it exists.
      read(historyBlob);
    }
    catch (IException &) {
    // if the history does not exist in the cube, this function creates it.
    }
    History history(historyBlob);
    return history;
  }
  History Cube::readHistory(const QString &name) const  {…}
 

  ImagePolygon Cube::readFootprint() const {
    Blob footprintBlob("Footprint", "Polygon");
    try {
      // read history from cube, if it exists.
      read(footprintBlob);
    }
    catch (IException &e) {
      QString msg = "Footprintinit must be run prior to reading the footprint";
      msg += " with POLYGON=TRUE for cube [" + fileName() + "]";
      throw IException(e, IException::User, msg, _FILEINFO_);
    }
    ImagePolygon footprint(footprintBlob);
    return footprint;
  }
  ImagePolygon Cube::readFootprint() const  {…}
 

  OriginalLabel Cube::readOriginalLabel(const QString &name) const {
    Blob origLabelBlob(name, "OriginalLabel");
    try {
      read(origLabelBlob);
    }
    catch (IException &e){
      QString msg = "Unable to locate OriginalLabel in " + fileName();
      throw IException(e, IException::User, msg, _FILEINFO_);
    }
    OriginalLabel origLabel(origLabelBlob);
    return origLabel;
  }
  OriginalLabel Cube::readOriginalLabel(const QString &name) const  {…}
 

  CubeStretch Cube::readCubeStretch(QString name, const std::vector<PvlKeyword> keywords) const {
    Blob stretchBlob(name, "Stretch");
    try {
      read(stretchBlob, keywords);
    }
    catch (IException &e){
      QString msg = "Unable to locate Stretch information in " + fileName();
      throw IException(e, IException::User, msg, _FILEINFO_);
    }
    CubeStretch cubeStretch(stretchBlob);
    return stretchBlob;
  }
  CubeStretch Cube::readCubeStretch(QString name, const std::vector<PvlKeyword> keywords) const  {…}
 

  OriginalXmlLabel Cube::readOriginalXmlLabel() const {
    Blob origXmlLabelBlob("IsisCube", "OriginalXmlLabel");
    try {
      read(origXmlLabelBlob);
    }
    catch (IException &e){
      QString msg = "Unable to locate OriginalXmlLabel in " + fileName();
      throw IException(e, IException::User, msg, _FILEINFO_);
    }
    OriginalXmlLabel origXmlLabel(origXmlLabelBlob);
    return origXmlLabel;
  }
  OriginalXmlLabel Cube::readOriginalXmlLabel() const  {…}
 

  Table Cube::readTable(const QString &name) {
    Blob tableBlob(name, "Table");
    try {
      read(tableBlob);
    }
    catch (IException &e) {
      QString msg = "Failed to read table [" + name + "] from cube [" + fileName() + "].";
      throw IException(e, IException::Programmer, msg, _FILEINFO_);
    }
    return Table(tableBlob);
  }
  Table Cube::readTable(const QString &name) {…}
 

  void Cube::write(Blob &blob, bool overwrite) {
    if (!isOpen()) {
      string msg = "The cube is not opened so you can't write a blob to it";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    if (!m_labelFile->isWritable()) {
      string msg = "The cube must be opened in read/write mode, not readOnly";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    // Write an attached blob
    if (m_attached) {
      QMutexLocker locker(m_mutex);
      QMutexLocker locker2(m_ioHandler->dataFileMutex());
 
      // Compute the number of bytes in the cube + label bytes and if the
      // endpos of the file // is not greater than this then seek to that position.
      fstream stream(m_labelFileName->expanded().toLatin1().data(),
                     ios::in | ios::out | ios::binary);
      stream.seekp(0, ios::end);
 
      // End byte = end byte of the file (aka eof position, file size)
      streampos endByte = stream.tellp();
      // maxbyte = position after the cube DN data and labels
      streampos maxbyte = (streampos) m_labelBytes;
 
      if (m_storesDnData) {
        maxbyte += (streampos) m_ioHandler->getDataSize();
      }
 
      // If EOF is too early, allocate space up to where we want the blob
      if (endByte < maxbyte) {
        stream.seekp(maxbyte, ios::beg);
      }
 
      // Use default argument of "" for detached stream
      blob.Write(*m_label, stream, "", overwrite);
    }
 
    // Write a detached blob
    else {
      FileName blobFileName = fileName();
      blobFileName = blobFileName.removeExtension();
      blobFileName = blobFileName.addExtension(blob.Type());
      blobFileName = blobFileName.addExtension(blob.Name());
      QString blobFile(blobFileName.expanded());
      ios::openmode flags = ios::in | ios::binary | ios::out | ios::trunc;
      fstream detachedStream;
      detachedStream.open(blobFile.toLatin1().data(), flags);
      if (!detachedStream) {
        QString message = "Unable to open data file [" +
                          blobFileName.expanded() + "]";
        throw IException(IException::Io, message, _FILEINFO_);
      }
 
      blob.Write(*m_label, detachedStream, blobFileName.name());
    }
  }
  void Cube::write(Blob &blob, bool overwrite) {…}
 

  void Cube::write(OriginalLabel &lab) {
    Blob labelBlob = lab.toBlob();
    write(labelBlob);
  }
  void Cube::write(OriginalLabel &lab) {…}
 

  void Cube::write(const OriginalXmlLabel &lab) {
    Blob labelBlob = lab.toBlob();
    write(labelBlob);
  }
  void Cube::write(const OriginalXmlLabel &lab) {…}
 

  void Cube::write(const Table &table) {
    Blob tableBlob = table.toBlob();
    write(tableBlob);
  }
  void Cube::write(const Table &table) {…}
 

  void Cube::write(const CubeStretch &cubeStretch) {
    Blob cubeStretchBlob = cubeStretch.toBlob();
    write(cubeStretchBlob);
  }
  void Cube::write(const CubeStretch &cubeStretch) {…}
 

  void Cube::write(History &history, const QString &name) {
    Blob histBlob = history.toBlob(name);
    write(histBlob);
  }
  void Cube::write(History &history, const QString &name) {…}
 

  void Cube::write(const ImagePolygon &polygon) {
    Blob polyBlob = polygon.toBlob();
    write(polyBlob);
  }
  void Cube::write(const ImagePolygon &polygon) {…}
 

  void Cube::write(Buffer &bufferToWrite) {
    if (!isOpen()) {
      string msg = "Tried to write to a cube before opening/creating it";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    if (isReadOnly()) {
      QString msg = "Cannot write to the cube [" + (QString)QFileInfo(fileName()).fileName() +
          "] because it is opened read-only";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    if (!m_storesDnData) {
      QString msg = "The cube [" + QFileInfo(fileName()).fileName() +
          "] does not support storing DN data because it is using an external file for DNs";
      throw IException(IException::Unknown, msg, _FILEINFO_);
    }
 
    QMutexLocker locker(m_mutex);
    m_ioHandler->write(bufferToWrite);
  }
  void Cube::write(Buffer &bufferToWrite) {…}
 

  void Cube::setBaseMultiplier(double base, double mult) {
    openCheck();
    m_base = base;
    m_multiplier = mult;
  }
  void Cube::setBaseMultiplier(double base, double mult) {…}
 

  void Cube::setMinMax(double min, double max) {
    openCheck();
 
    m_base = 0.0;
    m_multiplier = 1.0;
 
    double x1, x2;
    if (m_pixelType == UnsignedByte) {
      x1 = VALID_MIN1;
      x2 = VALID_MAX1;
      m_multiplier = (max - min) / (x2 - x1);
      m_base = min - m_multiplier * x1;
    }
    else if (m_pixelType == SignedWord) {
      x1 = VALID_MIN2;
      x2 = VALID_MAX2;
      m_multiplier = (max - min) / (x2 - x1);
      m_base = min - m_multiplier * x1;
    }
    else if (m_pixelType == UnsignedWord) {
      x1 = VALID_MINU2;
      x2 = VALID_MAXU2;
      m_multiplier = (max - min) / (x2 - x1);
      m_base = min - m_multiplier * x1;
    }
  }
  void Cube::setMinMax(double min, double max) {…}
 

  void Cube::setByteOrder(ByteOrder byteOrder) {
    openCheck();
    m_byteOrder = byteOrder;
  }
  void Cube::setByteOrder(ByteOrder byteOrder) {…}
 

  void Cube::setDimensions(int ns, int nl, int nb) {
    openCheck();
    if ((ns < 1) || (nl < 1) || (nb < 1)) {
      string msg = "SetDimensions:  Invalid number of sample, lines or bands";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    m_samples = ns;
    m_lines = nl;
    m_bands = nb;
  }
  void Cube::setDimensions(int ns, int nl, int nb) {…}
 

  void Cube::setExternalDnData(FileName cubeFileWithDnData) {
    try {
      initLabelFromFile(cubeFileWithDnData, false);
      initCoreFromLabel(*m_label);
 
      delete m_label;
      m_label = NULL;
    }
    catch (IException &) {
      delete m_label;
      m_label = NULL;
      throw;
    }
 
    m_storesDnData = false;
    m_dataFileName = new FileName(cubeFileWithDnData);
 
    delete m_labelFile;
    m_labelFile = NULL;
 
    delete m_labelFileName;
    m_labelFileName = NULL;
  }
  void Cube::setExternalDnData(FileName cubeFileWithDnData) {…}
 

  void Cube::setFormat(Format format) {
    openCheck();
    m_format = format;
  }
  void Cube::setFormat(Format format) {…}
 

  void Cube::setLabelsAttached(bool attach) {
    openCheck();
    m_attached = attach;
  }
  void Cube::setLabelsAttached(bool attach) {…}
 

  void Cube::setLabelSize(int labelBytes) {
    openCheck();
    m_labelBytes = labelBytes;
  }
  void Cube::setLabelSize(int labelBytes) {…}
 

  void Cube::setPixelType(PixelType pixelType) {
    openCheck();
    m_pixelType = pixelType;
  }
  void Cube::setPixelType(PixelType pixelType) {…}
 

  void Cube::setVirtualBands(const QList<QString> &vbands) {
    openCheck();
    if (m_virtualBandList)
      m_virtualBandList->clear();
    else
      m_virtualBandList = new QList<int>;
 
    if (vbands.size() > 0) {
      QListIterator<QString> it(vbands);
      while (it.hasNext()) {
        m_virtualBandList->append(toInt(it.next()));
      }
    }
    else {
      delete m_virtualBandList;
      m_virtualBandList = NULL;
    }
 
    if (m_ioHandler) {
      m_ioHandler->setVirtualBands(m_virtualBandList);
    }
  }
  void Cube::setVirtualBands(const QList<QString> &vbands) {…}
 

  void Cube::setVirtualBands(const std::vector<QString> &vbands) {
    QList<QString> realVBands;
 
    for(unsigned int i = 0; i < vbands.size(); i++)
      realVBands << vbands[i];
 
    setVirtualBands(realVBands);
  }
  void Cube::setVirtualBands(const std::vector<QString> &vbands) {…}
 

  void Cube::relocateDnData(FileName dnDataFile) {
    if (!isOpen()) {
      throw IException(IException::Unknown,
                       QString("Cannot relocate the DN data to [%1] for an external cube label "
                               "file which is not open.")
                         .arg(dnDataFile.original()),
                       _FILEINFO_);
    }
 
 
    if (m_storesDnData) {
      throw IException(IException::Unknown,
                       QString("The cube [%1] stores DN data. It cannot be relocated to [%2] - "
                               "this is only supported for external cube label files.")
                         .arg(m_labelFileName->original()).arg(dnDataFile.original()),
                       _FILEINFO_);
    }
 
    m_label->findObject("IsisCube").findObject("Core").findKeyword("^DnFile")[0] =
        dnDataFile.original();
    reopen(m_labelFile->isWritable()? "rw" : "r");
  }
  void Cube::relocateDnData(FileName dnDataFile) {…}
 
 
//   void Cube::relocateDnData(FileName externalLabelFile, FileName dnDataFile) {
//     try {
//       Pvl externalLabelData(externalLabelFile.expanded());
//       externalLabelData.FindObject("IsisCube").FindObject("Core").FindKeyword("^DnFile")[0] =
//           dnDataFile.original();
//     }
//     catch (IException &e) {
//       throw IException(e, IException::Io,
//                        QString("File [%1] does not appear to be an external cube label file")
//                          .arg(externalLabelFile.original().ToQt()),
//                        _FILEINFO_);
//     }
//   }
 

  int Cube::bandCount() const {
    int numBands = m_bands;
    if (m_virtualBandList)
      numBands = m_virtualBandList->size();
    return numBands;
  }
  int Cube::bandCount() const  {…}
 

  double Cube::base() const {
    return m_base;
  }
  double Cube::base() const  {…}
 

  ByteOrder Cube::byteOrder() const {
    return m_byteOrder;
  }
  ByteOrder Cube::byteOrder() const  {…}
 

  Camera *Cube::camera() {
    if (m_camera == NULL && isOpen()) {
      m_camera = CameraFactory::Create(*this);
    }
    return m_camera;
  }
  Camera *Cube::camera() {…}
 
 
  void Cube::attachSpiceFromIsd(nlohmann::json isd) {
    PvlKeyword lkKeyword("LeapSecond");
    PvlKeyword pckKeyword("TargetAttitudeShape");
    PvlKeyword targetSpkKeyword("TargetPosition");
    PvlKeyword ckKeyword("InstrumentPointing");
    PvlKeyword ikKeyword("Instrument");
    PvlKeyword sclkKeyword("SpacecraftClock");
    PvlKeyword spkKeyword("InstrumentPosition");
    PvlKeyword iakKeyword("InstrumentAddendum");
    PvlKeyword demKeyword("ShapeModel");
    PvlKeyword exkKeyword("Extra");
 
    Spice spice(*this->label(), isd);
    Table ckTable = spice.instrumentRotation()->Cache("InstrumentPointing");
    ckTable.Label() += PvlKeyword("Kernels");
 
    for (int i = 0; i < ckKeyword.size(); i++)
      ckTable.Label()["Kernels"].addValue(ckKeyword[i]);
 
    this->write(ckTable);
 
    Table spkTable = spice.instrumentPosition()->Cache("InstrumentPosition");
    spkTable.Label() += PvlKeyword("Kernels");
    for (int i = 0; i < spkKeyword.size(); i++)
      spkTable.Label()["Kernels"].addValue(spkKeyword[i]);
 
    this->write(spkTable);
 
    Table bodyTable = spice.bodyRotation()->Cache("BodyRotation");
    bodyTable.Label() += PvlKeyword("Kernels");
    for (int i = 0; i < targetSpkKeyword.size(); i++)
      bodyTable.Label()["Kernels"].addValue(targetSpkKeyword[i]);
 
    for (int i = 0; i < pckKeyword.size(); i++)
      bodyTable.Label()["Kernels"].addValue(pckKeyword[i]);
 
    bodyTable.Label() += PvlKeyword("SolarLongitude",
        toString(spice.solarLongitude().degrees()));
    this->write(bodyTable);
 
    Table sunTable = spice.sunPosition()->Cache("SunPosition");
    sunTable.Label() += PvlKeyword("Kernels");
    for (int i = 0; i < targetSpkKeyword.size(); i++)
      sunTable.Label()["Kernels"].addValue(targetSpkKeyword[i]);
 
    this->write(sunTable);
 
    PvlGroup currentKernels = this->group("Kernels");
 
    Pvl *label = this->label();
    int i = 0;
    while (i < label->objects()) {
      PvlObject currObj = label->object(i);
      if (currObj.isNamed("NaifKeywords")) {
        label->deleteObject(i);
      }
      else {
        i ++;
      }
    }
 
    *(this->label()) += spice.getStoredNaifKeywords();
 
    // Access the camera here while all of the kernels are still loaded.
    // This needs to be done for some cameras that need loaded spice data
    // to actually create the camera model. (KaguyaTC for example)
    this->camera();
  }
 
  void Cube::attachLineScanTableFromIsd(nlohmann::json isd) {
      TableField ephTimeField("EphemerisTime", TableField::Double);
      TableField expTimeField("ExposureTime", TableField::Double);
      TableField lineStartField("LineStart", TableField::Integer);
 
      TableRecord timesRecord;
      timesRecord += ephTimeField;
      timesRecord += expTimeField;
      timesRecord += lineStartField;
 
      Table timesTable("LineScanTimes", timesRecord);
      for (size_t i = 0; i < isd["line_scan_rate"].size(); ++i) {
        timesRecord[0] = isd["line_scan_rate"][i][1].get<double>() + isd["center_ephemeris_time"].get<double>();
        timesRecord[1] = isd["line_scan_rate"][i][2].get<double>();
        timesRecord[2] = (int)(isd["line_scan_rate"][i][0].get<double>() + 0.5);
        timesTable += timesRecord;
      }
      this->write(timesTable);
  }
 

  FileName Cube::externalCubeFileName() const {
    if (!isOpen()) {
      throw IException(IException::Unknown,
                       "An external cube label file must be opened in order to use "
                         "Cube::getExternalCubeFileName",
                       _FILEINFO_);
    }
 
    if (storesDnData()) {
      throw IException(IException::Unknown,
                       "Cube::getExternalCubeFileName can only be called on an external cube label "
                         "file",
                       _FILEINFO_);
    }
 
 
   PvlObject &core = m_label->findObject("IsisCube").findObject("Core");
 
    return core["^DnFile"][0];
  }
  FileName Cube::externalCubeFileName() const  {…}
 

  QString Cube::fileName() const {
    if (isOpen())
      return m_labelFileName->expanded();
    else
      return "";
  }
  QString Cube::fileName() const  {…}
 

  Cube::Format Cube::format() const {
    return m_format;
  }
  Cube::Format Cube::format() const  {…}
 

  Histogram *Cube::histogram(const int &band, QString msg) {
    return histogram(band, ValidMinimum, ValidMaximum, msg);
  }
  Histogram *Cube::histogram(const int &band, QString msg) {…}
 

  Histogram *Cube::histogram(const int &band, const double &validMin,
                                const double &validMax, QString msg) {
    // Make sure cube is open
    if ( !isOpen() ) {
      QString msg = "Cannot create histogram object for an unopened cube";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    // Make sure band is valid
    if ((band < 0) || (band > bandCount())) {
      QString msg = "Invalid band in [CubeInfo::Histogram]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    int bandStart = band;
    int bandStop = band;
    int maxSteps = lineCount();
    if (band == 0) {
      bandStart = 1;
      bandStop = bandCount();
      maxSteps = lineCount() * bandCount();
    }
 
    Progress progress;
    Histogram *hist = new ImageHistogram(*this, band, &progress);
    LineManager line(*this);
 
    // This range is for throwing out data; the default parameters are OK always
    //hist->SetValidRange(validMin, validMax);
 
    // We now need to know the binning range - ValidMinimum/Maximum are no longer
    //   acceptable, default to the bin range start/end.
    double binMin = validMin;
    double binMax = validMax;
    if (binMin == ValidMinimum) {
      binMin = hist->BinRangeStart();
    }
 
    if (binMax == ValidMaximum) {
      binMax = hist->BinRangeEnd();
    }
 
    //hist->SetBinRange(binMin, binMax);
    hist->SetValidRange(binMin,binMax);
 
    // Loop and get the histogram
    progress.SetText(msg);
    progress.SetMaximumSteps(maxSteps);
    progress.CheckStatus();
 
    for(int useBand = bandStart ; useBand <= bandStop ; useBand++) {
      for(int i = 1; i <= lineCount(); i++) {
        line.SetLine(i, useBand);
        read(line);
        hist->AddData(line.DoubleBuffer(), line.size());
        progress.CheckStatus();
      }
    }
 
    return hist;
  }
  Histogram *Cube::histogram(const int &band, const double &validMin, {…}
 

  Pvl *Cube::label() const {
    return m_label;
  }
  Pvl *Cube::label() const  {…}
 

  int Cube::labelSize(bool actual) const {
    int labelSize = m_labelBytes;
 
    if (actual && m_label) {
      ostringstream s;
      s << *m_label << endl;
      labelSize = s.tellp();
    }
    else if (actual) {
      labelSize = 0;
    }
 
    return labelSize;
  }
  int Cube::labelSize(bool actual) const  {…}
 

  int Cube::lineCount() const {
    return m_lines;
  }
  int Cube::lineCount() const  {…}
 

  double Cube::multiplier() const {
    return m_multiplier;
  }
  double Cube::multiplier() const  {…}
 

  PixelType Cube::pixelType() const {
    return m_pixelType;
  }
  PixelType Cube::pixelType() const  {…}
 

  int Cube::physicalBand(const int &virtualBand) const {
    int physicalBand = virtualBand;
 
    if (m_virtualBandList) {
      if ((virtualBand < 1) ||
          (virtualBand > m_virtualBandList->size())) {
        QString msg = "Out of array bounds [" + toString(virtualBand) + "]";
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }
      physicalBand = m_virtualBandList->at(virtualBand - 1);
    }
 
    return physicalBand;
  }
  int Cube::physicalBand(const int &virtualBand) const  {…}
 

  Projection *Cube::projection() {
    if (m_projection == NULL && isOpen()) {
      m_projection =  ProjectionFactory::CreateFromCube(*label());
    }
    return m_projection;
  }
  Projection *Cube::projection() {…}
 

  int Cube::sampleCount() const {
    return m_samples;
  }
  int Cube::sampleCount() const  {…}
 

  Statistics *Cube::statistics(const int &band, QString msg) {
    return statistics(band, ValidMinimum, ValidMaximum, msg);
  }
  Statistics *Cube::statistics(const int &band, QString msg) {…}
 

  Statistics *Cube::statistics(const int &band, const double &validMin,
                                     const double &validMax, QString msg) {
    // Make sure cube is open
    if ( !isOpen() ) {
      QString msg = "Cannot create statistics object for an unopened cube";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    // Make sure band is valid
    if ((band < 0) || (band > bandCount())) {
      string msg = "Invalid band in [CubeInfo::Statistics]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    // Construct a line buffer manager and a statistics object
    LineManager line(*this);
    Statistics *stats = new Statistics();
 
    stats->SetValidRange(validMin, validMax);
 
    int bandStart = band;
    int bandStop = band;
    int maxSteps = lineCount();
    if (band == 0) {
      bandStart = 1;
      bandStop = bandCount();
      maxSteps = lineCount() * bandCount();
    }
 
    Progress progress;
    progress.SetText(msg);
    progress.SetMaximumSteps(maxSteps);
    progress.CheckStatus();
 
    // Loop and get the statistics for a good minimum/maximum
    for(int useBand = bandStart ; useBand <= bandStop ; useBand++) {
      for(int i = 1; i <= lineCount(); i++) {
        line.SetLine(i, useBand);
        read(line);
        stats->AddData(line.DoubleBuffer(), line.size());
        progress.CheckStatus();
      }
    }
 
    return stats;
  }
  Statistics *Cube::statistics(const int &band, const double &validMin, {…}
 

  bool Cube::storesDnData() const {
    return m_storesDnData;
  }
  bool Cube::storesDnData() const  {…}
 

  void Cube::addCachingAlgorithm(CubeCachingAlgorithm *algorithm) {
 
    if (isOpen() && m_ioHandler) {
      m_ioHandler->addCachingAlgorithm(algorithm);
    }
    else if (!isOpen()) {
      QString msg = "Cannot add a caching algorithm until the cube is open";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }
  void Cube::addCachingAlgorithm(CubeCachingAlgorithm *algorithm) {…}

  void Cube::clearIoCache() {
    if (m_ioHandler) {
      QMutexLocker locker(m_mutex);
      m_ioHandler->clearCache();
    }
  }
  void Cube::clearIoCache() {…}
 

  bool Cube::deleteBlob(QString BlobName, QString BlobType) {
    for(int i = 0; i < m_label->objects(); i++) {
      PvlObject obj = m_label->object(i);
      if (obj.name().compare(BlobType) == 0) {
        if (obj.findKeyword("Name")[0] == BlobName) {
          m_label->deleteObject(i);
          return true;
        }
      }
    }
    return false;
  }
  bool Cube::deleteBlob(QString BlobName, QString BlobType) {…}
 

  void Cube::deleteGroup(const QString &group) {
    PvlObject &isiscube = label()->findObject("IsisCube");
    if (!isiscube.hasGroup(group)) return;
    isiscube.deleteGroup(group);
  }
  void Cube::deleteGroup(const QString &group) {…}
 

  PvlGroup &Cube::group(const QString &group) const {
    PvlObject &isiscube = label()->findObject("IsisCube");
    return isiscube.findGroup(group);
  }
  PvlGroup &Cube::group(const QString &group) const  {…}
 

  bool Cube::hasGroup(const QString &group) const {
    const PvlObject &isiscube = label()->findObject("IsisCube");
    if (isiscube.hasGroup(group)) return true;
    return false;
  }
  bool Cube::hasGroup(const QString &group) const  {…}
 

  bool Cube::hasBlob(const QString &name, const QString &type) {
    for(int o = 0; o < label()->objects(); o++) {
      PvlObject &obj = label()->object(o);
      if (obj.isNamed(type)) {
        if (obj.hasKeyword("Name")) {
          QString temp = (QString) obj["Name"];
          temp = temp.toUpper();
          QString temp2 = name;
          temp2 = temp2.toUpper();
          if (temp == temp2) return true;
        }
      }
    }
    return false;
  }
  bool Cube::hasBlob(const QString &name, const QString &type) {…}
 

  bool Cube::hasTable(const QString &name) {
    return hasBlob(name, "Table");
  }
  bool Cube::hasTable(const QString &name) {…}
 

  void Cube::putGroup(const PvlGroup &group) {
    if (isReadOnly()) {
      QString msg = "Cannot add a group to the label of cube [" + (QString)QFileInfo(fileName()).fileName() +
          "] because it is opened read-only";
      throw IException(IException::Programmer, msg, _FILEINFO_);
      return;
    }
 
    PvlObject &isiscube = label()->findObject("IsisCube");
    if (isiscube.hasGroup(group.name())) {
      isiscube.findGroup(group.name()) = group;
    }
    else {
      isiscube.addGroup(group);
    }
  }
  void Cube::putGroup(const PvlGroup &group) {…}
 

  void Cube::applyVirtualBandsToLabel() {
    PvlObject &core = m_label->findObject("IsisCube").findObject("Core");
 
    // Prune the band bin group if it exists
    if (m_label->findObject("IsisCube").hasGroup("BandBin")) {
      PvlGroup &bandBin = m_label->findObject("IsisCube").findGroup("BandBin");
      for (int k = 0;k < bandBin.keywords();k++) {
        if (bandBin[k].size() == m_bands && m_virtualBandList) {
          PvlKeyword temp = bandBin[k];
          bandBin[k].clear();
          for (int i = 0;i < m_virtualBandList->size();i++) {
            int physicalBand = m_virtualBandList->at(i) - 1;
            bandBin[k].addValue(temp[physicalBand], temp.unit(physicalBand));
          }
        }
      }
    }
 
    // Change the number of bands in the labels of the cube
    if (m_virtualBandList && core.hasGroup("Dimensions")) core.findGroup("Dimensions")["Bands"] = toString(m_virtualBandList->size());
  }
  void Cube::applyVirtualBandsToLabel() {…}
 

  void Cube::cleanUp(bool removeIt) {
    if (m_ioHandler) {
      delete m_ioHandler;
      m_ioHandler = NULL;
    }
 
    // Always remove a temporary file
    if (m_tempCube) {
      QFile::remove(m_tempCube->expanded());
      removeIt = false; // dont remove originals
 
      delete m_tempCube;
      m_tempCube = NULL;
    }
 
    if (removeIt) {
      QFile::remove(m_labelFileName->expanded());
 
      if (*m_labelFileName != *m_dataFileName)
        QFile::remove(m_dataFileName->expanded());
    }
 
    delete m_labelFile;
    m_labelFile = NULL;
 
    delete m_dataFile;
    m_dataFile = NULL;
 
    delete m_labelFileName;
    m_labelFileName = NULL;
 
    delete m_dataFileName;
    m_dataFileName = NULL;
 
    delete m_label;
    m_label = NULL;
 
    delete m_virtualBandList;
    m_virtualBandList = NULL;
 
    initialize();
  }
  void Cube::cleanUp(bool removeIt) {…}
 

  void Cube::construct() {
    m_labelFile = NULL;
    m_dataFile = NULL;
    m_ioHandler = NULL;
    m_mutex = NULL;
 
    m_camera = NULL;
    m_projection = NULL;
 
    m_labelFileName = NULL;
    m_dataFileName = NULL;
    m_tempCube = NULL;
    m_formatTemplateFile = NULL;
    m_label = NULL;
 
    m_virtualBandList = NULL;
 
    m_mutex = new QMutex();
    m_formatTemplateFile =
         new FileName("$ISISROOT/appdata/templates/labels/CubeFormatTemplate.pft");
 
    initialize();
  }
  void Cube::construct() {…}
 

  QFile *Cube::dataFile() const {
    if (m_dataFile)
      return m_dataFile;
    else
      return m_labelFile;
  }
  QFile *Cube::dataFile() const  {…}
 

  FileName Cube::realDataFileName() const {
    FileName result;
 
    // Attached, stores DN data - normal cube
    if (m_attached && m_storesDnData) {
      result = *m_labelFileName;
    }
    // Detached, stores DN data - standard detached cube
    else if (!m_attached && m_storesDnData) {
      result = *m_dataFileName;
    }
    // External cube - go look at our external file
    else if (!m_storesDnData) {
      FileName guess = *m_dataFileName;
      QDir dir(guess.toString());
 
      // If path is relative and there is a labelFileName, start in directory of the ecub, then
      // cd to the directory containing the DnFile, since it is relative to the location of the ecub.
      // We need to turn the relative path into an absolute path.
      if (dir.isRelative() && m_labelFileName) {
        QDir dir2(m_labelFileName->originalPath());
        dir2.cd(guess.path());
        guess = dir2.absolutePath() + "/" + guess.name();
      }
      do {
        Pvl guessLabel(guess.expanded());
 
        PvlObject &core = guessLabel.findObject("IsisCube").findObject("Core");
 
        if (core.hasKeyword("^DnFile")) {
          FileName currentGuess = guess;
          guess = core["^DnFile"][0];
 
          if (!guess.path().startsWith("/")) {
            guess = currentGuess.path() + "/" + guess.original();
          }
        }
        else if (core.hasKeyword("^Core")) {
          result = core["^Core"][0];
        }
        else {
          result = guess;
        }
      }
      while (result.name() == "");
    }
 
    return result;
  }
  FileName Cube::realDataFileName() const  {…}
 

  void Cube::initialize() {
    m_byteOrder = Lsb;
    if (IsBigEndian())
      m_byteOrder = Msb;
    m_format = Tile;
    m_pixelType = Real;
 
    m_attached = true;
    m_storesDnData = true;
    m_labelBytes = 65536;
 
    m_samples = 0;
    m_lines = 0;
    m_bands = 0;
 
    m_base = 0.0;
    m_multiplier = 1.0;
  }
  void Cube::initialize() {…}
 

  void Cube::initCoreFromLabel(const Pvl &label) {
    const PvlObject &core = label.findObject("IsisCube").findObject("Core");
 
    if (!core.hasKeyword("^DnFile")) {
      // Dimensions
      const PvlGroup &dims = core.findGroup("Dimensions");
      m_samples = dims["Samples"];
      m_lines = dims["Lines"];
      m_bands = dims["Bands"];
 
      // Stored pixel information
      const PvlGroup &pixelsGroup = core.findGroup("Pixels");
      m_byteOrder = ByteOrderEnumeration(pixelsGroup["ByteOrder"]);
      m_base = pixelsGroup["Base"];
      m_multiplier = pixelsGroup["Multiplier"];
      m_pixelType = PixelTypeEnumeration(pixelsGroup["Type"]);
 
      // Now examine the format to see which type of handler to create
      if ((QString) core["Format"] == "BandSequential") {
        m_format = Bsq;
      }
      else {
        m_format = Tile;
      }
    }
    else {
      FileName temp(core["^DnFile"][0]);
      if (!temp.expanded().startsWith("/")) {
        temp = FileName(m_labelFileName->path() + "/" + temp.original());
      }
 
      initCoreFromLabel(Pvl(temp.toString()));
    }
  }
  void Cube::initCoreFromLabel(const Pvl &label) {…}
 

  void Cube::initLabelFromFile(FileName labelFileName, bool readWrite) {
 
    try {
      if (labelFileName.fileExists()) {
        m_label = new Pvl(labelFileName.expanded());
        if (!m_label->objects()) {
          throw IException();
        }
      }
    }
    catch(IException &) {
      if (m_label) {
        delete m_label;
        m_label = NULL;
      }
    }
 
    try {
      if (!m_label) {
        FileName tmp(labelFileName);
        tmp = tmp.addExtension("cub");
        if (tmp.fileExists()) {
          m_label = new Pvl(tmp.expanded());
          if (!m_label->objects()) {
            throw IException();
          }
          labelFileName = tmp;
        }
      }
    }
    catch(IException &e) {
      if (m_label) {
        delete m_label;
        m_label = NULL;
      }
    }
 
    try {
      if (!m_label) {
        FileName tmp(labelFileName);
        tmp = tmp.setExtension("lbl");
        if (tmp.fileExists()) {
          m_label = new Pvl(tmp.expanded());
          if (!m_label->objects()) {
            throw IException();
          }
          labelFileName = tmp;
        }
      }
    }
    catch(IException &e) {
      if (m_label) {
        delete m_label;
        m_label = NULL;
      }
    }
 
    try {
      if (!m_label) {
        FileName tmp(labelFileName);
        tmp = tmp.addExtension("ecub");
        if (tmp.fileExists()) {
          m_label = new Pvl(tmp.expanded());
          if (!m_label->objects()) {
            throw IException();
          }
          labelFileName = tmp;
        }
      }
    }
    catch(IException &e) {
      if (m_label) {
        delete m_label;
        m_label = NULL;
      }
    }
 
    if (!m_label) {
      QString msg = Message::FileOpen(labelFileName.original());
      throw IException(IException::Io, msg, _FILEINFO_);
    }
 
    m_labelFileName = new FileName(labelFileName);
 
    // See if this is an old Isis cube format.  If so then we will
    // need to internalize a new label
    if (m_label->hasKeyword("CCSD3ZF0000100000001NJPL3IF0PDS200000001")) {
      if (!readWrite) {
        reformatOldIsisLabel(m_labelFileName->expanded());
      }
      else {
        QString msg = "Can not open [" + m_labelFileName->original() + "]"
                      " because it is an ISIS2 cube.";
        cleanUp(false);
        throw IException(IException::Io, msg, _FILEINFO_);
      }
    }
    else {
      m_labelFile = new QFile(m_labelFileName->expanded());
    }
  }
  void Cube::initLabelFromFile(FileName labelFileName, bool readWrite) {…}
 

  void Cube::openCheck() {
    if (isOpen()) {
      string msg = "Sorry you can't do a SetMethod after the cube is opened";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }
  void Cube::openCheck() {…}
 

  Pvl Cube::realDataFileLabel() const {
    Pvl label = *m_label;
    PvlObject *core = NULL;
 
    do {
      core = &label.findObject("IsisCube").findObject("Core");
 
      if (core->hasKeyword("^DnFile")) {
 
        FileName temp((*core)["^DnFile"][0]);
        if (!temp.expanded().startsWith("/")) {
          temp = realDataFileName();
        }
 
        label = Pvl(temp.toString());
        core = NULL;
      }
    }
    while (!core);
 
    return label;
  }
  Pvl Cube::realDataFileLabel() const  {…}
 

  void Cube::reformatOldIsisLabel(const QString &oldCube) {
    QString parameters = "from=" + oldCube;
    FileName oldName(oldCube);
    FileName tempCube = FileName::createTempFile("Temporary_" + oldName.name() + ".cub");
    parameters += " to=" + tempCube.expanded();
 
    if (iApp == NULL) {
      QString command = "$ISISROOT/bin/pds2isis " + parameters;
      ProgramLauncher::RunSystemCommand(command);
    }
    else {
      QString prog = "pds2isis";
      ProgramLauncher::RunIsisProgram(prog, parameters);
    }
 
    m_tempCube = new FileName(tempCube);
    *m_label = Pvl(m_tempCube->toString());
    m_labelFile = new QFile(m_tempCube->expanded());
  }
  void Cube::reformatOldIsisLabel(const QString &oldCube) {…}
 

  void Cube::latLonRange(double &minLatitude, double &maxLatitude, double &minLongitude, double &
                         maxLongitude) {
    Camera *cam;
    TProjection *proj;
 
    bool isGood = false;
    bool useProj = true;
 
    if (hasGroup("Instrument")) {
      useProj = false;
    }
 
    // setup camera or projection
    if (useProj) {
     try {
       proj = (TProjection *) projection();
     }
     catch(IException &e) {
       QString msg = "Cannot calculate lat/lon range without a camera or projection";
       throw IException(e, IException::User, msg, _FILEINFO_);
     }
    }
    else {
      try {
        cam = camera();
      }
      catch(IException &e) {
        QString msg = "Unable to create camera when calculating a lat/lon range.";
        throw IException(e, IException::User, msg, _FILEINFO_);
      }
    }
 
    // Iterate over all samp/line combos in cube
    minLatitude = 99999;
    minLongitude = 99999;
    maxLatitude = -99999;
    maxLongitude = -99999;
 
    for (double sample = 0.5; sample < sampleCount() + 0.5; sample++) {
    // Checks to see if the point is in outer space
      for (double line = 0.5; line < lineCount() + 0.5; line++) {
        if (useProj) {
          isGood = proj->SetWorld(sample, line);
        }
        else {
          isGood = cam->SetImage(sample, line);
        }
 
        double lat, lon;
        if (isGood) {
          if (useProj) {
            lat = proj->UniversalLatitude();
            lon = proj->UniversalLongitude();
          }
          else {
            lat = cam->UniversalLatitude();
            lon = cam->UniversalLongitude();
          }
 
          // update mix/max lat/lons
          if (lat < minLatitude) {
            minLatitude = lat;
          }
          else if (lat > maxLatitude) {
            maxLatitude = lat;
          }
 
          if (lon < minLongitude) {
            minLongitude = lon;
          }
          else if (lon > maxLongitude) {
            maxLongitude = lon;
          }
        }
      }
    }
    if ( (minLatitude == 99999) || (minLongitude == 99999) || (maxLatitude == -99999) ||
    (maxLongitude == -99999) ) {
      QString msg = "Unable to calculate a minimum or maximum latitutde or longitude.";
        throw IException(IException::Unknown, msg, _FILEINFO_);
    }
  }
  void Cube::latLonRange(double &minLatitude, double &maxLatitude, double &minLongitude, double & {…}

  void Cube::writeLabels() {
    if (!isOpen()) {
      string msg = "Cube must be opened first before writing labels";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    // Set the pvl's format template
    m_label->setFormatTemplate(m_formatTemplateFile->original());
 
    // Write them with attached data
    if (m_attached) {
      QMutexLocker locker(m_mutex);
      QMutexLocker locker2(m_ioHandler->dataFileMutex());
 
      ostringstream temp;
      temp << *m_label << endl;
      string tempstr = temp.str();
      if ((int) tempstr.length() < m_labelBytes) {
        QByteArray labelArea(m_labelBytes, '\0');
        QByteArray labelUnpaddedContents(tempstr.c_str(), tempstr.length());
        labelArea.replace(0, labelUnpaddedContents.size(), labelUnpaddedContents);
        // Rewrite the label area
        m_labelFile->seek(0);
        m_labelFile->write(labelArea);
      }
      else {
        locker2.unlock();
        QString msg = "Label space is full in [" +
            (QString)FileName(*m_labelFileName).name() +
                     "] unable to write labels";
        cleanUp(false);
        throw IException(IException::Io, msg, _FILEINFO_);
      }
    }
 
    // or detached label
    else {
      m_label->write(m_labelFileName->expanded());
    }
  }
  void Cube::writeLabels() {…}
}