CubeBsqHandler.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "CubeBsqHandler.h"
 
#include <iostream>
 
#include <QFile>
 
#include "IException.h"
#include "Pvl.h"
#include "PvlKeyword.h"
#include "PvlObject.h"
#include "RawCubeChunk.h"
 
using namespace std;
 
namespace Isis {
  CubeBsqHandler::CubeBsqHandler(QFile * dataFile,
      const QList<int> *virtualBandList, const Pvl &labels, bool alreadyOnDisk)
    : CubeIoHandler(dataFile, virtualBandList, labels, alreadyOnDisk) {
    int numSamplesInChunk = sampleCount();
    int numLinesInChunk = 1;
    QList<int> primeFactors;
 
    // we want our chunk sizes to be less than 1GB
    int sizeLimit = 1024 * 1024 * 1024;
    int maxNumLines = (sizeLimit) / (SizeOf(pixelType()) * numSamplesInChunk);
 
    // we've exceed our sizeLimit; increase our limit so we can process an entire line
    if (maxNumLines == 0)
      maxNumLines = 1;
 
    numLinesInChunk = findGoodSize(maxNumLines, lineCount());
 
    setChunkSizes(numSamplesInChunk, numLinesInChunk, 1);
  }
 

  CubeBsqHandler::~CubeBsqHandler() {
    clearCache();
  }
 

  void CubeBsqHandler::updateLabels(Pvl &label) {
    PvlObject &core = label.findObject("IsisCube").findObject("Core");
    core.addKeyword(PvlKeyword("Format", "BandSequential"),
                    PvlContainer::Replace);
  }
 
 
  void CubeBsqHandler::readRaw(RawCubeChunk &chunkToFill) {
    BigInt startByte = getChunkStartByte(chunkToFill);
 
    bool success = false;
 
    QFile * dataFile = getDataFile();
    if(dataFile->seek(startByte)) {
      QByteArray binaryData = dataFile->read(chunkToFill.getByteCount());
 
      if(binaryData.size() == chunkToFill.getByteCount()) {
        chunkToFill.setRawData(binaryData);
        success = true;
      }
    }
 
    if(!success) {
      IString msg = "Reading from the file [" + dataFile->fileName() + "] "
          "failed with reading [" +
          QString::number(chunkToFill.getByteCount()) +
          "] bytes at position [" + QString::number(startByte) + "]";
      throw IException(IException::Io, msg, _FILEINFO_);
    }
  }
 
 
  void CubeBsqHandler::writeRaw(const RawCubeChunk &chunkToWrite) {
    BigInt startByte = getChunkStartByte(chunkToWrite);
 
    bool success = false;
 
    QFile * dataFile = getDataFile();
    if(dataFile->seek(startByte)) {
      BigInt dataWritten = dataFile->write(chunkToWrite.getRawData());
 
      if(dataWritten == chunkToWrite.getByteCount()) {
        success = true;
      }
    }
 
    if(!success) {
      IString msg = "Writing to the file [" + dataFile->fileName() + "] "
          "failed with writing [" +
          QString::number(chunkToWrite.getByteCount()) +
          "] bytes at position [" + QString::number(startByte) + "]";
      throw IException(IException::Io, msg, _FILEINFO_);
    }
  }
 

  int CubeBsqHandler::findGoodSize(int maxSize, int dimensionSize) const {
    int chunkDimensionSize;
 
    if (dimensionSize <= maxSize) {
      chunkDimensionSize = dimensionSize;
    }
    else {
      // find largest divisor of dimension size so chunks fit into cube uniformly
      int greatestDivisor = maxSize;
      while (dimensionSize % greatestDivisor > 0) {
        greatestDivisor--;
      }
      chunkDimensionSize = greatestDivisor;
    }
    return chunkDimensionSize;
  }
 

  BigInt CubeBsqHandler::getChunkStartByte(const RawCubeChunk &chunk) const {
    return getDataStartByte() + getChunkIndex(chunk) * getBytesPerChunk();
  }
}