Field3D

#include <MIPFieldIO.h>

Inheritance diagram for MIPFieldIO:
FieldIO RefBase

Public Types

typedef MIPFieldIO class_type
 
typedef boost::intrusive_ptr< MIPFieldIOPtr
 
- Public Types inherited from FieldIO
typedef FieldIO class_type
 
typedef boost::intrusive_ptr< FieldIOPtr
 
- Public Types inherited from RefBase
typedef boost::intrusive_ptr< RefBasePtr
 
typedef boost::weak_ptr< RefBaseWeakPtr
 

Public Member Functions

virtual std::string className () const
 Returns the class name. More...
 
 MIPFieldIO ()
 Ctor. More...
 
virtual FieldBase::Ptr read (hid_t layerGroup, const std::string &filename, const std::string &layerPath, DataTypeEnum typeEnum)
 Reads the field at the given location and tries to create a MIPField object from it. Calls out to readData() for template-specific work. More...
 
virtual bool write (hid_t layerGroup, FieldBase::Ptr field)
 Writes the given field to disk. This function calls out to writeInternal once the template type has been determined. More...
 
virtual ~MIPFieldIO ()
 Dtor. More...
 
- Public Member Functions inherited from FieldIO
 FieldIO ()
 Ctor. More...
 
virtual ~FieldIO ()
 Dtor. More...
 
- Public Member Functions inherited from RefBase
void ref () const
 Used by boost::intrusive_pointer. More...
 
size_t refcnt ()
 Used by boost::intrusive_pointer. More...
 
void unref () const
 Used by boost::intrusive_pointer. More...
 
WeakPtr weakPtr () const
 
 RefBase ()
 
 RefBase (const RefBase &)
 Copy constructor. More...
 
RefBaseoperator= (const RefBase &)
 Assignment operator. More...
 
virtual ~RefBase ()
 Destructor. More...
 
virtual bool checkRTTI (const char *typenameStr)=0
 This function is only implemented by concrete classes and triggers the actual RTTI check through matchRTTI();. More...
 
bool matchRTTI (const char *typenameStr)
 Performs a check to see if the given typename string matches this class' This needs to be implemented in -all- subclasses, even abstract ones. More...
 

Static Public Member Functions

static FieldIO::Ptr create ()
 
static const char * staticClassType ()
 
- Static Public Member Functions inherited from FieldIO
static const char * staticClassType ()
 
- Static Public Member Functions inherited from RefBase
static const char * staticClassType ()
 

Public Attributes

 DEFINE_FIELD_RTTI_CONCRETE_CLASS
 
- Public Attributes inherited from FieldIO
 DEFINE_FIELD_RTTI_ABSTRACT_CLASS
 

Private Types

typedef FieldIO base
 Convenience typedef for referring to base class. More...
 

Private Member Functions

template<template< typename X > class Field_T, class Data_T >
MIPField< Field_T< Data_T > >::Ptr readInternal (hid_t layerGroup, const std::string &filename, const std::string &layerPath, DataTypeEnum typeEnum)
 
template<template< typename X > class Field_T, class Data_T >
bool writeInternal (hid_t layerGroup, typename MIPField< Field_T< Data_T > >::Ptr field)
 This call writes all the attributes and sets up the data space. More...
 

Static Private Attributes

static const std::string k_baseTypeStr
 
static const std::string k_bitsPerComponentStr
 
static const std::string k_componentsStr
 
static const std::string k_dataWindowStr
 
static const std::string k_extentsStr
 
static const std::string k_levelGroupStr
 
static const std::string k_levelsStr
 
static const std::string k_mipGroupStr
 
static const std::string k_versionAttrName
 
static const int k_versionNumber
 

Detailed Description

Handles IO for a MIPField object

Definition at line 78 of file MIPFieldIO.h.

Member Typedef Documentation

typedef boost::intrusive_ptr<MIPFieldIO> MIPFieldIO::Ptr

Definition at line 85 of file MIPFieldIO.h.

Definition at line 89 of file MIPFieldIO.h.

typedef FieldIO MIPFieldIO::base
private

Convenience typedef for referring to base class.

Definition at line 160 of file MIPFieldIO.h.

Constructor & Destructor Documentation

MIPFieldIO::MIPFieldIO ( )
inline

Ctor.

Definition at line 100 of file MIPFieldIO.h.

101  : FieldIO()
102  { }
FieldIO()
Ctor.
Definition: FieldIO.h:105
virtual MIPFieldIO::~MIPFieldIO ( )
inlinevirtual

Dtor.

Definition at line 105 of file MIPFieldIO.h.

106  { /* Empty */ }

Member Function Documentation

static const char* MIPFieldIO::staticClassType ( )
inlinestatic

Definition at line 92 of file MIPFieldIO.h.

93  {
94  return "MIPFieldIO";
95  }
static FieldIO::Ptr MIPFieldIO::create ( )
inlinestatic

Definition at line 108 of file MIPFieldIO.h.

References read(), and write().

Referenced by initIO().

109  { return Ptr(new MIPFieldIO); }
boost::intrusive_ptr< MIPFieldIO > Ptr
Definition: MIPFieldIO.h:85
FieldBase::Ptr MIPFieldIO::read ( hid_t  layerGroup,
const std::string &  filename,
const std::string &  layerPath,
DataTypeEnum  typeEnum 
)
virtual

Reads the field at the given location and tries to create a MIPField object from it. Calls out to readData() for template-specific work.

Returns
Null if no object was read

Implements FieldIO.

Definition at line 82 of file MIPFieldIO.cpp.

References DataTypeDouble, DataTypeFloat, DataTypeHalf, DataTypeVecDouble, DataTypeVecFloat, DataTypeVecHalf, and Hdf5Util::readAttribute().

Referenced by create().

85 {
86  Box3i extents, dataW;
87  int components;
88 
89  if (layerGroup == -1)
90  throw BadHdf5IdException("Bad layer group in MIPFieldIO::read");
91 
92  int version;
93  if (!readAttribute(layerGroup, k_versionAttrName, 1, version))
94  throw MissingAttributeException("Couldn't find attribute " +
96 
97  if (version != k_versionNumber)
98  throw UnsupportedVersionException("MIPField version not supported: " +
99  lexical_cast<std::string>(version));
100 
101  if (!readAttribute(layerGroup, k_componentsStr, 1, components))
102  throw MissingAttributeException("Couldn't find attribute " +
104 
105  // Check data type ---
106 
107  int bits;
108  if (!readAttribute(layerGroup, k_bitsPerComponentStr, 1, bits))
109  throw MissingAttributeException("Couldn't find attribute: " +
111 
112  std::string baseType;
113  if (!readAttribute(layerGroup, k_baseTypeStr, baseType)) {
114  throw MissingAttributeException("Couldn't find attribute: " +
115  k_baseTypeStr);
116  }
117 
118  bool isHalf = false;
119  bool isFloat = false;
120  bool isDouble = false;
121 
122  switch (bits) {
123  case 16:
124  isHalf = true;
125  break;
126  case 64:
127  isDouble = true;
128  break;
129  case 32:
130  default:
131  isFloat = true;
132  }
133 
134  bool isSparse = false;
135  bool isDense = false;
136 
137  if (baseType == "SparseField") {
138  isSparse = true;
139  } else if (baseType == "DenseField") {
140  isDense = true;
141  }
142 
143  // Read the data ---
144 
145  FieldBase::Ptr result;
146 
147  if (isDense && isHalf && components == 1 && typeEnum == DataTypeHalf)
148  result = readInternal<DenseField, half>(layerGroup, filename,
149  layerPath, typeEnum);
150  if (isDense && isFloat && components == 1 && typeEnum == DataTypeFloat)
151  result = readInternal<DenseField, float>(layerGroup, filename,
152  layerPath, typeEnum);
153  if (isDense && isDouble && components == 1 && typeEnum == DataTypeDouble)
154  result = readInternal<DenseField, double>(layerGroup, filename,
155  layerPath, typeEnum);
156  if (isDense && isHalf && components == 3 && typeEnum == DataTypeVecHalf)
157  result = readInternal<DenseField, V3h>(layerGroup, filename,
158  layerPath, typeEnum);
159  if (isDense && isFloat && components == 3 && typeEnum == DataTypeVecFloat)
160  result = readInternal<DenseField, V3f>(layerGroup, filename,
161  layerPath, typeEnum);
162  if (isDense && isDouble && components == 3 && typeEnum == DataTypeVecDouble)
163  result = readInternal<DenseField, V3d>(layerGroup, filename,
164  layerPath, typeEnum);
165  if (isSparse && isHalf && components == 1 && typeEnum == DataTypeHalf)
166  result = readInternal<SparseField, half>(layerGroup, filename,
167  layerPath, typeEnum);
168  if (isSparse && isFloat && components == 1 && typeEnum == DataTypeFloat)
169  result = readInternal<SparseField, float>(layerGroup, filename,
170  layerPath, typeEnum);
171  if (isSparse && isDouble && components == 1 && typeEnum == DataTypeDouble)
172  result = readInternal<SparseField, double>(layerGroup, filename,
173  layerPath, typeEnum);
174  if (isSparse && isHalf && components == 3 && typeEnum == DataTypeVecHalf)
175  result = readInternal<SparseField, V3h>(layerGroup, filename,
176  layerPath, typeEnum);
177  if (isSparse && isFloat && components == 3 && typeEnum == DataTypeVecFloat)
178  result = readInternal<SparseField, V3f>(layerGroup, filename,
179  layerPath, typeEnum);
180  if (isSparse && isDouble && components == 3 && typeEnum == DataTypeVecDouble)
181  result = readInternal<SparseField, V3d>(layerGroup, filename,
182  layerPath, typeEnum);
183 
184  return result;
185 }
Imath::Box3i Box3i
Definition: SpiMathLib.h:77
FIELD3D_API bool readAttribute(hid_t location, const std::string &attrName, std::string &value)
Reads a string attribute.
boost::intrusive_ptr< FieldBase > Ptr
Definition: Field.h:97
static const std::string k_baseTypeStr
Definition: MIPFieldIO.h:155
static const std::string k_versionAttrName
Definition: MIPFieldIO.h:147
static const std::string k_componentsStr
Definition: MIPFieldIO.h:150
static const std::string k_bitsPerComponentStr
Definition: MIPFieldIO.h:151
static const int k_versionNumber
Definition: MIPFieldIO.h:146
bool MIPFieldIO::write ( hid_t  layerGroup,
FieldBase::Ptr  field 
)
virtual

Writes the given field to disk. This function calls out to writeInternal once the template type has been determined.

Returns
true if successful, otherwise false

Implements FieldIO.

Definition at line 190 of file MIPFieldIO.cpp.

References FIELD3D_NAMESPACE_SOURCE_CLOSE, field_dynamic_cast(), and Hdf5Util::writeAttribute().

Referenced by create().

191 {
192  if (layerGroup == -1) {
193  throw BadHdf5IdException("Bad layer group in MIPFieldIO::write");
194  }
195 
196  // Add version attribute
197  if (!writeAttribute(layerGroup, k_versionAttrName,
198  1, k_versionNumber)) {
199  throw WriteAttributeException("Couldn't write attribute " +
201  }
202 
203  MIPField<DenseField<half> >::Ptr halfDenseField =
205  MIPField<DenseField<float> >::Ptr floatDenseField =
207  MIPField<DenseField<double> >::Ptr doubleDenseField =
209  MIPField<DenseField<V3h> >::Ptr vecHalfDenseField =
211  MIPField<DenseField<V3f> >::Ptr vecFloatDenseField =
213  MIPField<DenseField<V3d> >::Ptr vecDoubleDenseField =
215  MIPField<SparseField<half> >::Ptr halfSparseField =
217  MIPField<SparseField<float> >::Ptr floatSparseField =
219  MIPField<SparseField<double> >::Ptr doubleSparseField =
221  MIPField<SparseField<V3h> >::Ptr vecHalfSparseField =
223  MIPField<SparseField<V3f> >::Ptr vecFloatSparseField =
225  MIPField<SparseField<V3d> >::Ptr vecDoubleSparseField =
227 
228  bool success = true;
229 
230  if (floatDenseField) {
231  success = writeInternal<DenseField, float>(layerGroup, floatDenseField);
232  }
233  else if (halfDenseField) {
234  success = writeInternal<DenseField, half>(layerGroup, halfDenseField);
235  }
236  else if (doubleDenseField) {
237  success = writeInternal<DenseField, double>(layerGroup, doubleDenseField);
238  }
239  else if (vecFloatDenseField) {
240  success = writeInternal<DenseField, V3f>(layerGroup, vecFloatDenseField);
241  }
242  else if (vecHalfDenseField) {
243  success = writeInternal<DenseField, V3h>(layerGroup, vecHalfDenseField);
244  }
245  else if (vecDoubleDenseField) {
246  success = writeInternal<DenseField, V3d>(layerGroup, vecDoubleDenseField);
247  }
248  else if (floatSparseField) {
249  success = writeInternal<SparseField, float>(layerGroup, floatSparseField);
250  }
251  else if (halfSparseField) {
252  success = writeInternal<SparseField, half>(layerGroup, halfSparseField);
253  }
254  else if (doubleSparseField) {
255  success = writeInternal<SparseField, double>(layerGroup, doubleSparseField);
256  }
257  else if (vecFloatSparseField) {
258  success = writeInternal<SparseField, V3f>(layerGroup, vecFloatSparseField);
259  }
260  else if (vecHalfSparseField) {
261  success = writeInternal<SparseField, V3h>(layerGroup, vecHalfSparseField);
262  }
263  else if (vecDoubleSparseField) {
264  success = writeInternal<SparseField, V3d>(layerGroup, vecDoubleSparseField);
265  }
266  else {
267  throw WriteLayerException("MIPFieldIO does not support the given "
268  "MIPField template parameter");
269  }
270 
271  return success;
272 }
Field_T::Ptr field_dynamic_cast(RefBase::Ptr field)
Dynamic cast that uses string-comparison in order to be safe even after an object crosses a shared li...
Definition: RefCount.h:256
FIELD3D_API bool writeAttribute(hid_t location, const std::string &attrName, const std::string &value)
Writes a string attribute.
This subclass stores a MIP representation of a Field_T field.
Definition: MIPField.h:109
boost::intrusive_ptr< MIPFieldIO > Ptr
Definition: MIPFieldIO.h:85
static const std::string k_versionAttrName
Definition: MIPFieldIO.h:147
static const int k_versionNumber
Definition: MIPFieldIO.h:146
virtual std::string MIPFieldIO::className ( ) const
inlinevirtual

Returns the class name.

Implements FieldIO.

Definition at line 127 of file MIPFieldIO.h.

References readInternal(), and writeInternal().

Referenced by writeInternal().

128  { return "MIPField"; }
template<template< typename X > class Field_T, class Data_T >
bool MIPFieldIO::writeInternal ( hid_t  layerGroup,
typename MIPField< Field_T< Data_T > >::Ptr  field 
)
private

This call writes all the attributes and sets up the data space.

Definition at line 281 of file MIPFieldIO.h.

References className(), ClassFactory::createFieldIO(), FieldTraits< Data_T >::dataDims(), DataTypeTraits< T >::h5bits(), k_baseTypeStr, k_bitsPerComponentStr, k_componentsStr, k_dataWindowStr, k_extentsStr, k_levelGroupStr, k_levelsStr, k_mipGroupStr, Msg::print(), Msg::SevWarning, ClassFactory::singleton(), and Hdf5Util::writeAttribute().

Referenced by className().

283 {
284  using namespace Exc;
285  using namespace Hdf5Util;
286 
287  Box3i ext(field->extents()), dw(field->dataWindow());
288 
289  // Add extents attribute ---
290 
291  int extents[6] =
292  { ext.min.x, ext.min.y, ext.min.z, ext.max.x, ext.max.y, ext.max.z };
293 
294  if (!writeAttribute(layerGroup, k_extentsStr, 6, extents[0])) {
295  throw WriteAttributeException("Couldn't write attribute " + k_extentsStr);
296  }
297 
298  // Add data window attribute ---
299 
300  int dataWindow[6] =
301  { dw.min.x, dw.min.y, dw.min.z, dw.max.x, dw.max.y, dw.max.z };
302 
303  if (!writeAttribute(layerGroup, k_dataWindowStr, 6, dataWindow[0])) {
304  throw WriteAttributeException("Couldn't write attribute " + k_dataWindowStr);
305  }
306 
307  // Add components attribute ---
308 
309  int components = FieldTraits<Data_T>::dataDims();
310 
311  if (!writeAttribute(layerGroup, k_componentsStr, 1, components)) {
312  throw WriteAttributeException("Couldn't write attribute " + k_componentsStr);
313  }
314 
315  // Add the bits per component attribute ---
316 
317  int bits = DataTypeTraits<Data_T>::h5bits();
318  if (!writeAttribute(layerGroup, k_bitsPerComponentStr, 1, bits)) {
319  Msg::print(Msg::SevWarning, "Error adding bits per component attribute.");
320  return false;
321  }
322 
323  // Add the base type attribute ---
324 
325  std::string baseType = Field_T<Data_T>::staticClassName();
326  if (!writeAttribute(layerGroup, k_baseTypeStr, baseType)) {
327  throw WriteAttributeException("Couldn't write attribute " + k_baseTypeStr);
328  }
329 
330  // Add the mip fields group
331 
332  H5ScopedGcreate mipGroup(layerGroup, k_mipGroupStr);
333 
334  // Write number of layers
335  int numLevels = field->numLevels();
336  if (!writeAttribute(mipGroup, k_levelsStr, 1, numLevels)) {
337  throw WriteAttributeException("Couldn't write attribute " + k_levelsStr);
338  }
339 
340  // For each level ---
341 
342  for (size_t i = 0; i < field->numLevels(); i++) {
343 
344  // Add a named group
345  H5ScopedGcreate levelGroup(mipGroup, k_levelGroupStr + "." +
346  boost::lexical_cast<std::string>(i));
347 
348  // Add the field to the group
349  std::string className = Field_T<Data_T>::staticClassName();
350  FieldIO::Ptr io =
352  io->write(levelGroup, field->mipLevel(i));
353 
354  }
355 
356  return true;
357 }
virtual std::string className() const
Returns the class name.
Definition: MIPFieldIO.h:127
Imath::Box3i Box3i
Definition: SpiMathLib.h:77
Contains utility functions and classes for Hdf5 files.
Definition: Hdf5Util.h:86
FIELD3D_API bool writeAttribute(hid_t location, const std::string &attrName, const std::string &value)
Writes a string attribute.
static int dataDims()
Dimensions of the given data type. i.e. 3 for V3f, 1 for float.
Namespace for Exception objects.
Definition: Exception.h:57
static const std::string k_dataWindowStr
Definition: MIPFieldIO.h:149
static ClassFactory & singleton()
}
static const std::string k_levelsStr
Definition: MIPFieldIO.h:154
static const std::string k_baseTypeStr
Definition: MIPFieldIO.h:155
FIELD3D_API void print(Severity severity, const std::string &message)
Sends the string to the assigned output, prefixing the message with the severity. ...
Definition: Log.cpp:66
Scoped object - creates a group on creation and closes it on destruction.
Definition: Hdf5Util.h:165
static const std::string k_levelGroupStr
Definition: MIPFieldIO.h:153
static const std::string k_mipGroupStr
Definition: MIPFieldIO.h:152
static const std::string k_extentsStr
Definition: MIPFieldIO.h:148
static int h5bits()
static const std::string k_componentsStr
Definition: MIPFieldIO.h:150
FieldIO::Ptr createFieldIO(const std::string &className) const
Instances an IO object by name.
boost::intrusive_ptr< FieldIO > Ptr
Definition: FieldIO.h:90
static const std::string k_bitsPerComponentStr
Definition: MIPFieldIO.h:151
template<template< typename X > class Field_T, class Data_T >
MIPField< Field_T< Data_T > >::Ptr MIPFieldIO::readInternal ( hid_t  layerGroup,
const std::string &  filename,
const std::string &  layerPath,
DataTypeEnum  typeEnum 
)
private

Definition at line 363 of file MIPFieldIO.h.

References FIELD3D_NAMESPACE_HEADER_CLOSE, k_componentsStr, k_dataWindowStr, k_extentsStr, k_levelGroupStr, k_levelsStr, k_mipGroupStr, Hdf5Util::readAttribute(), and ResizableField< Data_T >::setSize().

Referenced by className().

367 {
368  using namespace detail;
369  using namespace Exc;
370  using namespace Hdf5Util;
371 
372  typedef MIPField<Field_T<Data_T> > MIPType;
373  typedef GenericLazyLoadAction<Field_T<Data_T> > Action;
374 
375  // Read extents
376  Box3i extents;
377  if (!readAttribute(layerGroup, k_extentsStr, 6, extents.min.x))
378  throw MissingAttributeException("Couldn't find attribute " +
379  k_extentsStr);
380 
381  // Read data window
382  Box3i dataW;
383  if (!readAttribute(layerGroup, k_dataWindowStr, 6, dataW.min.x))
384  throw MissingAttributeException("Couldn't find attribute " +
386 
387  // Read components
388  int components;
389  if (!readAttribute(layerGroup, k_componentsStr, 1, components))
390  throw MissingAttributeException("Couldn't find attribute " +
392 
393  // Construct the resulting MIP field
394  typename MIPType::Ptr result(new typename MIPInstance<Field_T<Data_T> >::type);
395 
396  // Open the MIP field group
397  H5ScopedGopen mipGroup(layerGroup, k_mipGroupStr);
398 
399  // Read num levels
400  int numLevels;
401  if (!readAttribute(mipGroup, k_levelsStr, 1, numLevels))
402  throw MissingAttributeException("Couldn't find attribute " + k_levelsStr);
403 
404  // Read each level ---
405 
406  std::vector<typename EmptyField<Data_T>::Ptr> proxies;
407  typename LazyLoadAction<Field_T<Data_T> >::Vec actions;
408 
409  for (int i = 0; i < numLevels; i++) {
410  // Open level group
411  std::string levelGroupStr =
412  k_levelGroupStr + "." + boost::lexical_cast<std::string>(i);
413  H5ScopedGopen levelGroup(mipGroup, levelGroupStr);
414  // Read the proxy
415  typename EmptyField<Data_T>::Ptr proxy(new EmptyField<Data_T>);
416  // Read extents
417  if (!readAttribute(levelGroup, k_extentsStr, 6, extents.min.x))
418  throw MissingAttributeException("Couldn't find attribute " +
419  k_extentsStr);
420  // Read data window
421  if (!readAttribute(levelGroup, k_dataWindowStr, 6, dataW.min.x))
422  throw MissingAttributeException("Couldn't find attribute " +
424  // Configure proxy with resolution
425  proxy->setSize(extents, dataW);
426  proxies.push_back(proxy);
427  // Make the lazy load action
428  std::string fullPath =
429  layerPath + "/" + k_mipGroupStr + "/" + levelGroupStr;
430  typename Action::Ptr action(new Action(filename, fullPath, typeEnum));
431  actions.push_back(action);
432  }
433 
434  result->setupLazyLoad(proxies, actions);
435 
436  return result;
437 }
Imath::Box3i Box3i
Definition: SpiMathLib.h:77
Contains utility functions and classes for Hdf5 files.
Definition: Hdf5Util.h:86
Namespace for Exception objects.
Definition: Exception.h:57
static const std::string k_dataWindowStr
Definition: MIPFieldIO.h:149
FIELD3D_API bool readAttribute(hid_t location, const std::string &attrName, std::string &value)
Reads a string attribute.
static const std::string k_levelsStr
Definition: MIPFieldIO.h:154
This subclass stores a MIP representation of a Field_T field.
Definition: MIPField.h:109
static const std::string k_levelGroupStr
Definition: MIPFieldIO.h:153
static const std::string k_mipGroupStr
Definition: MIPFieldIO.h:152
static const std::string k_extentsStr
Definition: MIPFieldIO.h:148
This subclass of Field does not store any data.
Definition: EmptyField.h:86
We need to instantiate MIPSparseField rather than MIPField<SparseField>. This traits class does that...
Definition: MIPFieldIO.h:173
boost::intrusive_ptr< EmptyField > Ptr
Definition: EmptyField.h:93
static const std::string k_componentsStr
Definition: MIPFieldIO.h:150
Scoped object - opens a group on creation and closes it on destruction.
Definition: Hdf5Util.h:194

Member Data Documentation

MIPFieldIO::DEFINE_FIELD_RTTI_CONCRETE_CLASS

Definition at line 90 of file MIPFieldIO.h.

const int MIPFieldIO::k_versionNumber
staticprivate

Definition at line 146 of file MIPFieldIO.h.

const std::string MIPFieldIO::k_versionAttrName
staticprivate

Definition at line 147 of file MIPFieldIO.h.

const std::string MIPFieldIO::k_extentsStr
staticprivate

Definition at line 148 of file MIPFieldIO.h.

Referenced by readInternal(), and writeInternal().

const std::string MIPFieldIO::k_dataWindowStr
staticprivate

Definition at line 149 of file MIPFieldIO.h.

Referenced by readInternal(), and writeInternal().

const std::string MIPFieldIO::k_componentsStr
staticprivate

Definition at line 150 of file MIPFieldIO.h.

Referenced by readInternal(), and writeInternal().

const std::string MIPFieldIO::k_bitsPerComponentStr
staticprivate

Definition at line 151 of file MIPFieldIO.h.

Referenced by writeInternal().

const std::string MIPFieldIO::k_mipGroupStr
staticprivate

Definition at line 152 of file MIPFieldIO.h.

Referenced by readInternal(), and writeInternal().

const std::string MIPFieldIO::k_levelGroupStr
staticprivate

Definition at line 153 of file MIPFieldIO.h.

Referenced by readInternal(), and writeInternal().

const std::string MIPFieldIO::k_levelsStr
staticprivate

Definition at line 154 of file MIPFieldIO.h.

Referenced by readInternal(), and writeInternal().

const std::string MIPFieldIO::k_baseTypeStr
staticprivate

Definition at line 155 of file MIPFieldIO.h.

Referenced by writeInternal().


The documentation for this class was generated from the following files: