Buffer.cpp

Go to the documentation of this file.

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