image_io.h

Go to the documentation of this file.

/*                       
        This file is part of the CVD Library.

        Copyright (C) 2005 The Authors

        This library is free software; you can redistribute it and/or
        modify it under the terms of the GNU Lesser General Public
        License as published by the Free Software Foundation; either
        version 2.1 of the License, or (at your option) any later version.

        This library is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
        Lesser General Public License for more details.

        You should have received a copy of the GNU Lesser General Public
        License along with this library; if not, write to the Free Software
        Foundation, Inc., 
    51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
#ifndef CVD_IMAGE_IO_H
#define CVD_IMAGE_IO_H

#include <cvd/config.h>

#include <cvd/exceptions.h>
#include <cvd/image_convert.h>
#include <cvd/internal/load_and_save.h>
#include <cvd/internal/name_builtin_types.h>
#include <cvd/internal/name_CVD_rgb_types.h>
#include <errno.h>
#include <memory>
#include <string>
#include <fstream>
#include <cctype>

#include <cvd/internal/io/pnm_grok.h>
#include <cvd/internal/io/save_postscript.h>
#include <cvd/internal/io/bmp.h>
#include <cvd/internal/io/fits.h>
#include <cvd/internal/io/text.h>
#include <cvd/internal/io/cvdimage.h>


#ifdef CVD_HAVE_JPEG
        #include <cvd/internal/io/jpeg.h>
#endif

#ifdef CVD_HAVE_TIFF
        #include <cvd/internal/io/tiff.h>
#endif


#ifdef CVD_HAVE_PNG
        #include <cvd/internal/io/png.h>
#endif

namespace CVD
{
        


        //
        // Image loading
        //

        #ifndef DOXYGEN_IGNORE_INTERNAL
        namespace ImageType
        {
                enum ImageType
                {
                        Automatic= -2,
                        Unknown = -1,
                        PNM=0,
                        PS=1,
                        EPS=2,
                        BMP=3,
                        #ifdef CVD_HAVE_JPEG
                                JPEG=4,
                        #endif
                        #ifdef CVD_HAVE_PNG
                                PNG=5,
                        #endif
                        #ifdef CVD_HAVE_TIFF
                                TIFF=6,
                        #endif
                        TXT=7,
                        TEXT=7,
                        FITS=8,
                        CVD=9,
                };
        }

        namespace Internal
        {
                class ImageLoaderIstream{};
                template<> struct ImagePromise<ImageLoaderIstream>
                {
                        ImagePromise(std::istream& is)
                        :i(is){}

                        std::istream& i;
                        template<class C> void execute(Image<C>& im)
                        {
                                img_load(im, i);
                        }
                };

                class ImageLoaderString{};
                template<> struct ImagePromise<ImageLoaderString>
                {
                        ImagePromise(const std::string& ss)
                        :s(ss){}

                        const std::string& s;
                        template<class C> void execute(Image<C>& im)
                        {
                                img_load(im, s);
                        }
                };
        };
        #endif

        #ifdef DOXYGEN_INCLUDE_ONLY_FOR_DOCS
        // This is not the real definition, but this is what it would look like if all
        // the macros were expanded. The real definition is above
        namespace ImageType
        {
                enum ImageType
                {       
                        Automatic,
                        Unknown,
                        PNM, 
                        JPEG,
                        BMP,
                        PNG,
                        TIFF,
                        PS,
                        EPS,
                        TXT,
                        CVD,
                        FITS,
                };
        }
        #endif

        #ifndef DOXYGEN_IGNORE_INTERNAL

        Internal::ImagePromise<Internal::ImageLoaderIstream> img_load(std::istream& i);
        Internal::ImagePromise<Internal::ImageLoaderString> img_load(const std::string &s);
        #endif

        #if DOXYGEN_INCLUDE_ONLY_FOR_DOCS
        
        template<class C> Image<C> img_load(std::istream& i);
        
        template<class C> Image<C> img_load(std::string& i);



        #endif  


        template<class I> void img_load(Image<I>& im, std::istream& i)
        {
          if(!i.good())
          {
            //Check for one of the commonest errors and put in
            //a special case
            std::ifstream* fs;
            if((fs = dynamic_cast<std::ifstream*>(&i)) && !fs->is_open())
              throw Exceptions::Image_IO::IfstreamNotOpen();
            else
              throw Exceptions::Image_IO::EofBeforeImage();
          }
          unsigned char c = i.peek();
          
          if(!i.good())
            throw Exceptions::Image_IO::EofBeforeImage();

          if(c == 'P')
            PNM::readPNM(im, i);
#ifdef CVD_HAVE_JPEG
          else if(c == 0xff)
            CVD::Internal::readImage<I, JPEG::reader>(im, i);
#endif
#ifdef CVD_HAVE_TIFF
          else if(c == 'I' || c == 'M') //Little or big endian TIFF
            CVD::Internal::readImage<I, TIFF::tiff_reader>(im, i);
#endif
#ifdef CVD_HAVE_PNG
          else if(c == 0x89)
            CVD::Internal::readImage<I, PNG::png_reader>(im, i);
#endif
          else if(c == 'B')
            BMP::readBMP(im, i);
          else if(c == 'S')
            CVD::Internal::readImage<I, FITS::reader>(im, i);
          else if(c == 'C')
                CVD::Internal::readImage<I, CVDimage::reader>(im, i);
          else if(c == ' ' || c == '\t' || isdigit(c) || c == '-' || c == '+')
            CVD::Internal::readImage<I, TEXT::reader>(im, i);
          else
            throw Exceptions::Image_IO::UnsupportedImageType();
        }
                
        //  syg21
        template<class I> void img_load(Image<I> &im, const std::string &s)
        {
          std::ifstream i(s.c_str(), std::ios::in|std::ios::binary);

          if(!i.good())
            throw Exceptions::Image_IO::OpenError(s, "for reading", errno);
          img_load(im, i);
        }       


        //
        // Image saving
        //


        ImageType::ImageType string_to_image_type(const std::string& name);


        template<class PixelType> 
        void img_save(const BasicImage<PixelType>& im, std::ostream& o, ImageType::ImageType t, const std::map<std::string, Parameter<> >& p = std::map<std::string, Parameter<> >())
        {
          switch (t) {
          default:
          case ImageType::PNM:  
          case ImageType::Automatic:
          case ImageType::Unknown:
                Internal::writeImage<PixelType, PNM::pnm_writer>(im, o, p); break;
          #ifdef CVD_HAVE_JPEG
                  case ImageType::JPEG: Internal::writeImage<PixelType, JPEG::writer>(im,o, p); break;
          #endif
          #ifdef CVD_HAVE_PNG
                  case ImageType::PNG: Internal::writeImage<PixelType, PNG::png_writer>(im,o, p); break;
          #endif
          #ifdef CVD_HAVE_TIFF
                  case ImageType::TIFF: Internal::writeImage<PixelType, TIFF::tiff_writer>(im,o, p); break;
          #endif
          case ImageType::FITS: Internal::writeImage<PixelType, FITS::writer>(im,o, p); break;
          case ImageType::BMP: BMP::writeBMP(im, o); break;
          case ImageType::TXT: Internal::writeImage<PixelType, TEXT::writer>(im, o, p); break;
          case ImageType::PS:   Internal::writeImage<PixelType, PS::writer>(im, o, p); break;
          case ImageType::EPS:   Internal::writeImage<PixelType, PS::eps_writer>(im, o, p); break;
          case ImageType::CVD: Internal::writeImage<PixelType, CVDimage::writer>(im,o, p); break;
          }
        }

        template<class PixelType> void img_save(const BasicImage<PixelType>& im, const std::string& name, ImageType::ImageType t, ImageType::ImageType d = ImageType::PNM, const std::map<std::string, Parameter<> >& p = std::map<std::string, Parameter<> >())
        {
          std::ofstream out(name.c_str(), std::ios::out|std::ios::binary);
          if(!out.good())
            throw Exceptions::Image_IO::OpenError(name, "for writing", errno);

          if(t == ImageType::Automatic)
          {
                t = string_to_image_type(name);
                if(t == ImageType::Unknown)
                        t = d;
          }

          img_save(im, out, t, p);
        }

        template<class PixelType> void img_save(const BasicImage<PixelType>& im, const std::string& name, const std::map<std::string, Parameter<> >& p = std::map<std::string, Parameter<> >())
        {
            img_save(im, name, ImageType::Automatic, ImageType::PNM, p);
        }

        //
        // Legacy pnm_* functions
        //

        template<class PixelType> void pnm_save(const BasicImage<PixelType>& im, std::ostream& o)
        {
                img_save(im, o, ImageType::PNM);
        }

        template<class PixelType> void pnm_load(Image<PixelType>& im, std::istream& i)
        {
                img_load(im, i);
        }

        //
        // Postscript helper functions
        //

        void output_eps_footer(std::ostream& o);

        void output_eps_header(std::ostream& o, int xs, int ys);


        void output_eps_header(std::ostream & o, const ImageRef& s);

        template<class PixelType> void output_eps_header(std::ostream& o, const BasicImage<PixelType>& im)
        {
                output_eps_header(o, im.size());
        }



}

#endif

---

libcvd
Author(s): Edward Rosten, Paul Smith, Tom Drummond, Gerhard Reitmayr, Ethan Eade, Timothy Gan, Chris Kemp, Georg Klein
autogenerated on Fri Jan 11 09:13:10 2013