MIPFieldIO Class Reference

#include <MIPFieldIO.h>

Inheritance diagram for MIPFieldIO:

Public Types
typedef MIPFieldIO	class_type
typedef boost::intrusive_ptr< MIPFieldIO >	Ptr
Public Types inherited from FieldIO
typedef FieldIO	class_type
typedef boost::intrusive_ptr< FieldIO >	Ptr
Public Types inherited from RefBase
typedef boost::intrusive_ptr< RefBase >	Ptr
typedef boost::weak_ptr< RefBase >	WeakPtr

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...
RefBase &	operator= (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.

typedef MIPFieldIO MIPFieldIO::class_type

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.

   : FieldIO()
  { }

virtual MIPFieldIO::~MIPFieldIO ( )

inlinevirtual

Dtor.

Definition at line 105 of file MIPFieldIO.h.

  { /* Empty */ }

Member Function Documentation

static const char* MIPFieldIO::staticClassType ( )

inlinestatic

Definition at line 92 of file MIPFieldIO.h.

  {
    return "MIPFieldIO";
  }

static FieldIO::Ptr MIPFieldIO::create ( )

inlinestatic

Definition at line 108 of file MIPFieldIO.h.

References read(), and write().

Referenced by initIO().

  { return Ptr(new MIPFieldIO); }

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().

{
  Box3i extents, dataW;
  int components;
  
  if (layerGroup == -1)
    throw BadHdf5IdException("Bad layer group in MIPFieldIO::read");

  int version;
  if (!readAttribute(layerGroup, k_versionAttrName, 1, version))
    throw MissingAttributeException("Couldn't find attribute " + 
                                    k_versionAttrName);

  if (version != k_versionNumber)
    throw UnsupportedVersionException("MIPField version not supported: " + 
                                      lexical_cast<std::string>(version));

  if (!readAttribute(layerGroup, k_componentsStr, 1, components)) 
    throw MissingAttributeException("Couldn't find attribute " + 
                                    k_componentsStr);

  // Check data type ---

  int bits;
  if (!readAttribute(layerGroup, k_bitsPerComponentStr, 1, bits)) 
    throw MissingAttributeException("Couldn't find attribute: " +
                                    k_bitsPerComponentStr);  

  std::string baseType;
  if (!readAttribute(layerGroup, k_baseTypeStr, baseType)) {
    throw MissingAttributeException("Couldn't find attribute: " +
                                    k_baseTypeStr);
  }

  bool isHalf   = false;
  bool isFloat  = false;
  bool isDouble = false;

  switch (bits) {
  case 16:
    isHalf = true;
    break;
  case 64:
    isDouble = true;
    break;
  case 32:
  default:
    isFloat = true;
  }

  bool isSparse = false;
  bool isDense  = false;

  if (baseType == "SparseField") {
    isSparse = true;
  } else if (baseType == "DenseField") {
    isDense = true;
  }

  // Read the data ---

  FieldBase::Ptr result;

  if (isDense && isHalf && components == 1 && typeEnum == DataTypeHalf)
    result = readInternal<DenseField, half>(layerGroup, filename, 
                                            layerPath, typeEnum);
  if (isDense && isFloat && components == 1 && typeEnum == DataTypeFloat)
    result = readInternal<DenseField, float>(layerGroup, filename, 
                                             layerPath, typeEnum);
  if (isDense && isDouble && components == 1 && typeEnum == DataTypeDouble)
    result = readInternal<DenseField, double>(layerGroup, filename, 
                                              layerPath, typeEnum); 
  if (isDense && isHalf && components == 3 && typeEnum == DataTypeVecHalf)
    result = readInternal<DenseField, V3h>(layerGroup, filename, 
                                           layerPath, typeEnum);
  if (isDense && isFloat && components == 3 && typeEnum == DataTypeVecFloat)
    result = readInternal<DenseField, V3f>(layerGroup, filename, 
                                           layerPath, typeEnum);
  if (isDense && isDouble && components == 3 && typeEnum == DataTypeVecDouble)
    result = readInternal<DenseField, V3d>(layerGroup, filename, 
                                           layerPath, typeEnum);
  if (isSparse && isHalf && components == 1 && typeEnum == DataTypeHalf)
    result = readInternal<SparseField, half>(layerGroup, filename, 
                                            layerPath, typeEnum);
  if (isSparse && isFloat && components == 1 && typeEnum == DataTypeFloat)
    result = readInternal<SparseField, float>(layerGroup, filename, 
                                             layerPath, typeEnum);
  if (isSparse && isDouble && components == 1 && typeEnum == DataTypeDouble)
    result = readInternal<SparseField, double>(layerGroup, filename, 
                                              layerPath, typeEnum); 
  if (isSparse && isHalf && components == 3 && typeEnum == DataTypeVecHalf)
    result = readInternal<SparseField, V3h>(layerGroup, filename, 
                                           layerPath, typeEnum);
  if (isSparse && isFloat && components == 3 && typeEnum == DataTypeVecFloat)
    result = readInternal<SparseField, V3f>(layerGroup, filename, 
                                           layerPath, typeEnum);
  if (isSparse && isDouble && components == 3 && typeEnum == DataTypeVecDouble)
    result = readInternal<SparseField, V3d>(layerGroup, filename, 
                                           layerPath, typeEnum);

  return result;
}

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().

{
  if (layerGroup == -1) {
    throw BadHdf5IdException("Bad layer group in MIPFieldIO::write");
  }

  // Add version attribute
  if (!writeAttribute(layerGroup, k_versionAttrName, 
                      1, k_versionNumber)) {
    throw WriteAttributeException("Couldn't write attribute " + 
                                  k_versionAttrName);
  }

  MIPField<DenseField<half> >::Ptr halfDenseField = 
    field_dynamic_cast<MIPField<DenseField<half> > >(field);
  MIPField<DenseField<float> >::Ptr floatDenseField = 
    field_dynamic_cast<MIPField<DenseField<float> > >(field);
  MIPField<DenseField<double> >::Ptr doubleDenseField = 
    field_dynamic_cast<MIPField<DenseField<double> > >(field);
  MIPField<DenseField<V3h> >::Ptr vecHalfDenseField = 
    field_dynamic_cast<MIPField<DenseField<V3h> > >(field);
  MIPField<DenseField<V3f> >::Ptr vecFloatDenseField = 
    field_dynamic_cast<MIPField<DenseField<V3f> > >(field);
  MIPField<DenseField<V3d> >::Ptr vecDoubleDenseField = 
    field_dynamic_cast<MIPField<DenseField<V3d> > >(field);
  MIPField<SparseField<half> >::Ptr halfSparseField = 
    field_dynamic_cast<MIPField<SparseField<half> > >(field);
  MIPField<SparseField<float> >::Ptr floatSparseField = 
    field_dynamic_cast<MIPField<SparseField<float> > >(field);
  MIPField<SparseField<double> >::Ptr doubleSparseField = 
    field_dynamic_cast<MIPField<SparseField<double> > >(field);
  MIPField<SparseField<V3h> >::Ptr vecHalfSparseField = 
    field_dynamic_cast<MIPField<SparseField<V3h> > >(field);
  MIPField<SparseField<V3f> >::Ptr vecFloatSparseField = 
    field_dynamic_cast<MIPField<SparseField<V3f> > >(field);
  MIPField<SparseField<V3d> >::Ptr vecDoubleSparseField = 
    field_dynamic_cast<MIPField<SparseField<V3d> > >(field);

  bool success = true;

  if (floatDenseField) {
    success = writeInternal<DenseField, float>(layerGroup, floatDenseField);
  }
  else if (halfDenseField) {
    success = writeInternal<DenseField, half>(layerGroup, halfDenseField);
  }
  else if (doubleDenseField) {
    success = writeInternal<DenseField, double>(layerGroup, doubleDenseField);
  }
  else if (vecFloatDenseField) {
    success = writeInternal<DenseField, V3f>(layerGroup, vecFloatDenseField);
  }
  else if (vecHalfDenseField) {
    success = writeInternal<DenseField, V3h>(layerGroup, vecHalfDenseField);
  }
  else if (vecDoubleDenseField) {
    success = writeInternal<DenseField, V3d>(layerGroup, vecDoubleDenseField);
  }
  else if (floatSparseField) {
    success = writeInternal<SparseField, float>(layerGroup, floatSparseField);
  }
  else if (halfSparseField) {
    success = writeInternal<SparseField, half>(layerGroup, halfSparseField);
  }
  else if (doubleSparseField) {
    success = writeInternal<SparseField, double>(layerGroup, doubleSparseField);
  }
  else if (vecFloatSparseField) {
    success = writeInternal<SparseField, V3f>(layerGroup, vecFloatSparseField);
  }
  else if (vecHalfSparseField) {
    success = writeInternal<SparseField, V3h>(layerGroup, vecHalfSparseField);
  }
  else if (vecDoubleSparseField) {
    success = writeInternal<SparseField, V3d>(layerGroup, vecDoubleSparseField);
  }
  else {
    throw WriteLayerException("MIPFieldIO does not support the given "
                              "MIPField template parameter");
  }

  return success;
}

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().

  { 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().

{
  using namespace Exc;
  using namespace Hdf5Util;

  Box3i ext(field->extents()), dw(field->dataWindow());

  // Add extents attribute ---

  int extents[6] = 
    { ext.min.x, ext.min.y, ext.min.z, ext.max.x, ext.max.y, ext.max.z };

  if (!writeAttribute(layerGroup, k_extentsStr, 6, extents[0])) {
    throw WriteAttributeException("Couldn't write attribute " + k_extentsStr);
  }

  // Add data window attribute ---

  int dataWindow[6] = 
    { dw.min.x, dw.min.y, dw.min.z, dw.max.x, dw.max.y, dw.max.z };

  if (!writeAttribute(layerGroup, k_dataWindowStr, 6, dataWindow[0])) {
    throw WriteAttributeException("Couldn't write attribute " + k_dataWindowStr);
  }

  // Add components attribute ---

  int components = FieldTraits<Data_T>::dataDims();

  if (!writeAttribute(layerGroup, k_componentsStr, 1, components)) {
    throw WriteAttributeException("Couldn't write attribute " + k_componentsStr);
  }

  // Add the bits per component attribute ---

  int bits = DataTypeTraits<Data_T>::h5bits();
  if (!writeAttribute(layerGroup, k_bitsPerComponentStr, 1, bits)) {
    Msg::print(Msg::SevWarning, "Error adding bits per component attribute.");
    return false;
  }

  // Add the base type attribute ---

  std::string baseType = Field_T<Data_T>::staticClassName();
  if (!writeAttribute(layerGroup, k_baseTypeStr, baseType)) {
    throw WriteAttributeException("Couldn't write attribute " + k_baseTypeStr);
  }

  // Add the mip fields group

  H5ScopedGcreate mipGroup(layerGroup, k_mipGroupStr);

  // Write number of layers
  int numLevels = field->numLevels();
  if (!writeAttribute(mipGroup, k_levelsStr, 1, numLevels)) {
    throw WriteAttributeException("Couldn't write attribute " + k_levelsStr);
  }

  // For each level ---

  for (size_t i = 0; i < field->numLevels(); i++) {

    // Add a named group
    H5ScopedGcreate levelGroup(mipGroup, k_levelGroupStr + "." + 
                               boost::lexical_cast<std::string>(i));
    
    // Add the field to the group
    std::string className = Field_T<Data_T>::staticClassName();
    FieldIO::Ptr io = 
      ClassFactory::singleton().createFieldIO(className);
    io->write(levelGroup, field->mipLevel(i));

  }

  return true; 
}

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().

{
  using namespace detail;
  using namespace Exc;
  using namespace Hdf5Util;

  typedef MIPField<Field_T<Data_T> >              MIPType;
  typedef GenericLazyLoadAction<Field_T<Data_T> > Action;

  // Read extents
  Box3i extents;
  if (!readAttribute(layerGroup, k_extentsStr, 6, extents.min.x)) 
    throw MissingAttributeException("Couldn't find attribute " + 
                                    k_extentsStr);
  
  // Read data window
  Box3i dataW;
  if (!readAttribute(layerGroup, k_dataWindowStr, 6, dataW.min.x)) 
    throw MissingAttributeException("Couldn't find attribute " + 
                                    k_dataWindowStr);
  
  // Read components
  int components;
  if (!readAttribute(layerGroup, k_componentsStr, 1, components)) 
    throw MissingAttributeException("Couldn't find attribute " + 
                                    k_componentsStr);
  
  // Construct the resulting MIP field
  typename MIPType::Ptr result(new typename MIPInstance<Field_T<Data_T> >::type);

  // Open the MIP field group
  H5ScopedGopen mipGroup(layerGroup, k_mipGroupStr);

  // Read num levels
  int numLevels;
  if (!readAttribute(mipGroup, k_levelsStr, 1, numLevels)) 
    throw MissingAttributeException("Couldn't find attribute " + k_levelsStr);

  // Read each level ---

  std::vector<typename EmptyField<Data_T>::Ptr>  proxies;
  typename LazyLoadAction<Field_T<Data_T> >::Vec actions;

  for (int i = 0; i < numLevels; i++) {
    // Open level group
    std::string levelGroupStr = 
      k_levelGroupStr + "." + boost::lexical_cast<std::string>(i);
    H5ScopedGopen levelGroup(mipGroup, levelGroupStr);
    // Read the proxy
    typename EmptyField<Data_T>::Ptr proxy(new EmptyField<Data_T>);
    // Read extents
    if (!readAttribute(levelGroup, k_extentsStr, 6, extents.min.x)) 
      throw MissingAttributeException("Couldn't find attribute " + 
                                    k_extentsStr);
    // Read data window
    if (!readAttribute(levelGroup, k_dataWindowStr, 6, dataW.min.x)) 
      throw MissingAttributeException("Couldn't find attribute " + 
                                      k_dataWindowStr);
    // Configure proxy with resolution
    proxy->setSize(extents, dataW);
    proxies.push_back(proxy);
    // Make the lazy load action
    std::string fullPath = 
      layerPath + "/" + k_mipGroupStr + "/" + levelGroupStr;
    typename Action::Ptr action(new Action(filename, fullPath, typeEnum));
    actions.push_back(action);
  }

  result->setupLazyLoad(proxies, actions);

  return result;
}

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:

• export/MIPFieldIO.h
• src/MIPFieldIO.cpp