BufferManager.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "IsisDebug.h"
#include "BufferManager.h"
 
#include <iostream>
#include <string>
 
#include "IException.h"
 
using namespace std;
 
namespace Isis {
  BufferManager::BufferManager() {
  }
 
 
  BufferManager::BufferManager(int maxsamps, int maxlines,
                               int maxbands, int bufsamps,
                               int buflines, int bufbands,
                               Isis::PixelType type, bool reverse) :
                                   Isis::Buffer(bufsamps, buflines, bufbands, type),
                                   p_maxSamps(maxsamps), p_maxLines(maxlines),
                                   p_maxBands(maxbands) {
    SetIncrements(bufsamps, buflines, bufbands);
    p_reverse = reverse;
  }
 
 
  BufferManager::BufferManager(const BufferManager &other) :
      Buffer(other),
      p_maxSamps(other.p_maxSamps), p_maxLines(other.p_maxLines),
      p_maxBands(other.p_maxBands), p_sinc(other.p_sinc), p_linc(other.p_linc),
      p_binc(other.p_binc), p_soff(other.p_soff), p_loff(other.p_loff),
      p_boff(other.p_boff), p_currentSample(other.p_currentSample),
      p_currentLine(other.p_currentLine), p_currentBand(other.p_currentBand),
      p_nmaps(other.p_nmaps), p_currentMap(other.p_currentMap),
      p_reverse(other.p_reverse) {
  }
 
 
  void BufferManager::swap(BufferManager &other) {
    std::swap(p_maxSamps, other.p_maxSamps);
    std::swap(p_maxLines, other.p_maxLines);
    std::swap(p_maxBands, other.p_maxBands);
    std::swap(p_sinc, other.p_sinc);
    std::swap(p_linc, other.p_linc);
    std::swap(p_binc, other.p_binc);
    std::swap(p_soff, other.p_soff);
    std::swap(p_loff, other.p_loff);
    std::swap(p_boff, other.p_boff);
    std::swap(p_currentSample, other.p_currentSample);
    std::swap(p_currentLine, other.p_currentLine);
    std::swap(p_currentBand, other.p_currentBand);
    std::swap(p_nmaps, other.p_nmaps);
    std::swap(p_currentMap, other.p_currentMap);
    std::swap(p_reverse, other.p_reverse);
  }
 
 
  BufferManager &BufferManager::operator=(const BufferManager &rhs) {
    BufferManager copy(rhs);
    swap(copy);
    return *this;
  }
 
 
  void BufferManager::SetIncrements(const int sinc, const int linc,
                                    const int binc) {
    p_sinc = sinc;
    p_linc = linc;
    p_binc = binc;
 
    p_soff = 0;
    p_loff = 0;
    p_boff = 0;
 
    p_currentSample = p_currentLine = p_currentBand = 1;
    p_currentMap = 0;
 
    p_nmaps = ((BigInt)((p_maxSamps - 1) / p_sinc + 1) *
               (BigInt)((p_maxLines - 1) / p_linc + 1) *
               (BigInt)((p_maxBands - 1) / p_binc + 1));
  }
 
 
  void BufferManager::SetOffsets(const int soff, const int loff,
                                 const int boff) {
    p_soff = soff;
    p_loff = loff;
    p_boff = boff;
  }
 
 
  bool BufferManager::setpos(BigInt map) {
    if(map >= 0) {
      p_currentMap = map;
 
      if(!p_reverse) {
        int sampDimension = (p_maxSamps / p_sinc);
        if (p_maxSamps % p_sinc)
          sampDimension++;
 
        p_currentSample = (map % sampDimension) * p_sinc + 1;
        map /= sampDimension;
 
        int lineDimension = (p_maxLines / p_linc);
        if (p_maxLines % p_linc)
          lineDimension++;
 
        p_currentLine = (map % lineDimension) * p_linc + 1;
        map /= lineDimension;
 
        p_currentBand = map * p_binc + 1;
      }
      else {
        int bandDimension = (p_maxBands / p_binc);
        if (p_maxBands % p_binc)
          bandDimension++;
 
        p_currentBand = (map % bandDimension) * p_binc + 1;
        map /= bandDimension;
 
        int lineDimension = (p_maxLines / p_linc);
        if (p_maxLines % p_linc)
          lineDimension++;
 
        p_currentLine = (map % lineDimension) * p_linc + 1;
        map /= lineDimension;
 
        p_currentSample = map * p_sinc + 1;
      }
 
      SetBasePosition(p_currentSample + p_soff,
                      p_currentLine + p_loff,
                      p_currentBand + p_boff);
    }
    else {
      string message = "Invalid value for argument [map]";
      throw IException(IException::Programmer, message, _FILEINFO_);
    }
 
    return !end();
  }
} // end namespace isis