CubeIoPolicy.h

Go to the documentation of this file.

//_Title CubeIoPolicy.h Definition of basic ISIS support structure
//
//_Descr ISIS3 file/functionality definition.
//
//_Hist Jul 24 2004 Kris Becker, USGS
//      Apr 18 2013 Kris Becker - Modified to comply with recent API changes
//_Version: $Id: CubeIoPolicy.h,v 1.3 2009/07/30 00:15:37 kbecker Exp $
//_End
#if !defined(CubeIoPolicy_h)
#define CubeIoPolicy_h
#include <string>
#include "Idl.h"
#include "IdlVariable.h"

#include "AlphaCube.h"
#include "Cube.h"
#include "Pvl.h"
#include "PvlGroup.h"
#include "Brick.h"
#include "SpecialPixel.h"
#include "SubArea.h"

#include "tnt/tnt_array3d.h"

namespace ISISDLM {

  using Isis::Brick;
  using Isis::Buffer;
  using Isis::Cube;
  using Isis::PvlGroup;
  using Isis::SubArea;


template <class T> struct RawIO {
  protected:
  void Extract(Brick &b,  T *data, Cube &cube) {
    T *ptr(static_cast<T *> (b.RawBuffer()));
    for (int i = 0 ; i < b.size() ; i++) {
      data[i] = ptr[i];
    }
    return;
  }

  void Inject(Brick &b, T *data, Cube &cube) {
    T *ptr(static_cast<T *> (b.RawBuffer()));
    for (int i = 0 ; i < b.size() ; i++) {
      ptr[i] = data[i];
    }
    ToDouble(b, cube);
    return;
  }

  void ToDouble(Buffer &rbuf, Cube &cube) {
    if (rbuf.PixelType() == Isis::UnsignedByte) {
      double *dbuf = rbuf.DoubleBuffer();
      unsigned char *cbuf = (unsigned char *) rbuf.RawBuffer();
      for (int i=0; i<rbuf.size(); i++) {
        if (cbuf[i] == Isis::NULL1) {
          dbuf[i] = Isis::NULL8;
        }
        else if (cbuf[i] == Isis::HIGH_REPR_SAT1) {
          dbuf[i] = Isis::HIGH_REPR_SAT8;
        }
        else {
          dbuf[i] = (double) cbuf[i] * cube.multiplier() + cube.base();
        }
      }
    }
    else if (rbuf.PixelType() == Isis::SignedWord) {
      double *dbuf = rbuf.DoubleBuffer();
      short int *sbuf = (short *) rbuf.RawBuffer();
      for (int i=0; i<rbuf.size(); i++) {
        if (sbuf[i] < Isis::VALID_MIN2) {
          if (sbuf[i] == Isis::NULL2) dbuf[i] = Isis::NULL8;
          else if (sbuf[i] == Isis::LOW_INSTR_SAT2) dbuf[i] = Isis::LOW_INSTR_SAT8;
          else if (sbuf[i] == Isis::LOW_REPR_SAT2) dbuf[i] = Isis::LOW_REPR_SAT8;
          else if (sbuf[i] == Isis::HIGH_INSTR_SAT2) dbuf[i] = Isis::HIGH_INSTR_SAT8;
          else if (sbuf[i] == Isis::HIGH_REPR_SAT2) dbuf[i] = Isis::HIGH_REPR_SAT8;
          else dbuf[i] = Isis::LOW_REPR_SAT8;
        }
        else {
          dbuf[i] = (double) sbuf[i] * cube.multiplier() + cube.base();
        }
      }
    }
    else {
      double *dbuf = rbuf.DoubleBuffer();
      float *fbuf = (float *) rbuf.RawBuffer();
      for (int i=0; i<rbuf.size(); i++) {
        if (fbuf[i] < Isis::VALID_MIN4) {
          if (fbuf[i] == Isis::NULL4) dbuf[i] = Isis::NULL8;
          else if (fbuf[i] == Isis::LOW_INSTR_SAT4) dbuf[i] = Isis::LOW_INSTR_SAT8;
          else if (fbuf[i] == Isis::LOW_REPR_SAT4) dbuf[i] = Isis::LOW_REPR_SAT8;
          else if (fbuf[i] == Isis::HIGH_INSTR_SAT4) dbuf[i] = Isis::HIGH_INSTR_SAT8;
          else if (fbuf[i] == Isis::HIGH_REPR_SAT4) dbuf[i] = Isis::HIGH_REPR_SAT8;
          else dbuf[i] = Isis::LOW_REPR_SAT8;
        }
        else {
          dbuf[i] = (double) fbuf[i];
        }
      }
    }
  }

};

template <class T> struct StdIO {
  protected:
  void Extract(Brick &b, T *data, Cube &cube) {
    T *ptr(static_cast<T *> (b.DoubleBuffer()));
    for (int i = 0 ; i < b.size() ; i++) {
      data[i] = ptr[i];
    }
    return;
  }

  void Inject(Brick &b, T *data, Cube &cube) {
    T *ptr(static_cast<T *> (b.DoubleBuffer()));
    for (int i = 0 ; i < b.size() ; i++) {
      ptr[i] = data[i];
    }
    return;
  }

};


struct CubeDims {
    CubeDims() : _ssamp(1), _nsamps(0), _sline(1), _nlines(0),
                 _sband(1), _nbands(0) { }
    CubeDims(const int &ns, const int &nl, const int &nb = 1) :
             _ssamp(1), _nsamps(ns), _sline(1), _nlines(nl),
             _sband(1), _nbands(nb) { }

    void setSampleSpecs(int ssamp, int ns = 0) { 
      _ssamp = ssamp; _nsamps = ns;
    };

    void setLineSpecs(int sline, int nl = 0) {
      _sline = sline; _nlines = nl;
    };

    void setBandSpecs(int sband, int nb = 0) {
      _sband = sband; _nbands = nb;
    };

    int _ssamp;
    int _nsamps;
    int _sline;
    int _nlines;
    int _sband;
    int _nbands;
};


inline PvlGroup setAlphaCube(Cube *icube, Cube *ocube, const CubeDims &specs) {
  SubArea s;
  s.SetSubArea(icube->lineCount(), icube->sampleCount(), 
               specs._sline, specs._ssamp, 
               (specs._sline+specs._nlines-1), (specs._ssamp+specs._nsamps-1),
               1.0, 1.0);
  PvlGroup results("IDL_History");
  s.UpdateLabel(icube, ocube, results);
  return (results);
}

template <
 class T, int TYPEID,
 template <class> class IOPolicy
 >
 class CubeIoPolicy : public IOPolicy<T> {
   public:
     typedef T   DataType;
     CubeIoPolicy() : dims() { };
     CubeIoPolicy(const CubeDims &d) : dims(d) { }
     virtual ~CubeIoPolicy() { };

     int getVarType() const { return (TYPEID); }

     void Read(Isis::Cube &cube, TNT::Array3D<T> &data) {
       int ss,sl,sb;
       ss = (dims._ssamp <= 0) ? 1 : dims._ssamp;
       sl = (dims._sline <= 0) ? 1 : dims._sline;
       sb = (dims._sband <= 0) ? 1 : dims._sband;

       int ns,nl,nb;
       ns = (dims._nsamps <= 0) ? cube.sampleCount() - ss + 1 : dims._nsamps;
       nl = (dims._nlines <= 0) ? cube.lineCount()   - sl + 1 : dims._nlines;
       nb = (dims._nbands <= 0) ? cube.bandCount()   - sb + 1 : dims._nbands;

       Brick brick(cube, ns, 1, 1);
       for (int b = 0 ; b < nb ; b++) {
         for (int l = 0 ; l < nl ; l++) {
           brick.SetBasePosition(ss,sl+l,sb+b);
           cube.read(brick);
           this->Extract(brick, data[b][l], cube);
         }
       }
     };

     void Write(TNT::Array3D<T> &data, Isis::Cube &cube) {
       int ss,sl,sb;
       ss = (dims._ssamp <= 0) ? 1 : dims._ssamp;
       sl = (dims._sline <= 0) ? 1 : dims._sline;
       sb = (dims._sband <= 0) ? 1 : dims._sband;

       int ns,nl,nb;
       ns = data.dim3();
       nl = data.dim2();
       nb = data.dim1();

       Brick brick(cube, ns, 1, 1);
       for (int b = 0 ; b < nb ; b++) {
         for (int l = 0 ; l < nl ; l++) {
           brick.SetBasePosition(ss,sl+l,sb+b);
           this->Inject(brick, data[b][l], cube);
           cube.write(brick);
           brick++;
         }
       }
     };

   private:
     CubeDims dims;           

 };



 }
 #endif