image_io.h

#ifndef CVD_IMAGE_IO_H
#define CVD_IMAGE_IO_H

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

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

namespace CVD
{

// 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 = -2,
        Unknown = -1,
        PNM = 0,
        JPEG = 1,
        BMP = 2,
        PNG = 3,
        TIFF = 4,
        PS = 5,
        EPS = 6,
        TXT = 7,
        TEXT = 7,
        CVD = 8,
        FITS = 9,
    };
}

#if DOXYGEN_INCLUDE_ONLY_FOR_DOCS

template <class C>
Image<C> img_load(std::istream& i);

template <class C>
Image<C> img_load(const std::string& i);

#endif

namespace Internal
{

    using AllImageTypes = std::tuple<PNM::Reader, JPEG::Reader, TIFF::Reader, PNG::Reader, BMP::Reader, FITS::Reader, CVDimage::Reader, TEXT::Reader>;

    // This selects the correct image reader from the list of available readers
    // (provided as a tuple), using the first byte of the file to decide.
    template <class I, class ImageTypeList, int N = 0>
    void img_load_tuple(Image<I>& im, std::istream& i, [[maybe_unused]] int c)
    {
        if constexpr(N == std::tuple_size_v<ImageTypeList>)
        {
            throw Exceptions::Image_IO::UnsupportedImageType();
        }
        else
        {
            using ImageReader = std::tuple_element_t<N, ImageTypeList>;

            if(ImageReader::first_byte_matches(c))
                CVD::Internal::readImage<I, ImageReader>(im, i);
            else
                img_load_tuple<I, ImageTypeList, N + 1>(im, i, c);
        }
    }

    template <class... T>
    struct as_tuple
    {
        using type = std::tuple<T...>;
    };

    template <class... T>
    struct as_tuple<std::tuple<T...>>
    {
        using type = std::tuple<T...>;
    };
}

//If there's only one argument it can be a tuple or a single element typelist
template <class I, class Head = Internal::AllImageTypes, class... ImageTypes>
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();
    }
    int c = i.peek();

    if(!i.good())
        throw Exceptions::Image_IO::EofBeforeImage();

    Internal::img_load_tuple<I, typename Internal::as_tuple<Head, ImageTypes...>::type>(im, i, c);
}

template <class I, class Head = Internal::AllImageTypes, class... ImageTypes>
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<I, Head, ImageTypes...>(im, i);
}

#ifndef DOXYGEN_IGNORE_INTERNAL
namespace Internal
{
    template <class... ImageTypes>
    class ImageLoaderIstream
    {
    };

    template <class... ImageTypes>
    struct ImagePromise<ImageLoaderIstream<ImageTypes...>>
    {
        ImagePromise(std::istream& is)
            : i(is)
        {
        }

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

    template <class... ImageTypes>
    class ImageLoaderString
    {
    };

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

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

};

template <class... ImageTypes>
Internal::ImagePromise<Internal::ImageLoaderIstream<ImageTypes...>> img_load(std::istream& i)
{
    return i;
}

template <class... ImageTypes>
Internal::ImagePromise<Internal::ImageLoaderString<ImageTypes...>> img_load(const std::string& i)
{
    return i;
}

inline Internal::ImagePromise<Internal::ImageLoaderIstream<Internal::AllImageTypes>> img_load(std::istream& i)
{
    return i;
}

inline Internal::ImagePromise<Internal::ImageLoaderString<Internal::AllImageTypes>> img_load(const std::string& i)
{
    return i;
}

#endif

//
// 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;
        case ImageType::JPEG:
            Internal::writeImage<PixelType, JPEG::writer>(im, o, p);
            break;
        case ImageType::PNG:
            Internal::writeImage<PixelType, PNG::png_writer>(im, o, p);
            break;
        case ImageType::TIFF:
            Internal::writeImage<PixelType, TIFF::tiff_writer>(im, o, p);
            break;
        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