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.

typedef ImageContainer::Domain	Domain

typedef ImageContainer	OutputImage
	New types.

typedef OutputImage::Value	Value

Public Member Functions
	BOOST_CONCEPT_ASSERT ((concepts::CImage< TImageContainer >))
	Checking concepts.

	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.

const std::string	myFilename
	HDF5 filename and datasetname.

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'.

Examples: images/exampleImageFactoryFromHDF5.cpp, and images/raw2HDF5.cpp.

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::ImageContainerBySTLVector< TDomain, TValue >::domain(), 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;
    }