image_fileinput.h

Go to the documentation of this file.

#ifndef IMAGE_FILEINPUT_H
#define IMAGE_FILEINPUT_H

#include <list>
#include <map>
#include <Magick++.h>
#include "image_input.h"
#include "rgba.h"

namespace mimas {

template< typename T >
class image_fileinput: public image_input< T >
{
 public:
  explicit image_fileinput( std::istream &_stream ): stream( &_stream ) {}
  virtual void read( image< T > &image ) throw (mimasexception);
  static std::map< std::string, bool > formats(void);
 protected:
  static const char *mapString(void);
  std::istream *stream;
  boost::shared_ptr< std::list< Magick::Image > > images;
};

template<>
const char *image_fileinput< unsigned char >::mapString(void);

template<>
const char *image_fileinput< rgba< unsigned char > >::mapString(void);
 
template< typename T, typename U >
inline image_fileinput< T > &operator>>( image_fileinput< T > &input,
                                            image< U > &im )
{
  if ( typeid( T ) == typeid( U ) )
    input.read( (image< T > &)im );
  else {
    image< T > temp;
    input.read( temp );
    im = image< U >( temp );
  };
  return input;
}

inline std::istream &operator>>( std::istream &stream, image< unsigned char > &im )
{
  image_fileinput< unsigned char > input( stream );
  try {
    input >> im;
  } catch ( mimasexception & ) {
    stream.setstate( std::ios_base::failbit );
  };
  return stream;
}

inline std::istream &operator>>( std::istream &stream,
                                 image< int > &im )
{
  image_fileinput< unsigned char > input( stream );
  try {
    input >> im;
  } catch ( mimasexception & ) {
    stream.setstate( std::ios_base::failbit );
  };
  return stream;
}

inline std::istream &operator>>( std::istream &stream,
                                 image< float > &im )
{
  image_fileinput< unsigned char > input( stream );
  try {
    input >> im;
  } catch ( mimasexception & ) {
    stream.setstate( std::ios_base::failbit );
  };
  return stream;
}

inline std::istream &operator>>( std::istream &stream,
                                 image< double > &im )
{
  image_fileinput< unsigned char > input( stream );
  try {
    input >> im;
  } catch ( mimasexception & ) {
    stream.setstate( std::ios_base::failbit );
  };
  return stream;
}

inline std::istream &operator>>( std::istream &stream,
                                 image< rgba< unsigned char > >
                                 &im )
{
  image_fileinput< rgba< unsigned char > > input( stream );
  try {
    input >> im;
  } catch ( mimasexception & ) {
    stream.setstate( std::ios_base::failbit );
  };
  return stream;
}

inline std::istream &operator>>( std::istream &stream,
                                 image< rgba< int > >
                                 &im )
{
  image_fileinput< rgba< unsigned char > > input( stream );
  try {
    input >> im;
  } catch ( mimasexception & ) {
    stream.setstate( std::ios_base::failbit );
  };
  return stream;
}

inline std::istream &operator>>( std::istream &stream,
                                 image< rgba< double > >
                                 &im )
{
  image_fileinput< rgba< unsigned char > > input( stream );
  try {
    input >> im;
  } catch ( mimasexception & ) {
    stream.setstate( std::ios_base::failbit );
  };
  return stream;
}

inline std::istream &operator>>( std::istream &stream,
                                 image< rgba< float > >
                                 &im )
{
  image_fileinput< rgba< unsigned char > > input( stream );
  try {
    input >> im;
  } catch ( mimasexception & ) {
    stream.setstate( std::ios_base::failbit );
  };
  return stream;
}



};

#include "image_fileinput.tcc"

#endif

---