cvd/image_io.h

/*                       
    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')
        CVD::Internal::readImage<I, PNM::Reader>(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')
        CVD::Internal::readImage<I, BMP::Reader>(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::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:  Internal::writeImage<PixelType, BMP::Writer>(im, o, p); 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