Buffer.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "PixelType.h"
#include "Buffer.h"
#include "IException.h"
#include "Message.h"
 
#include <iostream>
 
using namespace std;
 
namespace Isis {
 
  Buffer::Buffer() : p_sample(0), p_nsamps(0), p_line(0), p_nlines(0),
    p_band(0), p_nbands(0), p_npixels(0), p_buf(0),
    p_pixelType(None), p_rawbuf(0) { }
 
 
  Buffer::Buffer(const int nsamps, const int nlines,
                 const int nbands, const Isis::PixelType type) :
    p_nsamps(nsamps), p_nlines(nlines),
    p_nbands(nbands), p_pixelType(type) {
 
    p_sample = p_line = p_band = 0;
 
    if(p_nsamps <= 0) {
      string message = "Invalid value for sample dimensions (nsamps)";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
    if(p_nlines <= 0) {
      string message = "Invalid value for line dimensions (nlines)";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
    if(p_nbands <= 0) {
      string message = "Invalid value for band dimensions (nbands)";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
 
    p_npixels = p_nsamps * p_nlines * p_nbands;
 
    Allocate();
  }
 
 
  Buffer::~Buffer() {
    try {
      if(p_buf) {
        delete [] p_buf;
      }
      if(p_rawbuf) {
        delete [](char *) p_rawbuf;
      }
    }
    catch(...) {
 
    }
  }
 
 
  Buffer &Buffer::operator=(const double &d) {
    for(int i = 0 ; i < p_npixels ; i++) {
      p_buf[i] = d;
    }
    return (*this);
  }
 
 
  void Buffer::SetBasePosition(const int start_sample,
                               const int start_line,
                               const int start_band) {
    SetBaseSample(start_sample);
    SetBaseLine(start_line);
    SetBaseBand(start_band);
  }
 
 
  int Buffer::Sample(const int index) const {
    return (index % p_nsamps) + p_sample;
  }
 
 
  int Buffer::Line(const int index) const {
    int sub_index = index % (p_nsamps * p_nlines);
    return sub_index / p_nsamps + p_line;
  }
 
 
  int Buffer::Band(const int index) const {
    return index / (p_nsamps * p_nlines) + p_band;
  }
 
 
  void Buffer::Position(const int index, int &i_samp, int &i_line,
                        int &i_band) const {
    i_samp = Sample(index);
    i_line = Line(index);
    i_band = Band(index);
  }
 
 
  int Buffer::Index(const int i_samp, const int i_line, const int i_band)
      const {
    if((i_samp < p_sample) || (i_samp > (p_sample + p_nsamps - 1))) {
      QString message = Message::ArraySubscriptNotInRange(i_samp);
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
 
    if((i_line < p_line) || (i_line > (p_line + p_nlines - 1))) {
      QString message = Message::ArraySubscriptNotInRange(i_line);
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
 
    if((i_band < p_band) || (i_band > (p_band + p_nbands - 1))) {
      QString message = Message::ArraySubscriptNotInRange(i_band);
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
 
    //  Got a valid reference location so compute the index and return
    int index = (i_band - p_band) * (p_nlines * p_nsamps) +
                (i_line - p_line) * (p_nsamps) +
                (i_samp - p_sample);
    return (index);
  }
 
 
  double Buffer::at(const int index) const {
    if(index < 0) {
      QString message = Message::ArraySubscriptNotInRange(index);
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
    else if(index >= p_npixels) {
      QString message = Message::ArraySubscriptNotInRange(index);
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
 
    return p_buf[index];
  }
 
 
  void Buffer::Copy(const Buffer &in, bool includeRawBuf) {
    if(p_npixels != in.size()) {
      string message = "Input and output buffers are not the same size";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
 
    if(includeRawBuf && p_pixelType != in.PixelType()) {
      string message = "Input and output buffers are not the same pixel type";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
 
    size_t n = sizeof(double);
    n = n * (size_t) p_npixels;
    memcpy(p_buf, in.p_buf, n);
 
    if (includeRawBuf) {
      n = Isis::SizeOf(p_pixelType);
      n = n * (size_t) p_npixels;
      memcpy(p_rawbuf, in.p_rawbuf, n);
    }
  }
 
 
  bool Buffer::CopyOverlapFrom(const Buffer &in) {
    bool isSubareaOfIn = (p_npixels <= in.size());
    isSubareaOfIn &= (p_sample >= in.p_sample);
    isSubareaOfIn &= (p_line >= in.p_line);
    isSubareaOfIn &= (p_band >= in.p_band);
 
    int endSample = p_sample + p_nsamps - 1;
    int otherEndSample = in.p_sample + in.p_nsamps - 1;
 
    int endLine = p_line + p_nlines - 1;
    int otherEndLine = in.p_line + in.p_nlines - 1;
 
    int endBand = p_band + p_nbands - 1;
    int otherEndBand = in.p_band + in.p_nbands - 1;
 
    isSubareaOfIn &= (endSample <= otherEndSample);
    isSubareaOfIn &= (endLine <= otherEndLine);
    isSubareaOfIn &= (endBand <= otherEndBand);
 
    if (isSubareaOfIn) {
      for (int i = 0; i < size(); i++) {
        (*this)[i] = in[in.Index(Sample(i), Line(i), Band(i))];
      }
    }
 
    return isSubareaOfIn;
  }
 
 
  Buffer::Buffer(const Buffer &rhs) :
    p_nsamps(rhs.p_nsamps), p_nlines(rhs.p_nlines),
    p_nbands(rhs.p_nbands), p_pixelType(rhs.p_pixelType) {
 
    p_sample = rhs.p_sample;
    p_line = rhs.p_line;
    p_band = rhs.p_band;
 
    p_npixels = rhs.p_npixels;
 
    Allocate();
    Copy(rhs);
  }
 
 
  void Buffer::Allocate() {
    p_buf = NULL;
    p_rawbuf = NULL;
    try {
      p_buf = new double [p_npixels];
      size_t n = Isis::SizeOf(p_pixelType);
      n = n * (size_t) p_npixels;
      p_rawbuf = new char[n];
    }
    catch(...) {
      try {
        if(p_buf) {
          delete [] p_buf;
          p_buf = NULL;
        }
        if(p_rawbuf) {
          delete [](char *)p_rawbuf;
          p_rawbuf = NULL;
        }
      }
      catch(...) {
        p_buf = NULL;
        p_rawbuf = NULL;
      }
      QString message = Message::MemoryAllocationFailed();
      throw IException(IException::Unknown, message, _FILEINFO_);
    }
  }
}