RawCubeChunk.cpp

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