io.h

Go to the documentation of this file.

/* Copyright (C) 2000-2013 CEA
 *
 * This software and supporting documentation were developed by
 *     bioPICSEL
 *     CEA/DSV/I²BM/MIRCen/LMN, Batiment 61,
 *     18, route du Panorama
 *     92265 Fontenay-aux-Roses
 *     France
 */
 
#ifndef PRIMATOLOGIST_UTILITY_IO_H
#define PRIMATOLOGIST_UTILITY_IO_H
 
#include <aims/utility/converter_g.h>                // aims::ShallowConverter
#include <aims/io/io_g.h>                // aims::Process/Finder/Reader/Writer
#include <aims/io/channelR.h>                           // aims::ChannelReader
#include <cartodata/volume/volume.h>
 
namespace aims {
namespace io {
 
  template <typename T>
  void write( const T & object, const std::string & fname, bool doit = true )
  {
    if( doit )
    {
      Writer<T> w( fname );
      w << object;
    }
  }
 
  template <typename T>
  void read( const std::string & fname, T & object, bool doit = true )
  {
    if( doit )
    {
      Reader<T> r( fname );
      r >> object;
    }
  }
 
  template <typename T>
  void readChannel( const std::string & fname, T & object, int8_t channel, bool doit = true )
  {
    if( doit )
    {
      ChannelReader<T> r( fname );
      r.read( object, channel );
    }
  }
 
#ifndef DOXYGEN_HIDE_INTERNAL_CLASSES
  // Specialization for VolumeRef
  template <typename T>
  void readChannel( const std::string & fname, carto::VolumeRef<T> & object, int8_t channel, bool doit = true )
  {
    if( doit )
    {
      carto::VolumeRef<T> data( object );
      ChannelReader<carto::VolumeRef<T> > r( fname );
      r.read( data, channel );
      if( object.get() != data.get() )
        object = data;
    }
  }
#endif // DOXYGEN_HIDE_INTERNAL_CLASSES
 
#ifndef DOXYGEN_HIDE_INTERNAL_CLASSES
  // utility for convert reader
  namespace internal {
 
    template<typename IN, typename OUT>
    bool convert( Process & p, const std::string & fname, Finder & f );
 
    template <typename T>
    class VolumeConvertReader: public Process
    {
    public:
      VolumeConvertReader( carto::VolumeRef<T> & vol ):
        Process(),
        data( vol ),
        options()
        {
          registerProcessType( "Volume", "S8",      &convert<int8_t,T> );
          registerProcessType( "Volume", "U8",      &convert<uint8_t,T> );
          registerProcessType( "Volume", "S16",     &convert<int16_t,T> );
          registerProcessType( "Volume", "U16",     &convert<uint16_t,T> );
          registerProcessType( "Volume", "S32",     &convert<int32_t,T> );
          registerProcessType( "Volume", "U32",     &convert<uint32_t,T> );
          registerProcessType( "Volume", "S64",     &convert<int64_t,T> );
          registerProcessType( "Volume", "U64",     &convert<uint64_t,T> );
          registerProcessType( "Volume", "FLOAT",   &convert<float,T> );
          registerProcessType( "Volume", "DOUBLE",  &convert<double,T> );
        }
      virtual ~VolumeConvertReader() {}
 
      carto::Object options;
      carto::VolumeRef<T> & data;
    };
 
    template<typename IN, typename OUT>
    bool convert( Process & p, const std::string & fname, Finder & f )
    {
      VolumeConvertReader<OUT> & cc = (VolumeConvertReader<OUT> &) p;
      std::string fmt = f.format();
      Reader<carto::VolumeRef<IN> > r( fname );
      carto::VolumeRef<IN> data;
      r.read( data, 0, &fmt );
      r.setOptions( cc.options );
      if( cc.data.get() )
        cc.data.reallocate( data.getSizeX(), data.getSizeY(),
                            data.getSizeZ(), data.getSizeT() );
      else
        cc.data = carto::VolumeRef<OUT>( data.getSizeX(), data.getSizeY(),
                                         data.getSizeZ(), data.getSizeT() );
      carto::ShallowConverter<carto::VolumeRef<IN>, carto::VolumeRef<OUT> > conv;
      conv.convert( data, cc.data );
      cc.data.copyHeaderFrom( data.header() );
      return true;
    }
 
  } // namespace internal
#endif // DOXYGEN_HIDE_INTERNAL_CLASSES
 
  // Convert read
  // If the provided object data type is not the same as the disk data type,
  // a conversion (without dynamic resampling) is performed.
  template <typename T>
  void readConvert( const std::string & fname, carto::VolumeRef<T> & object, bool doit = true )
  {
    if( doit )
    {
      internal::VolumeConvertReader<T> cr(object);
      cr.execute(fname);
    }
  }
 
} // namespace io
} // namespace aims
 
#endif // PRIMATOLOGIST_UTILITY_IO_H