GenericReader.h

 
#pragma once
 
#if defined(GenericReader_RECURSES)
#error Recursive header files inclusion detected in GenericReader.h
#else // defined(GenericReader_RECURSES)
#define GenericReader_RECURSES
 
#if !defined GenericReader_h
#define GenericReader_h
 
// Inclusions
#include <iostream>
#include <vector>
#include "DGtal/images/CImage.h"
#include "DGtal/base/Common.h"
#include "DGtal/io/readers/VolReader.h"
#include "DGtal/io/readers/LongvolReader.h"
#include "DGtal/io/readers/PPMReader.h"
#include "DGtal/io/readers/PGMReader.h"
#include "DGtal/io/readers/RawReader.h"
#ifdef WITH_HDF5
#include "DGtal/io/readers/HDF5Reader.h"
#endif
#ifdef WITH_MAGICK
#include "DGtal/io/readers/MagickReader.h"
#endif
#ifdef WITH_ITK
#include "DGtal/io/readers/DicomReader.h"
#include "DGtal/io/readers/ITKReader.h"
#endif
#include "DGtal/io/colormaps/BasicColorToScalarFunctors.h"
 
 
namespace DGtal
{
 
  // template class GenericReader
  template <typename TContainer, int Tdim=TContainer::Point::dimension,  typename TValue = typename TContainer::Value>
  struct GenericReader
  {
    BOOST_CONCEPT_ASSERT((  concepts::CImage<TContainer> )) ;
 
    static TContainer import(const std::string &filename,
                             std::vector<unsigned int> dimSpace= std::vector<unsigned int > () );
 
    template <typename TFunctor>
    static TContainer importWithValueFunctor(
    const std::string & filename, const TFunctor & aFunctor,
    std::vector<unsigned int> dimSpace =
    std::vector<unsigned int>() )
    {
      BOOST_CONCEPT_ASSERT(
      (concepts::CUnaryFunctor<TFunctor, TValue, typename TContainer::Value>));
      DGtal::IOException dgtalio;
      const std::string extension =
      filename.substr( filename.find_last_of( "." ) + 1 );
 
      if ( extension == "raw" )
      {
        for ( unsigned int i = 0; i < dimSpace.size(); i++ )
          ASSERT( dimSpace[ i ] != 0 );
        typename TContainer::Point const pt;
        for ( unsigned int i = 0; i < dimSpace.size(); i++ )
          pt[ i ]            = dimSpace[ i ];
 
        return RawReader<TContainer, TFunctor>::template importRaw<TValue>(
        filename, pt, aFunctor );
      }
 
      trace.error() << "Extension " << extension
                    << " not yet implemented in DGtal GenericReader."
                    << std::endl;
      throw dgtalio;
    }
 
    template <typename TFunctor>
    static TContainer importWithColorFunctor(
    const std::string & filename, const TFunctor & aFunctor,
    std::vector<unsigned int> dimSpace =
    std::vector<unsigned int>() )
 
    {
      BOOST_CONCEPT_ASSERT(
      (concepts::CUnaryFunctor<TFunctor, DGtal::Color,
                               typename TContainer::Value>));
 
      DGtal::IOException dgtalio;
      const std::string extension =
      filename.substr( filename.find_last_of( "." ) + 1 );
 
      if ( extension == "raw" )
      {
        for ( unsigned int i = 0; i < dimSpace.size(); i++ )
          ASSERT( dimSpace[ i ] != 0 );
        typename TContainer::Point const pt;
        for ( unsigned int i = 0; i < dimSpace.size(); i++ )
          pt[ i ]            = dimSpace[ i ];
        return RawReader<TContainer, TFunctor>::template importRaw<
        DGtal::Color>( filename, pt, aFunctor );
      }
 
      trace.error() << "Extension " << extension
                    << " not yet implemented in DGtal GenericReader."
                    << std::endl;
      throw dgtalio;
    }
  };
 
 
  template <typename TContainer, typename TValue>
  struct GenericReader<TContainer, 3, TValue>
  {
    BOOST_CONCEPT_ASSERT((  concepts::CImage<TContainer> )) ;
    static TContainer import(const std::string &filename,  unsigned int x=0,
                             unsigned int y=0, unsigned int z=0);
 
 
 
    template<typename TFunctor>
    static TContainer importWithValueFunctor(const std::string &filename,
                                             const TFunctor &aFunctor,
                                             unsigned int x=0,
                                             unsigned int y=0, unsigned int z=0)
      {
        BOOST_CONCEPT_ASSERT((  concepts::CUnaryFunctor<TFunctor, unsigned char, typename TContainer::Value > )) ;
        DGtal::IOException dgtalio;
        const std::string extension = filename.substr(filename.find_last_of(".") + 1);
 
        if ( extension == "vol" )
          {
            return VolReader<TContainer, TFunctor>::importVol( filename, aFunctor );
          }
        else if ( extension == "longvol" )
          {
            return LongvolReader<TContainer, TFunctor>::importLongvol( filename, aFunctor  );
          }
        else if ( extension == "pgm3d" || extension == "pgm3D" || extension == "p3d" || extension == "pgm" )
          {
            return PGMReader<TContainer, TFunctor>::importPGM3D(filename, aFunctor);
          }
        else if ( extension == "raw" )
          {
            ASSERT( x != 0 && y != 0 && z != 0 );
            typename TContainer::Point const pt (x, y, z);
            return RawReader< TContainer, TFunctor >::template importRaw<TValue>( filename, pt, aFunctor  );
          }
 
#ifdef WITH_HDF5
        if ( extension == "h5" )
          return HDF5Reader<TContainer, TFunctor>::importHDF5_3D(filename, "UInt8Array3D", aFunctor);
#endif
 
#ifdef WITH_ITK
        if ( extension == "dcm" )
          {
            return DicomReader<TContainer, TFunctor>::importDicom(filename, aFunctor);
          }
          else if ( extension == "nii" || extension == "mha" ||
                    extension == "mhd" || extension == "tiff" ||
                    extension == "tif" )
          {
            return ITKReader<TContainer>::importITK( filename, aFunctor );
          }
#endif
 
        trace.error() << "Extension " << extension<< " in 3D, not yet implemented in DGtal GenericReader." << std::endl;
        throw dgtalio;
      }
  };
 
 
 
  template <typename TContainer>
  struct GenericReader<TContainer, 3 , DGtal::uint32_t>
  {
    BOOST_CONCEPT_ASSERT((  concepts::CImage<TContainer> )) ;
    static TContainer import(const std::string &filename,  unsigned int x=0,
                             unsigned int y=0, unsigned int z=0);
 
 
 
    template<typename TFunctor>
    static TContainer importWithValueFunctor(const std::string &filename,
                                             const TFunctor &aFunctor,
                                             unsigned int x=0,
                                             unsigned int y=0, unsigned int z=0)
      {
        BOOST_CONCEPT_ASSERT((  concepts::CUnaryFunctor<TFunctor, DGtal::uint32_t, typename TContainer::Value > )) ;
        DGtal::IOException dgtalio;
        const std::string extension = filename.substr( filename.find_last_of(".") + 1 );
 
        if ( extension == "longvol" )
          {
            return LongvolReader<TContainer, TFunctor>::importLongvol( filename, aFunctor  );
          }
        else if ( extension == "raw" )
          {
            ASSERT( x != 0 && y != 0 && z != 0 );
            typename TContainer::Point const pt (x, y, z);
            return RawReader< TContainer, TFunctor >::importRaw32 ( filename, pt, aFunctor  );
          }
 
#ifdef WITH_ITK
        if ( extension == "dcm" )
          {
            return DicomReader<TContainer, TFunctor>::importDicom(filename, aFunctor);
          }
        else if ( extension == "mha" || extension == "mhd" )
          {
            return ITKReader<TContainer>::importITK( filename, aFunctor );
          }
#endif
 
        trace.error() << "Extension " << extension<< " not yet implemented in DGtal GenericReader." << std::endl;
        throw dgtalio;
      }
  };
 
 
 
 
  template <typename TContainer>
  struct GenericReader<TContainer, 3 , DGtal::uint64_t>
  {
    BOOST_CONCEPT_ASSERT((  concepts::CImage<TContainer> )) ;
    static TContainer import(const std::string &filename);
 
  };
 
 
  template <typename TContainer, typename TValue>
  struct GenericReader<TContainer, 2, TValue>
  {
    BOOST_CONCEPT_ASSERT((  concepts::CImage<TContainer> )) ;
 
    static TContainer import(const std::string &filename, unsigned int x=0,
                             unsigned int y=0);
 
 
    template<typename TFunctor>
    static TContainer importWithColorFunctor(const std::string &filename,
                                             const  TFunctor &aFunctor,
                                             unsigned int x=0,
                                             unsigned int y=0)
      {
        BOOST_CONCEPT_ASSERT((  concepts::CUnaryFunctor<TFunctor, DGtal::Color, typename TContainer::Value> )) ;
        DGtal::IOException dgtalio;
        //Getting image extension
        const std::string extension = filename.substr( filename.find_last_of(".") + 1 );
 
        if ( extension == "ppm" )
          {
            return PPMReader<TContainer, TFunctor>::importPPM(filename, aFunctor);
          }
        else if ( extension == "raw" )
          {
            ASSERT( x != 0 && y != 0 );
            typename TContainer::Point const pt (x,y);
            return RawReader< TContainer, TFunctor >::template importRaw<DGtal::Color>( filename, pt, aFunctor);
          }
        else if ( extension == "gif" || extension == "jpg" || extension == "png" || extension == "jpeg" || extension == "bmp" )
          {
#ifdef WITH_MAGICK
            MagickReader<TContainer, TFunctor> reader;
            return reader.importImage( filename, aFunctor );
#else
            trace.error() << "Extension " << extension<< " not yet implemented in DGtal but you can add Magick option to deal with this image type." << std::endl;
            throw dgtalio;
#endif
          }
 
        trace.error() << "Extension " << extension<< " in 2D, not yet implemented in DGtal GenericReader." << std::endl;
        throw dgtalio;
      }
 
 
    template<typename TFunctor>
    static TContainer importWithValueFunctor(const std::string &filename,
                                             const  TFunctor &aFunctor, unsigned int x=0,
                                             unsigned int y=0)
      {
        BOOST_CONCEPT_ASSERT((  concepts::CUnaryFunctor<TFunctor, unsigned char, typename TContainer::Value > )) ;
 
        DGtal::IOException dgtalio;
        //Getting image extension
        const std::string extension = filename.substr( filename.find_last_of(".") + 1 );
 
        if ( extension == "raw" )
          {
            ASSERT( x!= 0 && y != 0);
            typename TContainer::Point const pt (x,y);
            return RawReader< TContainer, TFunctor >::importRaw8( filename, pt, aFunctor  );
          }
        else if ( extension == "pgm" )
          {
            return PGMReader<TContainer, TFunctor>::importPGM(filename, aFunctor);
          }
 
#ifdef WITH_HDF5
        if (extension=="h5")
          return HDF5Reader<TContainer, TFunctor>::importHDF5(filename, "image8bit", aFunctor);
#endif
 
        trace.error() << "Extension " << extension<< " not yet implemented in DGtal GenericReader." << std::endl;
        throw dgtalio;
 
      }
 
  };
 
  template <typename TContainer>
  struct GenericReader<TContainer, 2, DGtal::uint32_t>
  {
    BOOST_CONCEPT_ASSERT((  concepts::CImage<TContainer> )) ;
 
    static TContainer import(const std::string &filename,unsigned int x=0,
                             unsigned int y=0 );
 
 
    template<typename TFunctor>
    static TContainer importWithColorFunctor(const std::string &filename,
                                             const  TFunctor &aFunctor, unsigned int x=0,
                                             unsigned int y=0)
      {
 
        BOOST_CONCEPT_ASSERT((  concepts::CUnaryFunctor<TFunctor, DGtal::Color, typename TContainer::Value> )) ;
        DGtal::IOException dgtalio;
        //Getting image extension
        const std::string extension = filename.substr(filename.find_last_of(".") + 1);
 
        if ( extension == "ppm" )
          {
            return PPMReader<TContainer, TFunctor>::importPPM(filename, aFunctor);
          }
        else if ( extension == "raw" )
          {
            ASSERT( x != 0 && y != 0 );
            typename TContainer::Point const pt (x,y);
            return RawReader< TContainer, TFunctor >::template importRaw<DGtal::Color>( filename, pt, aFunctor);
          }
        else if ( extension == "gif" || extension == "jpg" || extension == "png" || extension == "jpeg" || extension == "bmp" )
          {
#ifdef WITH_MAGICK
            MagickReader<TContainer, TFunctor> reader;
            return reader.importImage( filename, aFunctor );
#else
            trace.error() << "Extension " << extension<< " not yet implemented in DGtal but you can add Magick option to deal with this image type." << std::endl;
            throw dgtalio;
#endif
          }
 
        trace.error() << "Extension " << extension<< " not yet implemented in DGtal GenericReader." << std::endl;
        throw dgtalio;
      }
 
 
    template<typename TFunctor>
    static TContainer importWithValueFunctor(const std::string &filename,
                                             const  TFunctor &aFunctor, unsigned int x=0,
                                             unsigned int y=0)
      {
        BOOST_CONCEPT_ASSERT((  concepts::CUnaryFunctor<TFunctor, unsigned char, typename TContainer::Value > )) ;
 
        DGtal::IOException dgtalio;
        //Getting image extension
        const std::string extension = filename.substr(filename.find_last_of(".") + 1);
 
        if ( extension == "raw" )
          {
            ASSERT( x != 0 && y != 0);
            typename TContainer::Point const pt (x,y);
            return RawReader< TContainer, TFunctor >::importRaw8 ( filename, pt, aFunctor  );
          }
        else if ( extension == "pgm ")
          {
            return PGMReader<TContainer, TFunctor>::importPGM(filename, aFunctor);
          }
 
#ifdef WITH_HDF5
        if (extension=="h5")
          return HDF5Reader<TContainer, TFunctor>::importHDF5(filename, "image8bit", aFunctor);
#endif
 
        trace.error() << "Extension " << extension<< " not yet implemented in DGtal GenericReader." << std::endl;
        throw dgtalio;
 
      }
 
  };
 
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/io/readers/GenericReader.ih"
 
//                                                                           //
 
#endif // !defined GenericReader_h
 
#undef GenericReader_RECURSES
#endif // else defined(GenericReader_RECURSES)