Buffer.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "Buffer.h"
#include "IException.h"
#include "Message.h"
#include "PixelType.h"
#include "SpecialPixel.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 = true;
 
    // If one rectangle is on left side of other
    // if (l1.x > r2.x || l2.x > r1.x)
    if (p_line >= in.p_line + in.p_nlines ||
        in.p_line >= p_line + p_nlines)
      isSubareaOfIn = false;
 
    // If one rectangle is above other
    // if (r1.y > l2.y || r2.y > l1.y)
    if (p_sample >= in.p_sample + in.p_nsamps || 
        in.p_sample >= p_sample + p_nsamps)
      isSubareaOfIn = false;
 
    if (isSubareaOfIn) {
      int topLine = max(in.p_line, p_line);
      int topSamp = max(in.p_sample, p_sample);
 
      int bottomLine = min(in.p_line + in.p_nlines, p_line + p_nlines);
      int bottomSamp = min(in.p_sample + in.p_nsamps, p_sample + p_nsamps);
 
      int firstBand = max(in.p_band, p_band);
      int lastBand = min(in.p_band + in.p_nbands, p_band + p_nbands);
 
      for (int b = firstBand; b < lastBand; b++) {
        for (int i = topLine; i < bottomLine; i++) {
          for (int j = topSamp; j < bottomSamp; j++) {
            try {
              (*this)[Index(j, i, b)] = in[in.Index(j, i, b)];
            }
            catch(...) {
              (*this)[Index(j, i, b)] = NULL8;
            }
          }
        }
      }
    }
 
    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_);
    }
  }
}