image_fileoutput.h

Go to the documentation of this file.

#ifndef IMAGE_FILEOUTPUT_H
#define IMAGE_FILEOUTPUT_H

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

namespace mimas {

template< typename T >
class image_fileoutput: public image_output< T >
{
 public:
  explicit image_fileoutput( std::ostream &_stream ): stream( &_stream ) {}
  virtual ~image_fileoutput(void);
  virtual void write( const const_image_ref< T > &image );
  static std::map< std::string, bool > formats(void);
 protected:
  static const char *mapString(void);
  static const char *defaultFormat(void);
  std::ostream *stream;
  std::list< Magick::Image > buffer;
};

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

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

template<>
const char *image_fileoutput< unsigned char >::defaultFormat(void);

template<>
const char *image_fileoutput< rgba< unsigned char > >::defaultFormat(void);

extern const char *image_fileoutput_fileType;

struct _format { const char *name; };
inline _format setformat( const char *name )
{ _format retVal; retVal.name = name; return retVal; }

inline std::ostream &operator<<( std::ostream &stream, _format format )
{ image_fileoutput_fileType = format.name; return stream; }

template< typename T, typename U >
inline image_fileoutput< T > &operator<<( image_fileoutput< T > &output,
                                          const const_image_ref< U > &im )
{
  if ( typeid( T ) == typeid( U ) )
    output.write( (const_image_ref< T > &)im );
  else {
    output.write( image< T >( im ) );
  };
  return output;
}

inline std::ostream &operator<<( std::ostream &stream,
                                 const const_image_ref< unsigned char > &img )
{
  image_fileoutput< unsigned char > output( stream );
  output << img;
  return stream;
}

inline std::ostream &operator<<( std::ostream &stream,
                                 const const_image_ref< int > &img )
{
  image_fileoutput< unsigned char > output( stream );
  output << img;
  return stream;
}

inline std::ostream &operator<<( std::ostream &stream,
                                 const const_image_ref< double > &img )
{
  image_fileoutput< unsigned char > output( stream );
  output << img;
  return stream;
}

inline std::ostream &operator<<( std::ostream &stream,
                                 const const_image_ref< float > &img )
{
  image_fileoutput< unsigned char > output( stream );
  output << img;
  return stream;
}

inline std::ostream &operator<<( std::ostream &stream,
                                 const const_image_ref< rgba< unsigned char > > &img )
{
  image_fileoutput< rgba< unsigned char > > output( stream );
  output << img;
  return stream;
}

inline std::ostream &operator<<( std::ostream &stream,
                                 const const_image_ref< rgba< int > > &img )
{
  image_fileoutput< rgba< unsigned char > > output( stream );
  output << img;
  return stream;
}

inline std::ostream &operator<<( std::ostream &stream,
                                 const const_image_ref< rgba< float > > &img )
{
  image_fileoutput< rgba< unsigned char > > output( stream );
  output << img;
  return stream;
}

inline std::ostream &operator<<( std::ostream &stream,
                                 const const_image_ref< rgba< double > > &img )
{
  image_fileoutput< rgba< unsigned char > > output( stream );
  output << img;
  return stream;
}



};

#include "image_fileoutput.tcc"

#endif

---