IsisDlm  Version 0.2
CubeIoPolicy.h
Go to the documentation of this file.
1 
2 //_Title CubeIoPolicy.h Definition of basic ISIS support structure
3 //
4 //_Descr ISIS3 file/functionality definition.
5 //
6 //_Hist Jul 24 2004 Kris Becker, USGS
7 // Apr 18 2013 Kris Becker - Modified to comply with recent API changes
8 //_Version: $Id: CubeIoPolicy.h,v 1.3 2009/07/30 00:15:37 kbecker Exp $
9 //_End
11 #if !defined(CubeIoPolicy_h)
12 #define CubeIoPolicy_h
13 #include <string>
14 #include "Idl.h"
15 #include "IdlVariable.h"
16 
17 #include "AlphaCube.h"
18 #include "Cube.h"
19 #include "Pvl.h"
20 #include "PvlGroup.h"
21 #include "Brick.h"
22 #include "SpecialPixel.h"
23 #include "SubArea.h"
24 
25 #include "tnt/tnt_array3d.h"
26 
27 namespace ISISDLM {
28 
29  using Isis::Brick;
30  using Isis::Buffer;
31  using Isis::Cube;
32  using Isis::PvlGroup;
33  using Isis::SubArea;
34 
35 
36 template <class T> struct RawIO {
37  protected:
38  void Extract(Brick &b, T *data, Cube &cube) {
39  T *ptr(static_cast<T *> (b.RawBuffer()));
40  for (int i = 0 ; i < b.size() ; i++) {
41  data[i] = ptr[i];
42  }
43  return;
44  }
45 
46  void Inject(Brick &b, T *data, Cube &cube) {
47  T *ptr(static_cast<T *> (b.RawBuffer()));
48  for (int i = 0 ; i < b.size() ; i++) {
49  ptr[i] = data[i];
50  }
51  ToDouble(b, cube);
52  return;
53  }
54 
55  void ToDouble(Buffer &rbuf, Cube &cube) {
56  if (rbuf.PixelType() == Isis::UnsignedByte) {
57  double *dbuf = rbuf.DoubleBuffer();
58  unsigned char *cbuf = (unsigned char *) rbuf.RawBuffer();
59  for (int i=0; i<rbuf.size(); i++) {
60  if (cbuf[i] == Isis::NULL1) {
61  dbuf[i] = Isis::NULL8;
62  }
63  else if (cbuf[i] == Isis::HIGH_REPR_SAT1) {
64  dbuf[i] = Isis::HIGH_REPR_SAT8;
65  }
66  else {
67  dbuf[i] = (double) cbuf[i] * cube.multiplier() + cube.base();
68  }
69  }
70  }
71  else if (rbuf.PixelType() == Isis::SignedWord) {
72  double *dbuf = rbuf.DoubleBuffer();
73  short int *sbuf = (short *) rbuf.RawBuffer();
74  for (int i=0; i<rbuf.size(); i++) {
75  if (sbuf[i] < Isis::VALID_MIN2) {
76  if (sbuf[i] == Isis::NULL2) dbuf[i] = Isis::NULL8;
77  else if (sbuf[i] == Isis::LOW_INSTR_SAT2) dbuf[i] = Isis::LOW_INSTR_SAT8;
78  else if (sbuf[i] == Isis::LOW_REPR_SAT2) dbuf[i] = Isis::LOW_REPR_SAT8;
79  else if (sbuf[i] == Isis::HIGH_INSTR_SAT2) dbuf[i] = Isis::HIGH_INSTR_SAT8;
80  else if (sbuf[i] == Isis::HIGH_REPR_SAT2) dbuf[i] = Isis::HIGH_REPR_SAT8;
81  else dbuf[i] = Isis::LOW_REPR_SAT8;
82  }
83  else {
84  dbuf[i] = (double) sbuf[i] * cube.multiplier() + cube.base();
85  }
86  }
87  }
88  else {
89  double *dbuf = rbuf.DoubleBuffer();
90  float *fbuf = (float *) rbuf.RawBuffer();
91  for (int i=0; i<rbuf.size(); i++) {
92  if (fbuf[i] < Isis::VALID_MIN4) {
93  if (fbuf[i] == Isis::NULL4) dbuf[i] = Isis::NULL8;
94  else if (fbuf[i] == Isis::LOW_INSTR_SAT4) dbuf[i] = Isis::LOW_INSTR_SAT8;
95  else if (fbuf[i] == Isis::LOW_REPR_SAT4) dbuf[i] = Isis::LOW_REPR_SAT8;
96  else if (fbuf[i] == Isis::HIGH_INSTR_SAT4) dbuf[i] = Isis::HIGH_INSTR_SAT8;
97  else if (fbuf[i] == Isis::HIGH_REPR_SAT4) dbuf[i] = Isis::HIGH_REPR_SAT8;
98  else dbuf[i] = Isis::LOW_REPR_SAT8;
99  }
100  else {
101  dbuf[i] = (double) fbuf[i];
102  }
103  }
104  }
105  }
106 
107 };
108 
109 template <class T> struct StdIO {
110  protected:
111  void Extract(Brick &b, T *data, Cube &cube) {
112  T *ptr(static_cast<T *> (b.DoubleBuffer()));
113  for (int i = 0 ; i < b.size() ; i++) {
114  data[i] = ptr[i];
115  }
116  return;
117  }
118 
119  void Inject(Brick &b, T *data, Cube &cube) {
120  T *ptr(static_cast<T *> (b.DoubleBuffer()));
121  for (int i = 0 ; i < b.size() ; i++) {
122  ptr[i] = data[i];
123  }
124  return;
125  }
126 
127 };
128 
129 
130 struct CubeDims {
131  CubeDims() : _ssamp(1), _nsamps(0), _sline(1), _nlines(0),
132  _sband(1), _nbands(0) { }
133  CubeDims(const int &ns, const int &nl, const int &nb = 1) :
134  _ssamp(1), _nsamps(ns), _sline(1), _nlines(nl),
135  _sband(1), _nbands(nb) { }
136 
137  void setSampleSpecs(int ssamp, int ns = 0) {
138  _ssamp = ssamp; _nsamps = ns;
139  };
140 
141  void setLineSpecs(int sline, int nl = 0) {
142  _sline = sline; _nlines = nl;
143  };
144 
145  void setBandSpecs(int sband, int nb = 0) {
146  _sband = sband; _nbands = nb;
147  };
148 
149  int _ssamp;
150  int _nsamps;
151  int _sline;
152  int _nlines;
153  int _sband;
154  int _nbands;
155 };
156 
157 
158 inline PvlGroup setAlphaCube(Cube *icube, Cube *ocube, const CubeDims &specs) {
159  SubArea s;
160  s.SetSubArea(icube->lineCount(), icube->sampleCount(),
161  specs._sline, specs._ssamp,
162  (specs._sline+specs._nlines-1), (specs._ssamp+specs._nsamps-1),
163  1.0, 1.0);
164  PvlGroup results("IDL_History");
165  s.UpdateLabel(icube, ocube, results);
166  return (results);
167 }
168 
173 template <
174  class T, int TYPEID,
175  template <class> class IOPolicy
176  >
177  class CubeIoPolicy : public IOPolicy<T> {
178  public:
179  typedef T DataType;
180  CubeIoPolicy() : dims() { };
181  CubeIoPolicy(const CubeDims &d) : dims(d) { }
182  virtual ~CubeIoPolicy() { };
183 
184  int getVarType() const { return (TYPEID); }
185 
186  void Read(Isis::Cube &cube, TNT::Array3D<T> &data) {
187  int ss,sl,sb;
188  ss = (dims._ssamp <= 0) ? 1 : dims._ssamp;
189  sl = (dims._sline <= 0) ? 1 : dims._sline;
190  sb = (dims._sband <= 0) ? 1 : dims._sband;
191 
192  int ns,nl,nb;
193  ns = (dims._nsamps <= 0) ? cube.sampleCount() - ss + 1 : dims._nsamps;
194  nl = (dims._nlines <= 0) ? cube.lineCount() - sl + 1 : dims._nlines;
195  nb = (dims._nbands <= 0) ? cube.bandCount() - sb + 1 : dims._nbands;
196 
197  Brick brick(cube, ns, 1, 1);
198  for (int b = 0 ; b < nb ; b++) {
199  for (int l = 0 ; l < nl ; l++) {
200  brick.SetBasePosition(ss,sl+l,sb+b);
201  cube.read(brick);
202  this->Extract(brick, data[b][l], cube);
203  }
204  }
205  };
206 
207  void Write(TNT::Array3D<T> &data, Isis::Cube &cube) {
208  int ss,sl,sb;
209  ss = (dims._ssamp <= 0) ? 1 : dims._ssamp;
210  sl = (dims._sline <= 0) ? 1 : dims._sline;
211  sb = (dims._sband <= 0) ? 1 : dims._sband;
212 
213  int ns,nl,nb;
214  ns = data.dim3();
215  nl = data.dim2();
216  nb = data.dim1();
217 
218  Brick brick(cube, ns, 1, 1);
219  for (int b = 0 ; b < nb ; b++) {
220  for (int l = 0 ; l < nl ; l++) {
221  brick.SetBasePosition(ss,sl+l,sb+b);
222  this->Inject(brick, data[b][l], cube);
223  cube.write(brick);
224  brick++;
225  }
226  }
227  };
228 
229  private:
230  CubeDims dims;
231 
232  };
233 
234 
235 
236  }
237  #endif