Isis 3.0 Object Programmers' Reference

Home

---

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 Isis::iException::Message(Isis::iException::Programmer,message,_FILEINFO_);
    }
    if (p_nlines <= 0) {
      string message = "Invalid value for line dimensions (nlines)";
      throw Isis::iException::Message(Isis::iException::Programmer,message,_FILEINFO_);
    }
    if (p_nbands <= 0) {
      string message = "Invalid value for band dimensions (nbands)";
      throw Isis::iException::Message(Isis::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 &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 throw(Isis::iException &) {
  
    if ((i_samp < p_sample) || (i_samp > (p_sample+p_nsamps-1))) {
      string message = Isis::Message::ArraySubscriptNotInRange(i_samp);
      throw Isis::iException::Message(Isis::iException::Programmer,message,_FILEINFO_);
    }
  
    if ((i_line < p_line) || (i_line > (p_line+p_nlines-1))) {
      string message = Isis::Message::ArraySubscriptNotInRange(i_line);
      throw Isis::iException::Message(Isis::iException::Programmer,message,_FILEINFO_);
    }
  
    if ((i_band < p_band) || (i_band > (p_band+p_nbands-1))) {
      string message = Isis::Message::ArraySubscriptNotInRange(i_band);
      throw Isis::iException::Message(Isis::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) {
      string message = Isis::Message::ArraySubscriptNotInRange(index);
      throw Isis::iException::Message(Isis::iException::Programmer,message,_FILEINFO_);
    }
    else if (index >= p_npixels) {
      string message = Isis::Message::ArraySubscriptNotInRange(index);
      throw Isis::iException::Message(Isis::iException::Programmer,message,_FILEINFO_);
    }
  
    return p_buf[index];
  }
  
  void Buffer::Copy (const Buffer &in) {
    if (p_npixels != in.size()) {
      string message = "Input and output buffers are not the same size";
      throw Isis::iException::Message(Isis::iException::Programmer,message,_FILEINFO_);
    }
  
    size_t n = sizeof(double);
    n = n * (size_t) p_npixels;
    memcpy (p_buf, in.p_buf, n);
  
    n = Isis::SizeOf(p_pixelType);
    n = n * (size_t) p_npixels;
    memcpy (p_rawbuf, in.p_rawbuf, n);
  }
  
  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;
      }
      string message = Isis::Message::MemoryAllocationFailed();
      throw Isis::iException::Message(Isis::iException::System,message,_FILEINFO_);
    }
  }
}