RawCubeChunk.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "IsisDebug.h"
#include "RawCubeChunk.h"
 
#include <cmath>
#include <iostream>
 
#include <QByteArray>
 
#include "Area3D.h"
#include "Displacement.h"
#include "Distance.h"
#include "IException.h"
#include "IString.h"
 
namespace Isis {
  RawCubeChunk::RawCubeChunk(const Area3D &placement, int numBytes) {
    m_dirty = false;
 
    m_rawBuffer = new QByteArray(numBytes, '\0');
    m_rawBufferInternalPtr = m_rawBuffer->data();
 
    m_sampleCount = (int)round(placement.getWidth().pixels()) + 1;
    m_lineCount = (int)round(placement.getHeight().pixels()) + 1;
    m_bandCount = (int)round(placement.getDepth().pixels()) + 1;
 
    m_startSample = (int)round(placement.getStartX().pixels());
    m_startLine = (int)round(placement.getStartY().pixels());
    m_startBand = (int)round(placement.getStartZ().pixels());
  }
 
  RawCubeChunk::RawCubeChunk(int startSample, int startLine, int startBand,
                             int endSample, int endLine, int endBand,
                             int numBytes) {
    m_dirty = false;
 
    m_rawBuffer = new QByteArray(numBytes, '\0');
    m_rawBufferInternalPtr = m_rawBuffer->data();
 
    m_sampleCount = endSample - startSample + 1;
    m_lineCount = endLine - startLine + 1;
    m_bandCount = endBand - startBand + 1;
 
    m_startSample = startSample;
    m_startLine = startLine;
    m_startBand = startBand;
  }
 
 
  RawCubeChunk::~RawCubeChunk() {
    if(m_rawBuffer) {
      delete m_rawBuffer;
      m_rawBuffer = NULL;
      m_rawBufferInternalPtr = NULL;
    }
  }
 
 
  bool RawCubeChunk::isDirty() const {
    return m_dirty;
  }
 
 
  void RawCubeChunk::setRawData(QByteArray rawData) {
    if(rawData.size() != m_rawBuffer->size()) {
      IString msg = "Cannot set raw data on a RawCubeChunk with a differently "
          "sized data array";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    m_dirty = true;
    *m_rawBuffer = rawData;
    m_rawBufferInternalPtr = m_rawBuffer->data();
  }
 
 
  unsigned char RawCubeChunk::getChar(int offset) const {
    return ((unsigned char *)m_rawBuffer->data())[offset];
  }
 
  short RawCubeChunk::getShort(int offset) const {
    return ((short *)m_rawBuffer->data())[offset];
  }
 
  float RawCubeChunk::getFloat(int offset) const {
    return ((float *)m_rawBuffer->data())[offset];
  }
 
 
  int RawCubeChunk::getByteCount() const {
    if(m_rawBuffer)
      return m_rawBuffer->size();
    else
      return -1;
  }
 
 
  void RawCubeChunk::setData(unsigned char value, int offset) {
    ASSERT(offset < getByteCount());
 
    m_dirty = true;
    m_rawBufferInternalPtr[offset] = value;
  }
 
 
  void RawCubeChunk::setData(short value, int offset) {
    ASSERT((int)(offset * sizeof(short)) < getByteCount());
 
    m_dirty = true;
    ((short *)m_rawBufferInternalPtr)[offset] = value;
  }
 
 
  void RawCubeChunk::setData(const float &value, const int &offset) {
    ASSERT((int)(offset * sizeof(float)) < getByteCount());
 
    m_dirty = true;
    ((float *)m_rawBufferInternalPtr)[offset] = value;
  }
 
 
  void RawCubeChunk::setDirty(bool dirty) {
    m_dirty = dirty;
  }
}