DGtal::ImageFactoryFromHDF5< TImageContainer > Class Template Reference

Aim: implements a factory from an HDF5 file. More...

#include <DGtal/images/ImageFactoryFromHDF5.h>

Public Types
typedef ImageFactoryFromHDF5< TImageContainer >	Self
typedef TImageContainer	ImageContainer
	Types copied from the container. More...
typedef ImageContainer::Domain	Domain
typedef ImageContainer	OutputImage
	New types. More...
typedef OutputImage::Value	Value

Public Member Functions
	BOOST_CONCEPT_ASSERT ((concepts::CImage< TImageContainer >))
	Checking concepts. More...
	BOOST_CONCEPT_ASSERT ((concepts::CBoundedNumber< Value >))
	ImageFactoryFromHDF5 (const std::string &aFilename, const std::string &aDataset)
	~ImageFactoryFromHDF5 ()
const Domain &	domain () const
void	selfDisplay (std::ostream &out) const
bool	isValid () const
OutputImage *	requestImage (const Domain &aDomain)
void	flushImage (OutputImage *outputImage)
void	detachImage (OutputImage *outputImage)

Data Fields
hid_t	file
hid_t	dataset
hid_t	datatype
hid_t	dataspace

Protected Attributes
Domain *	myDomain
	Alias on the image domain. More...
const std::string	myFilename
	HDF5 filename and datasetname. More...
const std::string	myDataset

Private Member Functions
	ImageFactoryFromHDF5 (const ImageFactoryFromHDF5 &other)
ImageFactoryFromHDF5 &	operator= (const ImageFactoryFromHDF5 &other)

Detailed Description

template<typename TImageContainer>
class DGtal::ImageFactoryFromHDF5< TImageContainer >

Aim: implements a factory from an HDF5 file.

Description of template class 'ImageFactoryFromHDF5'

Template Parameters

TImageContainer

an image container type (model of CImage).

The factory images production (images are copied, so it's a creation process) is done with the function 'requestImage' so the deletion must be done with the function 'detachImage'.

The update of the original image is done with the function 'flushImage'.

Definition at line 196 of file ImageFactoryFromHDF5.h.

Member Typedef Documentation

Domain

template<typename TImageContainer >

typedef ImageContainer::Domain DGtal::ImageFactoryFromHDF5< TImageContainer >::Domain

Definition at line 209 of file ImageFactoryFromHDF5.h.

ImageContainer

template<typename TImageContainer >

typedef TImageContainer DGtal::ImageFactoryFromHDF5< TImageContainer >::ImageContainer

Types copied from the container.

Definition at line 208 of file ImageFactoryFromHDF5.h.

OutputImage

template<typename TImageContainer >

typedef ImageContainer DGtal::ImageFactoryFromHDF5< TImageContainer >::OutputImage

New types.

Definition at line 212 of file ImageFactoryFromHDF5.h.

Self

template<typename TImageContainer >

typedef ImageFactoryFromHDF5<TImageContainer> DGtal::ImageFactoryFromHDF5< TImageContainer >::Self

Definition at line 202 of file ImageFactoryFromHDF5.h.

Value

template<typename TImageContainer >

typedef OutputImage::Value DGtal::ImageFactoryFromHDF5< TImageContainer >::Value

Definition at line 213 of file ImageFactoryFromHDF5.h.

Constructor & Destructor Documentation

ImageFactoryFromHDF5() [1/2]

template<typename TImageContainer >

DGtal::ImageFactoryFromHDF5< TImageContainer >::ImageFactoryFromHDF5 ( const std::string &  aFilename, const std::string &  aDataset  )

inline

Constructor.

Parameters

aFilename	HDF5 filename.
aDataset	datasetname.

Definition at line 226 of file ImageFactoryFromHDF5.h.

                                                                                 :
      myFilename(aFilename), myDataset(aDataset)
    {
      const int ddim = Domain::dimension;
 
      hsize_t dims_out[ddim];              // dataset dimensions
 
      // Open the file and the dataset.
      file = H5Fopen(myFilename.c_str(), H5F_ACC_RDWR, H5P_DEFAULT);
      dataset = H5Dopen2(file, myDataset.c_str(), H5P_DEFAULT);
 
      // Get datatype and dataspace handles and then query dataset class, order, size, rank and dimensions.
      datatype = H5Dget_type(dataset); // datatype handle
 
      dataspace = H5Dget_space(dataset); // dataspace handle
 
      H5Sget_simple_extent_dims(dataspace, dims_out, NULL);
 
      // --
 
      typedef SpaceND<ddim> TSpace;
      typename TSpace::Point low, up;
 
      typename Domain::Integer d;
      for(d=0; d<ddim; d++)
      {
        low[d]=0;
        up[d]=dims_out[ddim-d-1]-1;
      }
 
      myDomain = new Domain(low, up);
    }

References DGtal::ImageFactoryFromHDF5< TImageContainer >::dataset, DGtal::ImageFactoryFromHDF5< TImageContainer >::dataspace, DGtal::ImageFactoryFromHDF5< TImageContainer >::datatype, DGtal::ImageFactoryFromHDF5< TImageContainer >::file, DGtal::ImageFactoryFromHDF5< TImageContainer >::myDataset, DGtal::ImageFactoryFromHDF5< TImageContainer >::myDomain, and DGtal::ImageFactoryFromHDF5< TImageContainer >::myFilename.

~ImageFactoryFromHDF5()

template<typename TImageContainer >

DGtal::ImageFactoryFromHDF5< TImageContainer >::~ImageFactoryFromHDF5 ( )

inline

Destructor.

Definition at line 262 of file ImageFactoryFromHDF5.h.

    {
      delete myDomain;
 
      // --
 
      // Close/release resources.
      H5Tclose(datatype);
      H5Dclose(dataset);
      H5Sclose(dataspace);
      H5Fclose(file);
    }

References DGtal::ImageFactoryFromHDF5< TImageContainer >::dataset, DGtal::ImageFactoryFromHDF5< TImageContainer >::dataspace, DGtal::ImageFactoryFromHDF5< TImageContainer >::datatype, DGtal::ImageFactoryFromHDF5< TImageContainer >::file, and DGtal::ImageFactoryFromHDF5< TImageContainer >::myDomain.

ImageFactoryFromHDF5() [2/2]

template<typename TImageContainer >

DGtal::ImageFactoryFromHDF5< TImageContainer >::ImageFactoryFromHDF5 ( const ImageFactoryFromHDF5< TImageContainer > &  other )

private

Member Function Documentation

BOOST_CONCEPT_ASSERT() [1/2]

template<typename TImageContainer >

DGtal::ImageFactoryFromHDF5< TImageContainer >::BOOST_CONCEPT_ASSERT

(

(concepts::CBoundedNumber< Value >)

)

BOOST_CONCEPT_ASSERT() [2/2]

template<typename TImageContainer >

DGtal::ImageFactoryFromHDF5< TImageContainer >::BOOST_CONCEPT_ASSERT

(

(concepts::CImage< TImageContainer >)

)

Checking concepts.

detachImage()

template<typename TImageContainer >

void DGtal::ImageFactoryFromHDF5< TImageContainer >::detachImage ( OutputImage *  outputImage )

inline

Free (i.e. delete) an OutputImage.

Parameters

outputImage

the OutputImage.

Definition at line 543 of file ImageFactoryFromHDF5.h.

    {
      delete outputImage;
    }

domain()

template<typename TImageContainer >

const Domain& DGtal::ImageFactoryFromHDF5< TImageContainer >::domain ( ) const

inline

Returns a reference to the underlying image domain.

Returns

a reference to the domain.

Definition at line 291 of file ImageFactoryFromHDF5.h.

    {
        return *myDomain;
    }

References DGtal::ImageFactoryFromHDF5< TImageContainer >::myDomain.

flushImage()

template<typename TImageContainer >

void DGtal::ImageFactoryFromHDF5< TImageContainer >::flushImage ( OutputImage *  outputImage )

inline

Flush (i.e. write/synchronize) an OutputImage.

Parameters

outputImage

the OutputImage.

Definition at line 435 of file ImageFactoryFromHDF5.h.

    {
      DGtal::IOException dgtalio;
      
      const int ddim = Domain::dimension;
 
      // --
 
      hsize_t offset[ddim];        // hyperslab offset in the file
      hsize_t count[ddim];         // size of the hyperslab in the file
 
      herr_t status;
      hsize_t dimsm[ddim];         // memory space dimensions
      hid_t memspace;
 
      hsize_t offset_in[ddim];    // hyperslab offset in memory
      hsize_t count_in[ddim];     // size of the hyperslab in memory
 
      //int i[ddim];
      int N_SUB[ddim];
      typename Domain::Integer d;
 
      int malloc_size=1;
      for(d=0; d<ddim; d++)
      {
        N_SUB[d] = (outputImage->domain().upperBound()[ddim-d-1]-outputImage->domain().lowerBound()[ddim-d-1])+1;
        malloc_size = malloc_size*N_SUB[d];
      }
 
      Value *data_in = (Value*) malloc (malloc_size * sizeof(Value)); // input buffer
      if (data_in == NULL)
      {
        trace.error() << "data_in malloc error in flushImage: " << (malloc_size * sizeof(Value)) << std::endl;
        throw dgtalio;
      }
 
      // Define hyperslab in the dataset.
      for(d=0; d<ddim; d++)
        offset[d] = outputImage->domain().lowerBound()[ddim-d-1]-myDomain->lowerBound()[ddim-d-1];
      for(d=0; d<ddim; d++)
        count[d] = N_SUB[d];
      status = H5Sselect_hyperslab(dataspace, H5S_SELECT_SET, offset, NULL, count, NULL);
      if (status)
      {
        trace.error() << " H5Sselect_hyperslab from dataspace error" << std::endl;
        throw dgtalio;
      }
 
      // Define the memory dataspace.
      for(d=0; d<ddim; d++)
        dimsm[d] = N_SUB[d];
      memspace = H5Screate_simple(ddim,dimsm,NULL);
 
      // Define memory hyperslab.
      for(d=0; d<ddim; d++)
        offset_in[d] = 0;
      for(d=0; d<ddim; d++)
        count_in[d] = N_SUB[d];
      status = H5Sselect_hyperslab(memspace, H5S_SELECT_SET, offset_in, NULL, count_in, NULL);
      if (status)
      {
        trace.error() << " H5Sselect_hyperslab from memspace error" << std::endl;
        throw dgtalio;
      }
 
      typedef SpaceND<ddim> TSpace;
      typename TSpace::Point a, b;
      for(d=0; d<ddim; d++)
      {
        a[d]=offset[ddim-d-1]+myDomain->lowerBound()[d];
        b[d]=a[d]+N_SUB[ddim-d-1]-1;
      }
      HyperRectDomain<TSpace> hrdomain(a,b);
 
      std::vector<typename TSpace::Dimension> v(ddim);
      for(d=0; d<ddim; d++)
        v[d]=d;
 
      int p=0;
      for( typename HyperRectDomain<TSpace>::ConstSubRange::ConstIterator
            it = hrdomain.subRange(v, a).begin(), itend = hrdomain.subRange(v, a).end();
          it != itend;
          ++it)
      {
        data_in[ p++ ] = outputImage->operator()((*it));
      }
 
      // Write data from hyperslab in memory into the hyperslab in the file.
      //status = H5Dwrite(dataset, H5T_NATIVE_INT, memspace, dataspace, H5P_DEFAULT, data_in);
      status = H5DSpecializations<Self, Value>::H5DwriteS(*this, memspace, data_in);
      if (status)
      {
        trace.error() << " H5DSpecializations/H5DwriteS error" << std::endl;
        throw dgtalio;
      }
 
      H5Sclose(memspace);
 
      // --
 
      free(data_in);
    }

References DGtal::HyperRectDomain< TSpace >::ConstSubRange::begin(), DGtal::ImageFactoryFromHDF5< TImageContainer >::dataspace, DGtal::HyperRectDomain< TSpace >::ConstSubRange::end(), DGtal::Trace::error(), DGtal::H5DSpecializations< TImageFactory, T >::H5DwriteS(), DGtal::ImageFactoryFromHDF5< TImageContainer >::myDomain, DGtal::HyperRectDomain< TSpace >::subRange(), and DGtal::trace.

isValid()

template<typename TImageContainer >

bool DGtal::ImageFactoryFromHDF5< TImageContainer >::isValid ( ) const

inline

Checks the validity/consistency of the object.

Returns

'true' if the object is valid, 'false' otherwise.

Definition at line 311 of file ImageFactoryFromHDF5.h.

    {
      return (myDomain->isValid());
    }

References DGtal::ImageFactoryFromHDF5< TImageContainer >::myDomain.

operator=()

template<typename TImageContainer >

ImageFactoryFromHDF5& DGtal::ImageFactoryFromHDF5< TImageContainer >::operator= ( const ImageFactoryFromHDF5< TImageContainer > &  other )

private

requestImage()

template<typename TImageContainer >

OutputImage* DGtal::ImageFactoryFromHDF5< TImageContainer >::requestImage ( const Domain &  aDomain )

inline

Returns a pointer of an OutputImage created with the Domain aDomain.

Parameters

aDomain

the domain.

Returns

an ImagePtr.

Definition at line 323 of file ImageFactoryFromHDF5.h.

    {
      DGtal::IOException dgtalio;
      
      const int ddim = Domain::dimension;
 
      // --
 
      hsize_t offset[ddim];        // hyperslab offset in the file
      hsize_t count[ddim];         // size of the hyperslab in the file
 
      herr_t status;
      hsize_t dimsm[ddim];         // memory space dimensions
      hid_t memspace;
 
      hsize_t offset_out[ddim];    // hyperslab offset in memory
      hsize_t count_out[ddim];     // size of the hyperslab in memory
 
      int N_SUB[ddim];
      typename Domain::Integer d;
 
      int malloc_size=1;
      for(d=0; d<ddim; d++)
      {
        N_SUB[d] = (aDomain.upperBound()[ddim-d-1]-aDomain.lowerBound()[ddim-d-1])+1;
        malloc_size = malloc_size*N_SUB[d];
      }
 
      Value *data_out = (Value*) malloc (malloc_size * sizeof(Value)); // output buffer
      if (data_out == NULL)
      {
        trace.error() << "data_out malloc error in requestImage: " << (malloc_size * sizeof(Value)) << std::endl;
        throw dgtalio;
      }
 
      // Define hyperslab in the dataset.
      for(d=0; d<ddim; d++)
        offset[d] = aDomain.lowerBound()[ddim-d-1]-myDomain->lowerBound()[ddim-d-1];
      for(d=0; d<ddim; d++)
        count[d] = N_SUB[d];
      status = H5Sselect_hyperslab(dataspace, H5S_SELECT_SET, offset, NULL, count, NULL);
      if (status)
      {
        trace.error() << " H5Sselect_hyperslab from dataspace error" << std::endl;
        throw dgtalio;
      }
 
      // Define the memory dataspace.
      for(d=0; d<ddim; d++)
        dimsm[d] = N_SUB[d];
      memspace = H5Screate_simple(ddim,dimsm,NULL);
 
      // Define memory hyperslab.
      for(d=0; d<ddim; d++)
        offset_out[d] = 0;
      for(d=0; d<ddim; d++)
        count_out[d] = N_SUB[d];
      status = H5Sselect_hyperslab(memspace, H5S_SELECT_SET, offset_out, NULL, count_out, NULL);
      if (status)
      {
        trace.error() << " H5Sselect_hyperslab from memspace error" << std::endl;
        throw dgtalio;
      }
 
      // Read data from hyperslab in the file into the hyperslab in memory.
      //status = H5Dread(dataset, H5T_NATIVE_INT, memspace, dataspace, H5P_DEFAULT, data_out);
      status = H5DSpecializations<Self, Value>::H5DreadS(*this, memspace, data_out);
      if (status)
      {
        trace.error() << " H5DSpecializations/H5DreadS error" << std::endl;
        throw dgtalio;
      }
 
      OutputImage* outputImage = new OutputImage(aDomain);
      if (outputImage == NULL)
      {
        trace.error() << "outputImage new error in requestImage: " << std::endl;
        throw dgtalio;
      }
 
      typedef SpaceND<ddim> TSpace;
      typename TSpace::Point a, b;
      for(d=0; d<ddim; d++)
      {
        a[d]=offset[ddim-d-1]+myDomain->lowerBound()[d];
        b[d]=a[d]+N_SUB[ddim-d-1]-1;
      }
      HyperRectDomain<TSpace> hrdomain(a,b);
 
      int p=0;
      for( typename HyperRectDomain<TSpace>::ConstIterator
            it = hrdomain.begin(), itend = hrdomain.end();
          it != itend;
          ++it)
      {
        outputImage->setValue((*it), data_out[ p++ ]);
      }
 
      H5Sclose(memspace);
 
      // --
 
      free(data_out);
 
      return outputImage;
    }

References DGtal::HyperRectDomain< TSpace >::begin(), DGtal::ImageFactoryFromHDF5< TImageContainer >::dataspace, DGtal::HyperRectDomain< TSpace >::end(), DGtal::Trace::error(), DGtal::H5DSpecializations< TImageFactory, T >::H5DreadS(), DGtal::ImageFactoryFromHDF5< TImageContainer >::myDomain, and DGtal::trace.

selfDisplay()

template<typename TImageContainer >

void DGtal::ImageFactoryFromHDF5< TImageContainer >::selfDisplay

(

std::ostream &

out

)

const

Writes/Displays the object on an output stream.

Parameters

out	the output stream where the object is written.

Field Documentation

dataset

template<typename TImageContainer >

hid_t DGtal::ImageFactoryFromHDF5< TImageContainer >::dataset

Definition at line 568 of file ImageFactoryFromHDF5.h.

Referenced by DGtal::ImageFactoryFromHDF5< TImageContainer >::ImageFactoryFromHDF5(), and DGtal::ImageFactoryFromHDF5< TImageContainer >::~ImageFactoryFromHDF5().

dataspace

template<typename TImageContainer >

hid_t DGtal::ImageFactoryFromHDF5< TImageContainer >::dataspace

Definition at line 569 of file ImageFactoryFromHDF5.h.

Referenced by DGtal::ImageFactoryFromHDF5< TImageContainer >::flushImage(), DGtal::ImageFactoryFromHDF5< TImageContainer >::ImageFactoryFromHDF5(), DGtal::ImageFactoryFromHDF5< TImageContainer >::requestImage(), and DGtal::ImageFactoryFromHDF5< TImageContainer >::~ImageFactoryFromHDF5().

datatype

template<typename TImageContainer >

hid_t DGtal::ImageFactoryFromHDF5< TImageContainer >::datatype

Definition at line 569 of file ImageFactoryFromHDF5.h.

Referenced by DGtal::ImageFactoryFromHDF5< TImageContainer >::ImageFactoryFromHDF5(), and DGtal::ImageFactoryFromHDF5< TImageContainer >::~ImageFactoryFromHDF5().

file

template<typename TImageContainer >

hid_t DGtal::ImageFactoryFromHDF5< TImageContainer >::file

Definition at line 568 of file ImageFactoryFromHDF5.h.

Referenced by DGtal::ImageFactoryFromHDF5< TImageContainer >::ImageFactoryFromHDF5(), and DGtal::ImageFactoryFromHDF5< TImageContainer >::~ImageFactoryFromHDF5().

myDataset

template<typename TImageContainer >

const std::string DGtal::ImageFactoryFromHDF5< TImageContainer >::myDataset

protected

Definition at line 563 of file ImageFactoryFromHDF5.h.

Referenced by DGtal::ImageFactoryFromHDF5< TImageContainer >::ImageFactoryFromHDF5().

myDomain

template<typename TImageContainer >

Domain* DGtal::ImageFactoryFromHDF5< TImageContainer >::myDomain

protected

Alias on the image domain.

Default constructor.

Definition at line 559 of file ImageFactoryFromHDF5.h.

Referenced by DGtal::ImageFactoryFromHDF5< TImageContainer >::domain(), DGtal::ImageFactoryFromHDF5< TImageContainer >::flushImage(), DGtal::ImageFactoryFromHDF5< TImageContainer >::ImageFactoryFromHDF5(), DGtal::ImageFactoryFromHDF5< TImageContainer >::isValid(), DGtal::ImageFactoryFromHDF5< TImageContainer >::requestImage(), and DGtal::ImageFactoryFromHDF5< TImageContainer >::~ImageFactoryFromHDF5().

myFilename

template<typename TImageContainer >

const std::string DGtal::ImageFactoryFromHDF5< TImageContainer >::myFilename

protected

HDF5 filename and datasetname.

Definition at line 562 of file ImageFactoryFromHDF5.h.

Referenced by DGtal::ImageFactoryFromHDF5< TImageContainer >::ImageFactoryFromHDF5().

---

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

• ImageFactoryFromHDF5.h