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 "IEndian.h"
#include "FileName.h"
#include "GdalIoHandler.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(const FileName &fileName, QString access) {
    construct();
    open(fileName.toString(), 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::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, 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");
  }

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

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

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

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

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

  Cube::LabelAttachment Cube::labelsAttached() const {
    return m_attached;
  }
 

  void Cube::close(bool removeIt) {
    if (isOpen() && isReadWrite())
      writeLabels();
 
    cleanUp(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;
    result->setLabelsAttached(newFileAttributes.labelAttachment());
 
    if (result->labelsAttached() != ExternalLabel) {
      result->setDimensions(sampleCount(), lineCount(), bandCount());
      result->setByteOrder(newFileAttributes.byteOrder());
      result->setFormat(newFileAttributes.fileFormat());
 
      // if (newFileAttributes.labelAttachment() == DetachedLabel) {
      // }
 
      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;
  }
 

  void Cube::create(const QString &imageFileName) {
    // 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(imageFileName),
          _FILEINFO_);
    }
 
    if (labelsAttached() == LabelAttachment::AttachedLabel) {
      // 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 [" + imageFileName + "] 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 imageFile(imageFileName);
    PvlObject isiscube("IsisCube");
    PvlObject core("Core");
 
    // 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));
 
    // 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));
 
    if (labelsAttached() != LabelAttachment::ExternalLabel) {
      if (format() != Format::GTiff) {
        imageFile = imageFile.addExtension("cub");
      }
      else if (format() == Format::GTiff) {
        if (imageFile.extension() != "tif" &&
            imageFile.extension() != "tiff") {
          imageFile = imageFile.addExtension("tif");
        }
      }
      else {
        QString msg = "Unknown format type [" + toString(format()) + "]";
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }
 
      m_dataFileName = new FileName(imageFile);
 
      // See if we have attached or detached labels
      if (labelsAttached() == LabelAttachment::AttachedLabel) {
        // StartByte is 1-based (why!!) so we need to do + 1
        core += PvlKeyword("StartByte", toString(m_labelBytes + 1));
        m_labelFileName = new FileName(imageFile);
        m_labelFile = new QFile(m_labelFileName->expanded());
      }
      else if (labelsAttached() == LabelAttachment::DetachedLabel) {
        core += PvlKeyword("StartByte", toString(1));
        core += PvlKeyword("^Core", imageFile.name());
        m_dataFile = new QFile(realDataFileName().expanded());
 
        FileName labelFileName(imageFile);
        labelFileName = labelFileName.setExtension("lbl");
        m_labelFileName = new FileName(labelFileName);
        m_labelFile = new QFile(m_labelFileName->expanded());
      }
      else {
        QString msg = "Label type [" + LabelAttachmentName(labelsAttached()) + "] not supported";
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }
      core.addGroup(dims);
      core.addGroup(ptype);
    }
    else if (labelsAttached() == LabelAttachment::ExternalLabel) {
      imageFile = imageFile.addExtension("ecub");
      if (!m_dataFileName) {
        if (format() == Bsq || format() == Tile) {
          imageFile = imageFile.setExtension("cub");
 
          Pvl dnLabel;
          PvlObject isiscube("IsisCube");
          PvlObject dnCore(core);
          PvlKeyword fileFormat("Format", CubeAttributeOutput::toString(format()));
 
          dnCore.addKeyword(fileFormat);
          dnCore.addGroup(dims);
          dnCore.addGroup(ptype);
 
          isiscube.addObject(dnCore);
          dnLabel.addObject(isiscube);
 
          Cube dnCube;
          dnCube.fromLabel(imageFile, dnLabel, "rw");
          dnCube.close();
        }
        else if (format() ==  Format::GTiff) {
          imageFile = imageFile.setExtension("tif");
        }
        m_dataFileName = new FileName(imageFile);
        
        imageFile = imageFile.setExtension("ecub");
        FileName labelFileName(imageFile);
        m_labelFileName = new FileName(labelFileName);
        m_labelFile = new QFile(m_labelFileName->expanded());
      }
 
      core += PvlKeyword("^DnFile", m_dataFileName->name());
      m_dataFile = new QFile(m_dataFileName->expanded());
 
      m_labelFileName = new FileName(imageFile);
      m_labelFile = new QFile(m_labelFileName->expanded());
    }
    else {
      QString msg = "Label type [" + LabelAttachmentName(labelsAttached()) + "] not supported";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    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 (labelsAttached() != ExternalLabel && !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 (labelsAttached() == ExternalLabel && !m_dataFile->open(QIODevice::ReadWrite)) {
        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 = (labelsAttached() == ExternalLabel);
 
    if (format() != GTiff) {
      if (format() == Bsq) {
        m_ioHandler = new CubeBsqHandler(dataFile(), m_virtualBandList, realDataFileLabel(),
                                        dataAlreadyOnDisk);
      }
      else if(format() == Tile) {
        m_ioHandler = new CubeTileHandler(dataFile(), m_virtualBandList, realDataFileLabel(),
                                          dataAlreadyOnDisk);
      }
 
      if (!dataAlreadyOnDisk) {
        m_ioHandler->updateLabels(*m_label);
      }
    }
    else if(format() ==  Format::GTiff) {
      char **papszOptions = NULL;
      // 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
 
      papszOptions = CSLSetNameValue(papszOptions, "PREDICTOR", "2");
      papszOptions = CSLSetNameValue(papszOptions, "NUM_THREADS", "4");
      if (size < 4) {
        papszOptions = CSLSetNameValue(papszOptions, "COMPRESS", "DEFLATE");
      }
      else {
        papszOptions = CSLSetNameValue(papszOptions, "COMPRESS", "LZW");
        papszOptions = CSLSetNameValue(papszOptions, "BIGTIFF", "YES");
      }
 
      QString datafile = m_dataFileName->expanded();
      QString format = "GTiff";
      createGdal(datafile, format, papszOptions);
 
      m_geodataSet = GDALDataset::FromHandle(GDALOpen(datafile.toStdString().c_str(), GA_Update));
      if (!m_geodataSet) {
        QString msg = "Failed opening GDALDataset from [" + m_dataFileName->name() + "]";
        cleanUp(false);
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }
 
      m_ioHandler = new GdalIoHandler(gdalDataset(), m_virtualBandList, IsisPixelToGdal(pixelType()));
      m_ioHandler->updateLabels(*m_label);
    }
    else {
      QString msg = "Format [" + toString(format()) + "] not supported";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    // Write the labels
    writeLabels();
  }
 
  void Cube::createGdal(QString &dataFileName, QString &driverName, char **papszOptions) {
    GDALDriver* driver = GetGDALDriverManager()->GetDriverByName(driverName.toStdString().c_str());
    if (driver) {
      double noDataValue;
      switch (pixelType()) {
        case UnsignedByte:
          noDataValue = (double) NULL1;
          break;
        case SignedByte:
          noDataValue = (double) NULLS1;
          break;
        case UnsignedWord:
          noDataValue = (double) NULLU2;
          break;
        case SignedWord:
          noDataValue = (double) NULL2;
          break;
        case UnsignedInteger:
          noDataValue = (double) NULLUI4;
          break;
        case SignedInteger:
          noDataValue = (double) NULLI4;
          break;
        case Real:
          noDataValue = (double) NULL4;
          break;
 
        default:
          noDataValue = NULL8;
          break;
      }
      GDALDataset *dataset = driver->Create(dataFileName.toStdString().c_str(), sampleCount(), lineCount(), bandCount(), IsisPixelToGdal(pixelType()), papszOptions);
      if (!dataset) {
        QString msg = "Could not create file [" + dataFileName + "] from [" + driverName + "] Driver.";
        throw IException(IException::Io, msg, _FILEINFO_);
      }
      for (int i = 1; i <= bandCount(); i++) {
        GDALRasterBand *band = dataset->GetRasterBand(i);
        band->SetScale(multiplier());
        band->SetOffset(base());
        band->SetNoDataValue(noDataValue);
        band->Fill(noDataValue);
        band->CreateMaskBand(GMF_ALPHA);
        band->GetMaskBand()->Fill(255);
      }
      GDALClose(dataset);
      CSLDestroy( papszOptions );
    } 
    else {
      QString msg = "No Driver found for name [" + driverName + "]";
      throw IException(IException::Io, msg, _FILEINFO_);
    }
  }
 

  void Cube::create(
      const QString &cubeFileName, const CubeAttributeOutput &att) {
 
    setByteOrder(att.byteOrder());
    setFormat(att.fileFormat());
    setLabelsAttached(att.labelAttachment());
    if (!att.propagatePixelType())
      setPixelType(att.pixelType());
    setMinMax(att.minimum(), att.maximum());
 
    // Allocate the cube
    create(cubeFileName);
  }
 
  void Cube::checkAccess(QString access) {
    if (!(access == "r" || access == "rw")) {
      QString msg = "Unknown value for access [" + access + "]. Expected 'r' "
                    " or 'rw'";
      cleanUp(false);
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }
 

  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_);
    }
 
    checkAccess(access);
 
    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
    }
 
    QString msg = "Failed to open [" + cubeFileName + "]";
    IException exceptions(IException::Io, msg, _FILEINFO_);
 
    GDALDriverH hDriver = GDALIdentifyDriver(FileName(cubeFileName).expanded().toStdString().c_str(), nullptr);
    bool openWithGdal = false;
    if (hDriver != nullptr) {
      GDALDriver* poDriver = (GDALDriver*)hDriver;
      QString driverDescription = poDriver->GetDescription();
      openWithGdal = (!driverDescription.contains("ISIS"));
    }
 
    try{
      if (openWithGdal) {
        openGdal(cubeFileName, access);
      }
      else {
        openCube(cubeFileName, access);
      }
    }
    catch(IException &e) {
      cleanUp(false);
      exceptions.append(e);
      throw exceptions;
    }
 
    applyVirtualBandsToLabel();
  }

  void Cube::openCube(const QString &cubeFileName, QString access) {
    checkAccess(access);
 
    initLabelFromFile(cubeFileName, (access == "rw"));
 
    // 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);
        }
        setLabelsAttached(LabelAttachment::DetachedLabel);
 
        FileName realDataFile = realDataFileName();
        delete m_dataFileName;
        m_dataFileName = new FileName(realDataFile.expanded());
 
        m_dataFile = new QFile(m_dataFileName->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);
        }
        setLabelsAttached(LabelAttachment::ExternalLabel);
 
        FileName realDataFile = realDataFileName();
        delete m_dataFileName;
        m_dataFileName = new FileName(realDataFile.expanded());
 
        m_dataFile = new QFile(m_dataFileName->expanded());
      }
      // Typical cube containing labels, SPICE, history and dn data
      else {
        setLabelsAttached(LabelAttachment::AttachedLabel);
        m_dataFileName = new FileName(*m_labelFileName);
      }
    }
    catch (IException &e) {
      cleanUp(false);
      throw e;
    }
 
    QIODevice::OpenModeFlag qtAccess = QIODevice::ReadOnly;
    GDALAccess eAccess = GA_ReadOnly;
    if (access == "rw") {
      qtAccess = QIODevice::ReadWrite;
      eAccess = GA_Update;
    }
 
    if (!m_labelFile->open(qtAccess)) {
        QString msg = "Failed to open [" + m_labelFile->fileName() + "] with "
                    "access [" + access + "]";
        cleanUp(false);
        throw IException(IException::Io, msg, _FILEINFO_);
      }
 
      if (m_dataFile) {
        if (!m_dataFile->open(qtAccess)) {
            QString msg = "Failed to open [" + m_dataFile->fileName() + "] with "
                      "access [" + access + "]";
            cleanUp(false);
            throw IException(IException::Io, msg, _FILEINFO_);
        }
    }
 
    initCoreFromLabel(*m_label);
 
    // Determine the number of bytes in the label
    if (labelsAttached() != LabelAttachment::DetachedLabel) {
      m_labelBytes = m_label->findObject("Label")["Bytes"];
    }
    else {
      m_labelBytes = labelSize(true);
    }
 
    // 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 if (m_format == Tile) {
      m_ioHandler = new CubeTileHandler(dataFile(), m_virtualBandList,
          realDataFileLabel(), true);
    }
    else if (m_format == GTiff) {
      if (m_dataFile) {
        m_dataFile->close();
      }
      m_geodataSet = GDALDataset::FromHandle(GDALOpen(m_dataFileName->expanded().toStdString().c_str(), eAccess));
      if (!m_geodataSet) {
        QString msg = "Opening GDALDataset from [" + m_dataFileName->name() + "] failed with access [" + QString::number(eAccess) +"]";
        cleanUp(false);
        throw IException(IException::Io, msg, _FILEINFO_);
      }
      m_ioHandler = new GdalIoHandler(gdalDataset(), m_virtualBandList, IsisPixelToGdal(pixelType()));
    }
    else {
      QString msg = "Unknown format [" + toString(m_format) + "]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }

  void Cube::openGdal(const QString &cubeFileName, QString access) {
    checkAccess(access);
 
    m_labelFileName = new FileName(cubeFileName);
 
    setLabelsAttached(LabelAttachment::AttachedLabel);
    m_dataFileName = new FileName(*m_labelFileName);
 
    initCoreFromGdal(m_labelFileName->expanded());
 
    m_label = new Pvl(m_dataFileName->expanded());
    
    GDALAccess eAccess = GA_ReadOnly;
    if (access == "rw") {
      eAccess = GA_Update;
    }
    m_geodataSet = GDALDataset::FromHandle(GDALOpen(m_dataFileName->expanded().toStdString().c_str(), eAccess));
    if (!m_geodataSet) {
      QString msg = "Opening GDALDataset from [" + m_dataFileName->name() + "] failed with access [" + QString::number(eAccess) +"]";
      cleanUp(false);
      throw IException(IException::Io, msg, _FILEINFO_);
    }
 
    m_ioHandler = new GdalIoHandler(gdalDataset(), m_virtualBandList, IsisPixelToGdal(pixelType()));
    m_ioHandler->updateLabels(*m_label);
  }
 

  void Cube::reopen(QString access) {
    if (!isOpen()) {
      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::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_);
    }
 
    QMutexLocker locker(m_mutex);
 
    FileName cubeFile = *m_labelFileName;
    if (m_tempCube)
      cubeFile = *m_tempCube;
 
    QString blobKey = blob.Key();
    if (m_blobMap.contains(blobKey)) {
      blob = m_blobMap[blobKey];
    }
    else {
      if (format() == Format::GTiff && labelsAttached() == LabelAttachment::AttachedLabel) {
        blob.ReadGdal(gdalDataset());
      }
      else {
        QMutexLocker locker2(m_ioHandler->dataFileMutex());
        blob.Read(cubeFile.toString(), *label(), keywords);
      }
    }
  }
 

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

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

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

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

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

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

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

  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 (isReadOnly()) {
      string msg = "The cube must be opened in read/write mode, not readOnly";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    QMutexLocker locker(m_mutex);
 
    Pvl &cubeLabel = *label();
    PvlObject &blobLabel = blob.Label();
    if (labelsAttached() == LabelAttachment::DetachedLabel) {
        FileName blobFileName = fileName();
        blobFileName = blobFileName.removeExtension();
        blobFileName = blobFileName.addExtension(blob.Type());
        blobFileName = blobFileName.addExtension(blob.Name());
        blobLabel += PvlKeyword("^" + blob.Type(), blobFileName.name());
    }
 
    // See if the blob is already in the file
    bool found = false;
    if (overwrite) {
      for (int i = 0; i < cubeLabel.objects(); i++) {
        if (cubeLabel.object(i).name() == blobLabel.name()) {
          PvlObject &obj = cubeLabel.object(i);
          if ((QString)obj["Name"] == (QString)blobLabel["Name"]) {
            found = true;
            blobLabel["StartByte"] = obj["StartByte"];
            blobLabel["Bytes"] = obj["Bytes"];
          }
        }
      }
    }
    if (!found) {
      blobLabel["StartByte"] = toString(0);
      cubeLabel.addObject(blobLabel);
    }
    m_blobMap[blob.Key()] = blob;
    m_blobQueue.push_back(blob.Key());
  }
 

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

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

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

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

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

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

  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 (labelsAttached() == ExternalLabel) {
    //   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::setBaseMultiplier(double base, double mult) {
    openCheck();
    m_base = base;
    m_multiplier = mult;
  }
 

  void Cube::setMinMax(double min, double max) {
    openCheck();
 
    m_base = 0.0;
    m_multiplier = 1.0;
 
    double x1 = 0.0, x2 = 0.0;
    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::setByteOrder(ByteOrder byteOrder) {
    openCheck();
    m_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::setExternalDnData(FileName cubeFileWithDnData) {
    try {
      initLabelFromFile(cubeFileWithDnData, false);
      initCoreFromLabel(*m_label);
 
      delete m_label;
      m_label = NULL;
    }
    catch (IException &e) {
      delete m_label;
      m_label = NULL;
      throw e;
    }
 
    setLabelsAttached(Cube::ExternalLabel);
    m_dataFileName = new FileName(cubeFileWithDnData);
    FileName realDataFile = realDataFileName();
    delete m_dataFileName;
    m_dataFileName = new FileName(realDataFile.expanded());
 
    delete m_labelFile;
    m_labelFile = NULL;
 
    delete m_labelFileName;
    m_labelFileName = NULL;
  }
 

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

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

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

  void Cube::setPixelType(PixelType pixelType) {
    openCheck();
    m_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 std::vector<QString> &vbands) {
    QList<QString> realVBands;
 
    for(unsigned int i = 0; i < vbands.size(); i++)
      realVBands << vbands[i];
 
    setVirtualBands(realVBands);
  }
 

  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 (labelsAttached() != ExternalLabel) {
      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 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;
  }
 

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

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

  Camera *Cube::camera() {
    if (m_camera == NULL && isOpen()) {
      m_camera = CameraFactory::Create(*this);
    }
    return m_camera;
  }
 
 
  void Cube::attachSpiceFromIsd(nlohmann::json isd) {
    PvlGroup currentKernels = this->group("Kernels");
    PvlKeyword lkKeyword = currentKernels["LeapSecond"];
    PvlKeyword pckKeyword = currentKernels["TargetAttitudeShape"];
    PvlKeyword targetSpkKeyword = currentKernels["TargetPosition"];
    PvlKeyword ckKeyword = currentKernels["InstrumentPointing"];
    PvlKeyword ikKeyword = currentKernels["Instrument"];
    PvlKeyword sclkKeyword = currentKernels["SpacecraftClock"];
    PvlKeyword spkKeyword = currentKernels["InstrumentPosition"];
    PvlKeyword iakKeyword = currentKernels["InstrumentAddendum"];
    PvlKeyword demKeyword = currentKernels["ShapeModel"];
 
    Spice spice(*this, *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);
    
    //  Save original kernels in keyword before changing to Table
    if (ckKeyword[0] != "Table") {
      currentKernels["InstrumentPointing"] = "Table";
      for (int i = 0; i < ckKeyword.size(); i++)
        currentKernels["InstrumentPointing"].addValue(ckKeyword[i]);
    }
 
    if (spkKeyword[0] != "Table") {
      currentKernels["InstrumentPosition"] = "Table";
      for (int i = 0; i < spkKeyword.size(); i++)
        currentKernels["InstrumentPosition"].addValue(spkKeyword[i]);
    }
 
    if (targetSpkKeyword[0] != "Table") {
      currentKernels["TargetPosition"] = "Table";
      for (int i = 0; i < targetSpkKeyword.size(); i++)
        currentKernels["TargetPosition"].addValue(targetSpkKeyword[i]);
    }
 
    putGroup(currentKernels);
 
    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 (labelsAttached() == ExternalLabel) {
      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];
  }
 

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

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

  Histogram *Cube::histogram(const int &band, QString msg) {
    return histogram(band, ValidMinimum, ValidMaximum, 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;
  }
 

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

  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::lineCount() const {
    return m_lines;
  }
 

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

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

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

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

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

  Statistics *Cube::statistics(const int &band, QString msg) {
    return statistics(band, ValidMinimum, ValidMaximum, 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;
  }
 

  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::clearIoCache() {
    if (m_ioHandler) {
      QMutexLocker locker(m_mutex);
      m_ioHandler->clearCache();
    }
  }
 

  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);
          QString key = BlobType + "_" + BlobName;
 
          if (gdalDataset()) {
            CPLStringList metadata = CPLStringList(gdalDataset()->GetMetadata("json:ISIS3"), false);
            const char *metadataJsonString = metadata[0];
            nlohmann::ordered_json jsonblob = nlohmann::ordered_json::parse(metadataJsonString);
 
            bool keyErased = jsonblob.erase(key.toStdString());
            string jsonblobstr = jsonblob.dump();
 
            char **outputMetadata = new char*[1];
            outputMetadata[0] = jsonblobstr.data();
            gdalDataset()->SetMetadata(outputMetadata, "json:ISIS3");
            delete []outputMetadata;
            
            return keyErased;
          }
 
          if (m_blobMap.contains(key)) {
            m_blobMap.remove(key);
            m_blobQueue.removeOne(key);
          }
          return true;
        }
      }
    }
    return false;
  }
 

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

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

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

  bool Cube::hasBlob(const QString &name, const QString &type) {
    QMutexLocker locker(m_mutex);
 
    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::hasTable(const QString &name) {
    return hasBlob(name, "Table");
  }
 

  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::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((int)m_virtualBandList->size());
  }
 

  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;
 
    if (m_geodataSet) {
      GDALClose(m_geodataSet);
    }
    m_geodataSet = 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::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();
  }
 

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

  FileName Cube::realDataFileName() const {
    FileName result;
 
    // Attached, stores DN data - normal cube
    if (labelsAttached() == LabelAttachment::AttachedLabel) {
      result = *m_labelFileName;
    }
    // Detached, stores DN data - standard detached cube
    else if (labelsAttached() == LabelAttachment::DetachedLabel) {
      result = *m_dataFileName;
    }
    // External cube - go look at our external file
    else if (labelsAttached() == LabelAttachment::ExternalLabel) {
      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 {
        Cube dataCube(guess.expanded());
        Pvl guessLabel = *(dataCube.label());
 
        if (guessLabel.hasObject("IsisCube")) {
          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;
          }
        }
        else {
          result = guess;
        }
      }
      while (result.name() == "");
    }
 
    return result;
  }
 

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

  void Cube::initCoreFromLabel(const Pvl &label) {
    initialize();
    initLabelState(label);
    const PvlObject &core = label.findObject("IsisCube").findObject("Core");
 
    if (labelsAttached() != ExternalLabel) {
      // 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 = Format::Bsq;
      }
      else if ((QString) core["Format"] == "Tile") {
        m_format = Format::Tile;
      }
      else if ((QString) core["Format"] == "GTiff") {
        m_format = Format::GTiff;
      }
      else {
        QString msg = "Unknown format [" + (QString)core["Format"] + "]";
        throw IException(IException::Io, msg, _FILEINFO_);
      }
    }
    else {
      FileName temp(core["^DnFile"][0]);
      if (!temp.expanded().startsWith("/")) {
        temp = FileName(m_labelFileName->path() + "/" + temp.original());
      }
      try {
        initCoreFromLabel(Pvl(temp.toString()));
      }
      catch (IException &e) {
        initCoreFromGdal(temp.toString());
      }
      // Reset the label state as we recurse back out from initCoreFromLabel calls
      initLabelState(label);
    }
  }
 
 
  void Cube::initCoreFromGdal(const QString &labelFile) {
    GDALDataset *geodataSet = GDALDataset::FromHandle(GDALOpen(labelFile.toStdString().c_str(), GA_ReadOnly));
    if (!geodataSet) {
      QString msg = "Gdal failed to open [" + labelFile + "]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    setFormat(GTiff);
    setDimensions(geodataSet->GetRasterXSize(), geodataSet->GetRasterYSize(), geodataSet->GetRasterCount());
 
    GDALRasterBand *band = geodataSet->GetRasterBand(1);
    setPixelType(GdalPixelToIsis(band->GetRasterDataType()));
    setBaseMultiplier(band->GetOffset(), band->GetScale());
    GDALClose(geodataSet);
  }

  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::openCheck() {
    if (isOpen()) {
      string msg = "Sorry you can't do a SetMethod after the cube is opened";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }
 

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

  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::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::writeLabels() {
    if (!isOpen()) {
      string msg = "Cube must be opened first before writing labels";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    if (isReadOnly()) {
      string msg = "The cube must be opened in read/write mode, not readOnly";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    
    if (m_format == Format::GTiff) {
 
      nlohmann::ordered_json jsonOut;
 
      // Check for existing data, if there is data update it
      CPLStringList metadata = CPLStringList(gdalDataset()->GetMetadata("json:ISIS3"), false);
 
      if (metadata[0] != nullptr) {
        const char *metadataJsonString = metadata[0];
        jsonOut = nlohmann::ordered_json::parse(metadataJsonString);
      }
 
      // update metadata
      nlohmann::ordered_json jsonblob = this->label()->toJson()["Root"];
      for (auto& [key, val] : jsonblob.items()) {
        if (!val.contains("Bytes") || key == "Label") {
          jsonOut[key] = val;
        }
      }
 
      for (QString blobKey : m_blobQueue) {
        Blob &blob = m_blobMap[blobKey];
 
        std::string blobJsonStr = "{}";
        blob.WriteGdal(blobJsonStr);
        nlohmann::ordered_json blobJson = nlohmann::ordered_json::parse(blobJsonStr);
        jsonOut.update(blobJson);
      }
      m_blobMap.clear();
      m_blobQueue.clear();
      std::string jsonOutStr = jsonOut.dump();
 
      char ** outputMetadata = new char*[1];
      outputMetadata[0] = jsonOutStr.data();
      gdalDataset()->SetMetadata(outputMetadata, "json:ISIS3");
      delete []outputMetadata;
 
      if (this->label()->findObject("IsisCube").hasGroup("Mapping")) {
        PvlGroup &mappingGroup = this->label()->findObject("IsisCube").findGroup("Mapping");
 
        if (mappingGroup.hasKeyword("ProjStr")) {
          OGRSpatialReference *oSRS = new OGRSpatialReference();
          oSRS->SetFromUserInput(mappingGroup.findKeyword("ProjStr")[0].toStdString().c_str());
 
          gdalDataset()->SetSpatialRef(oSRS);
 
          double dfRes = (double)mappingGroup.findKeyword("PixelResolution") / oSRS->GetLinearUnits();
          double upperLeftX = (double) mappingGroup.findKeyword("UpperLeftCornerX");
          double upperLeftY = (double) mappingGroup.findKeyword("UpperLeftCornerY");
          double *padfTransform = new double[6];
          padfTransform[1] = dfRes;
          padfTransform[5] = -dfRes;
          padfTransform[0] = upperLeftX;
          padfTransform[3] = upperLeftY;
          gdalDataset()->SetGeoTransform(padfTransform);
          delete oSRS;
          delete[] padfTransform;
        }
      }
 
 
      return;
    }
 
    // Set the pvl's format template
    m_label->setFormatTemplate(m_formatTemplateFile->original());
 
    // Write them with attached label and blob data
    if (labelsAttached() != LabelAttachment::DetachedLabel) {
      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);
 
      // maxbyte = position after the cube DN data and labels
      streampos maxbyte = (streampos) m_labelBytes;
 
      if (labelsAttached() == LabelAttachment::AttachedLabel) {
        maxbyte += (streampos) m_ioHandler->getDataSize();
      }
      for (QString blobKey : m_blobQueue) {
        Blob &blob = m_blobMap[blobKey];
 
        stream.seekp(0, ios::end);
 
        // End byte = end byte of the file (aka eof position, file size)
        streampos endByte = stream.tellp();
 
        // If EOF is too early, allocate space up to where we want the blob
        if (endByte < maxbyte) {
          stream.seekp(maxbyte, ios::beg);
        }
 
        streampos eofbyte = stream.tellp();
        eofbyte += 1;
 
        PvlObject &blobLabel = blob.Label();
 
        BigInt oldSbyte = blobLabel["StartByte"];
        int oldNbytes = (int) blobLabel["Bytes"];
 
        if (oldSbyte == 0) {
          blobLabel["StartByte"] = toString((BigInt)eofbyte);
        }
        else {
          // Does it fit in the old space
          if (blob.Size() <= oldNbytes) {
            stream.seekp(oldSbyte - 1, ios::beg);
          }
          // Was the old space at the end of the file
          else if ((oldSbyte + oldNbytes) == eofbyte) {
            stream.seekp(oldSbyte - 1, ios::beg);
          }
        }
 
        // Use default argument of "" for detached stream
        try {
          blob.Write(*label(), stream);
        }
        catch (IException &e) {
          QString msg = "Failed to write blob [" + blob.Type() + ", " + blob.Name() + "]";
          throw IException(e, IException::Io, msg, _FILEINFO_);
          stream.close();
        }
        stream.flush();
      }
      m_blobMap.clear();
      m_blobQueue.clear();
      stream.close();
 
      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 {
      for (QString blobKey : m_blobQueue) {
        Blob &blob = m_blobMap[blobKey];
 
        FileName blobFileName(blob.Label().findKeyword("^" + blob.Type())[0]);
        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_);
        }
 
        try {
          blob.Write(*label(), detachedStream);
        }
        catch (IException &e) {
          QString msg = "Failed to write blob [" + blob.Type() + ", " + blob.Name() + "]";
          throw IException(e, IException::Io, msg, _FILEINFO_);
          detachedStream.close();
        }
        detachedStream.flush();
        detachedStream.close();
      }
      m_blobMap.clear();
      m_blobQueue.clear();
 
      m_label->write(m_labelFileName->expanded());
    }
  }
 
  void Cube::initLabelState(const Pvl &label) {
    const PvlObject &core = label.findObject("IsisCube").findObject("Core");
    LabelAttachment attachmentStyle = AttachedLabel;
    if (core.hasKeyword("^DnFile")) {
      attachmentStyle = ExternalLabel;
    }
    else if (core.hasKeyword("^Core")) {
      attachmentStyle = DetachedLabel;
    }
 
    setLabelsAttached(attachmentStyle);
  }
}