dlib C++ Library - image_saver.h

    // Copyright (C) 2006  Davis E. King (davis@dlib.net)
    // License: Boost Software License   See LICENSE.txt for the full license.
    #ifndef DLIB_IMAGE_SAVEr_
    #define DLIB_IMAGE_SAVEr_

    #include "image_saver_abstract.h"
    #include <iostream>
    #include <fstream>
    #include <sstream>
    #include "../algs.h"
    #include "../pixel.h"
    #include "../byte_orderer.h"
    #include "../entropy_encoder.h"
    #include "../entropy_encoder_model.h"
    #include "dng_shared.h"
    #include "../uintn.h"
    #include "../dir_nav.h"
    #include "../float_details.h"
    #include "../vectorstream.h"
    #include "../matrix/matrix_exp.h"
    #include "../image_transforms/assign_image.h"

    namespace dlib
    {

    // ----------------------------------------------------------------------------------------

        class image_save_error : public dlib::error {
        public: image_save_error(const std::string& str) : error(EIMAGE_SAVE,str){}
        };

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type,
            bool grayscale = pixel_traits<typename image_traits<image_type>::pixel_type>::grayscale
            >
        struct save_bmp_helper;

        template <typename image_type>
        struct save_bmp_helper<image_type,false>
        {
            static void save_bmp (
                const image_type& image_,
                std::ostream& out
            )
            {
                const_image_view<image_type> image(image_);
                // we are going to write out a 24bit color image.
                byte_orderer::kernel_1a bo;

                out.write("BM",2);

                if (!out)
                    throw image_save_error("error writing image to output stream");

                unsigned long pad = 4 - (image.nc()*3)%4;
                if (pad == 4)
                    pad = 0;

                unsigned long bfSize = 14 + 40 + (image.nc()*3 + pad)*image.nr();
                unsigned long bfReserved = 0;
                unsigned long bfOffBits = 14 + 40;
                unsigned long biSize = 40;
                unsigned long biWidth = image.nc();
                unsigned long biHeight = image.nr();
                unsigned short biPlanes = 1;
                unsigned short biBitCount = 24;
                unsigned long biCompression = 0;
                unsigned long biSizeImage = 0;
                unsigned long biXPelsPerMeter = 0;
                unsigned long biYPelsPerMeter = 0;
                unsigned long biClrUsed = 0;
                unsigned long biClrImportant = 0;

                bo.host_to_little(bfSize);
                bo.host_to_little(bfOffBits);
                bo.host_to_little(biSize);
                bo.host_to_little(biWidth);
                bo.host_to_little(biHeight);
                bo.host_to_little(biPlanes);
                bo.host_to_little(biBitCount);

                out.write((char*)&bfSize,4);
                out.write((char*)&bfReserved,4);
                out.write((char*)&bfOffBits,4);
                out.write((char*)&biSize,4);
                out.write((char*)&biWidth,4);
                out.write((char*)&biHeight,4);
                out.write((char*)&biPlanes,2);
                out.write((char*)&biBitCount,2);
                out.write((char*)&biCompression,4);
                out.write((char*)&biSizeImage,4);
                out.write((char*)&biXPelsPerMeter,4);
                out.write((char*)&biYPelsPerMeter,4);
                out.write((char*)&biClrUsed,4);
                out.write((char*)&biClrImportant,4);

                if (!out)
                    throw image_save_error("error writing image to output stream");

                // now we write out the pixel data
                for (long row = image.nr()-1; row >= 0; --row)
                {
                    for (long col = 0; col < image.nc(); ++col)
                    {
                        rgb_pixel p;
                        p.red = 0;
                        p.green = 0;
                        p.blue = 0;
                        assign_pixel(p,image[row][col]);
                        out.write((char*)&p.blue,1);
                        out.write((char*)&p.green,1);
                        out.write((char*)&p.red,1);
                    }

                    // write out some zeros so that this line is a multiple of 4 bytes
                    for (unsigned long i = 0; i < pad; ++i)
                    {
                        unsigned char p = 0;
                        out.write((char*)&p,1);
                    }
                }

                if (!out)
                    throw image_save_error("error writing image to output stream");
            }
        };

        template <typename image_type>
        struct save_bmp_helper<image_type,true>
        {
            static void save_bmp (
                const image_type& image_,
                std::ostream& out
            )
            {
                const_image_view<image_type> image(image_);
                // we are going to write out an 8bit color image.
                byte_orderer::kernel_1a bo;

                out.write("BM",2);

                if (!out)
                    throw image_save_error("error writing image to output stream");

                unsigned long pad = 4 - image.nc()%4;
                if (pad == 4)
                    pad = 0;

                unsigned long bfSize = 14 + 40 + (image.nc() + pad)*image.nr() + 256*4;
                unsigned long bfReserved = 0;
                unsigned long bfOffBits = 14 + 40 + 256*4;
                unsigned long biSize = 40;
                unsigned long biWidth = image.nc();
                unsigned long biHeight = image.nr();
                unsigned short biPlanes = 1;
                unsigned short biBitCount = 8;
                unsigned long biCompression = 0;
                unsigned long biSizeImage = 0;
                unsigned long biXPelsPerMeter = 0;
                unsigned long biYPelsPerMeter = 0;
                unsigned long biClrUsed = 0;
                unsigned long biClrImportant = 0;

                bo.host_to_little(bfSize);
                bo.host_to_little(bfOffBits);
                bo.host_to_little(biSize);
                bo.host_to_little(biWidth);
                bo.host_to_little(biHeight);
                bo.host_to_little(biPlanes);
                bo.host_to_little(biBitCount);

                out.write((char*)&bfSize,4);
                out.write((char*)&bfReserved,4);
                out.write((char*)&bfOffBits,4);
                out.write((char*)&biSize,4);
                out.write((char*)&biWidth,4);
                out.write((char*)&biHeight,4);
                out.write((char*)&biPlanes,2);
                out.write((char*)&biBitCount,2);
                out.write((char*)&biCompression,4);
                out.write((char*)&biSizeImage,4);
                out.write((char*)&biXPelsPerMeter,4);
                out.write((char*)&biYPelsPerMeter,4);
                out.write((char*)&biClrUsed,4);
                out.write((char*)&biClrImportant,4);

                // write out the color palette
                for (unsigned int i = 0; i <= 255; ++i)
                {
                    unsigned char ch = static_cast<unsigned char>(i);
                    out.write((char*)&ch,1);
                    out.write((char*)&ch,1);
                    out.write((char*)&ch,1);
                    ch = 0;
                    out.write((char*)&ch,1);
                }

                if (!out)
                    throw image_save_error("error writing image to output stream");

                // now we write out the pixel data
                for (long row = image.nr()-1; row >= 0; --row)
                {
                    for (long col = 0; col < image.nc(); ++col)
                    {
                        unsigned char p = 0;
                        assign_pixel(p,image[row][col]);
                        out.write((char*)&p,1);
                    }

                    // write out some zeros so that this line is a multiple of 4 bytes
                    for (unsigned long i = 0; i < pad; ++i)
                    {
                        unsigned char p = 0;
                        out.write((char*)&p,1);
                    }
                }

                if (!out)
                    throw image_save_error("error writing image to output stream");

            }
        };

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type
            >
        inline typename disable_if<is_matrix<image_type> >::type save_bmp (
            const image_type& image,
            std::ostream& out
        )
        {
            save_bmp_helper<image_type>::save_bmp(image,out);
        }

        template <
            typename EXP
            >
        inline void save_bmp (
            const matrix_exp<EXP>& image,
            std::ostream& out
        )
        {
            array2d<typename EXP::type> temp;
            assign_image(temp, image);
            save_bmp_helper<array2d<typename EXP::type> >::save_bmp(temp,out);
        }

    // ----------------------------------------------------------------------------------------

        namespace dng_helpers_namespace
        {
            template <
                typename image_type,
                typename enabled = void
                >
            struct save_dng_helper;

            typedef entropy_encoder::kernel_2a encoder_type;
            typedef entropy_encoder_model<256,encoder_type>::kernel_5a eem_type;

            typedef entropy_encoder_model<256,encoder_type>::kernel_4a eem_exp_type;

            template <typename image_type >
            struct save_dng_helper<image_type, typename enable_if<is_float_type<typename image_traits<image_type>::pixel_type> >::type >
            {
                static void save_dng (
                    const image_type& image_,
                    std::ostream& out
                )
                {
                    const_image_view<image_type> image(image_);
                    out.write("DNG",3);
                    unsigned long version = 1;
                    serialize(version,out);
                    unsigned long type = grayscale_float;
                    serialize(type,out);
                    serialize(image.nc(),out);
                    serialize(image.nr(),out);

                    // Write the compressed exponent data into expbuf.  We will append it
                    // to the stream at the end of the loops.
                    std::vector<char> expbuf;
                    expbuf.reserve(image.size()*2);
                    vectorstream outexp(expbuf);
                    encoder_type encoder;
                    encoder.set_stream(outexp);

                    eem_exp_type eem_exp(encoder);
                    float_details prev;
                    for (long r = 0; r < image.nr(); ++r)
                    {
                        for (long c = 0; c < image.nc(); ++c)
                        {
                            float_details cur = image[r][c];
                            int16 exp = cur.exponent-prev.exponent;
                            int64 man = cur.mantissa-prev.mantissa;
                            prev = cur;

                            unsigned char ebyte1 = exp&0xFF;
                            unsigned char ebyte2 = exp>>8;
                            eem_exp.encode(ebyte1);
                            eem_exp.encode(ebyte2);

                            serialize(man, out);
                        }
                    }
                    // write out the magic byte to mark the end of the compressed data.
                    eem_exp.encode(dng_magic_byte);
                    eem_exp.encode(dng_magic_byte);
                    eem_exp.encode(dng_magic_byte);
                    eem_exp.encode(dng_magic_byte);

                    encoder.clear();
                    serialize(expbuf, out);
                }
            };

            template <typename image_type>
            struct is_non_float_non8bit_grayscale
            {
                typedef typename image_traits<image_type>::pixel_type pixel_type;
                const static bool value = pixel_traits<pixel_type>::grayscale &&
                                          sizeof(pixel_type) != 1 &&
                                          !is_float_type<pixel_type>::value;
            };

            template <typename image_type >
            struct save_dng_helper<image_type, typename enable_if<is_non_float_non8bit_grayscale<image_type> >::type>
            {
                static void save_dng (
                    const image_type& image_,
                    std::ostream& out
                )
                {
                    const_image_view<image_type> image(image_);
                    out.write("DNG",3);
                    unsigned long version = 1;
                    serialize(version,out);
                    unsigned long type = grayscale_16bit;
                    serialize(type,out);
                    serialize(image.nc(),out);
                    serialize(image.nr(),out);

                    encoder_type encoder;
                    encoder.set_stream(out);

                    eem_type eem(encoder);
                    for (long r = 0; r < image.nr(); ++r)
                    {
                        for (long c = 0; c < image.nc(); ++c)
                        {
                            uint16 cur;
                            assign_pixel(cur, image[r][c]);
                            cur -= predictor_grayscale_16(image,r,c);
                            unsigned char byte1 = cur&0xFF;
                            unsigned char byte2 = cur>>8;
                            eem.encode(byte2);
                            eem.encode(byte1);
                        }
                    }
                    // write out the magic byte to mark the end of the data
                    eem.encode(dng_magic_byte);
                    eem.encode(dng_magic_byte);
                    eem.encode(dng_magic_byte);
                    eem.encode(dng_magic_byte);
                }
            };

            template <typename image_type>
            struct is_8bit_grayscale
            {
                typedef typename image_traits<image_type>::pixel_type pixel_type;
                const static bool value = pixel_traits<pixel_type>::grayscale && sizeof(pixel_type) == 1;
            };

            template <typename image_type>
            struct save_dng_helper<image_type, typename enable_if<is_8bit_grayscale<image_type> >::type>
            {
                static void save_dng (
                    const image_type& image_,
                    std::ostream& out
                )
                {
                    const_image_view<image_type> image(image_);
                    out.write("DNG",3);
                    unsigned long version = 1;
                    serialize(version,out);
                    unsigned long type = grayscale;
                    serialize(type,out);
                    serialize(image.nc(),out);
                    serialize(image.nr(),out);

                    encoder_type encoder;
                    encoder.set_stream(out);

                    eem_type eem(encoder);
                    for (long r = 0; r < image.nr(); ++r)
                    {
                        for (long c = 0; c < image.nc(); ++c)
                        {
                            unsigned char cur;
                            assign_pixel(cur, image[r][c]);
                            cur -= predictor_grayscale(image,r,c);
                            eem.encode(cur);
                        }
                    }
                    // write out the magic byte to mark the end of the data
                    eem.encode(dng_magic_byte);
                    eem.encode(dng_magic_byte);
                    eem.encode(dng_magic_byte);
                    eem.encode(dng_magic_byte);
                }
            };

            template <typename image_type>
            struct save_dng_helper<image_type,typename enable_if<is_rgb_image<image_type> >::type>
            {
                static void save_dng (
                    const image_type& image_,
                    std::ostream& out
                )
                {
                    const_image_view<image_type> image(image_);
                    out.write("DNG",3);
                    unsigned long version = 1;
                    serialize(version,out);

                    unsigned long type = rgb;
                    // if this is a small image then we will use a different predictor
                    if (image.size() < 4000)
                        type = rgb_paeth;

                    serialize(type,out);
                    serialize(image.nc(),out);
                    serialize(image.nr(),out);

                    encoder_type encoder;
                    encoder.set_stream(out);

                    rgb_pixel pre, cur;
                    eem_type eem(encoder);

                    if (type == rgb)
                    {
                        for (long r = 0; r < image.nr(); ++r)
                        {
                            for (long c = 0; c < image.nc(); ++c)
                            {
                                pre = predictor_rgb(image,r,c);
                                assign_pixel(cur, image[r][c]);

                                eem.encode((unsigned char)(cur.red - pre.red));
                                eem.encode((unsigned char)(cur.green - pre.green));
                                eem.encode((unsigned char)(cur.blue - pre.blue));
                            }
                        }
                    }
                    else
                    {
                        for (long r = 0; r < image.nr(); ++r)
                        {
                            for (long c = 0; c < image.nc(); ++c)
                            {
                                pre = predictor_rgb_paeth(image,r,c);
                                assign_pixel(cur, image[r][c]);

                                eem.encode((unsigned char)(cur.red - pre.red));
                                eem.encode((unsigned char)(cur.green - pre.green));
                                eem.encode((unsigned char)(cur.blue - pre.blue));
                            }
                        }
                    }
                    // write out the magic byte to mark the end of the data
                    eem.encode(dng_magic_byte);
                    eem.encode(dng_magic_byte);
                    eem.encode(dng_magic_byte);
                    eem.encode(dng_magic_byte);
                }
            };

            template <typename image_type>
            struct is_rgb_alpha_image
            {
                typedef typename image_traits<image_type>::pixel_type pixel_type;
                const static bool value = pixel_traits<pixel_type>::rgb_alpha;
            };

            template <typename image_type>
            struct save_dng_helper<image_type,typename enable_if<is_rgb_alpha_image<image_type> >::type>
            {
                static void save_dng (
                    const image_type& image_,
                    std::ostream& out
                )
                {
                    const_image_view<image_type> image(image_);
                    out.write("DNG",3);
                    unsigned long version = 1;
                    serialize(version,out);

                    unsigned long type = rgb_alpha;
                    // if this is a small image then we will use a different predictor
                    if (image.size() < 4000)
                        type = rgb_alpha_paeth;

                    serialize(type,out);
                    serialize(image.nc(),out);
                    serialize(image.nr(),out);

                    encoder_type encoder;
                    encoder.set_stream(out);

                    rgb_alpha_pixel pre, cur;
                    eem_type eem(encoder);

                    if (type == rgb_alpha)
                    {
                        for (long r = 0; r < image.nr(); ++r)
                        {
                            for (long c = 0; c < image.nc(); ++c)
                            {
                                pre = predictor_rgb_alpha(image,r,c);
                                assign_pixel(cur, image[r][c]);

                                eem.encode((unsigned char)(cur.red - pre.red));
                                eem.encode((unsigned char)(cur.green - pre.green));
                                eem.encode((unsigned char)(cur.blue - pre.blue));
                                eem.encode((unsigned char)(cur.alpha - pre.alpha));
                            }
                        }
                    }
                    else
                    {
                        for (long r = 0; r < image.nr(); ++r)
                        {
                            for (long c = 0; c < image.nc(); ++c)
                            {
                                pre = predictor_rgb_alpha_paeth(image,r,c);
                                assign_pixel(cur, image[r][c]);

                                eem.encode((unsigned char)(cur.red - pre.red));
                                eem.encode((unsigned char)(cur.green - pre.green));
                                eem.encode((unsigned char)(cur.blue - pre.blue));
                                eem.encode((unsigned char)(cur.alpha - pre.alpha));
                            }
                        }
                    }
                    // write out the magic byte to mark the end of the data
                    eem.encode(dng_magic_byte);
                    eem.encode(dng_magic_byte);
                    eem.encode(dng_magic_byte);
                    eem.encode(dng_magic_byte);
                }
            };

            template <typename image_type>
            struct is_hsi_image
            {
                typedef typename image_traits<image_type>::pixel_type pixel_type;
                const static bool value = pixel_traits<pixel_type>::hsi;
            };

            template <typename image_type>
            struct save_dng_helper<image_type,typename enable_if<is_hsi_image<image_type> >::type>
            {
                static void save_dng (
                    const image_type& image_,
                    std::ostream& out
                )
                {
                    const_image_view<image_type> image(image_);
                    out.write("DNG",3);
                    unsigned long version = 1;
                    serialize(version,out);
                    unsigned long type = hsi;
                    serialize(type,out);
                    serialize(image.nc(),out);
                    serialize(image.nr(),out);

                    encoder_type encoder;
                    encoder.set_stream(out);

                    hsi_pixel pre, cur;
                    eem_type eem(encoder);
                    for (long r = 0; r < image.nr(); ++r)
                    {
                        for (long c = 0; c < image.nc(); ++c)
                        {
                            pre = predictor_hsi(image,r,c);
                            assign_pixel(cur, image[r][c]);

                            eem.encode((unsigned char)(cur.h - pre.h));
                            eem.encode((unsigned char)(cur.s - pre.s));
                            eem.encode((unsigned char)(cur.i - pre.i));
                        }
                    }
                    // write out the magic byte to mark the end of the data
                    eem.encode(dng_magic_byte);
                    eem.encode(dng_magic_byte);
                    eem.encode(dng_magic_byte);
                    eem.encode(dng_magic_byte);
                }
            };
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename image_type
            >
        inline typename disable_if<is_matrix<image_type> >::type save_dng (
            const image_type& image,
            std::ostream& out
        )
        {
            using namespace dng_helpers_namespace;
            save_dng_helper<image_type>::save_dng(image,out);
        }

        template <
            typename EXP
            >
        inline void save_dng (
            const matrix_exp<EXP>& image,
            std::ostream& out
        )
        {
            array2d<typename EXP::type> temp;
            assign_image(temp, image);
            using namespace dng_helpers_namespace;
            save_dng_helper<array2d<typename EXP::type> >::save_dng(temp,out);
        }

    // ----------------------------------------------------------------------------------------

        template <typename image_type>
        void save_dng (
            const image_type& image,
            const std::string& file_name
        )
        {
            std::ofstream fout(file_name.c_str(), std::ios::binary);
            if (!fout)
                throw image_save_error("Unable to open " + file_name + " for writing.");
            save_dng(image, fout);
        }

    // ----------------------------------------------------------------------------------------

        template <typename image_type>
        void save_bmp (
            const image_type& image,
            const std::string& file_name
        )
        {
            std::ofstream fout(file_name.c_str(), std::ios::binary);
            if (!fout)
                throw image_save_error("Unable to open " + file_name + " for writing.");
            save_bmp(image, fout);
        }

    // ----------------------------------------------------------------------------------------

    }

    #endif // DLIB_IMAGE_SAVEr_