dlib C++ Library - colormaps.h

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

    #include "colormaps_abstract.h"
    #include "../hash.h"
    #include "../pixel.h"
    #include "../matrix.h"

    namespace dlib
    {

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

        template <typename T>
        struct op_randomly_color_image : does_not_alias
        {
            op_randomly_color_image( const T& img_) : img(img_){}

            const T& img;

            const static long cost = 7;
            const static long NR = 0;
            const static long NC = 0;
            typedef rgb_pixel type;
            typedef const rgb_pixel const_ret_type;
            typedef default_memory_manager mem_manager_type;
            typedef row_major_layout layout_type;

            const_ret_type apply (long r, long c ) const
            {
                const unsigned long gray = get_pixel_intensity(mat(img)(r,c));
                if (gray != 0)
                {
                    const uint32 h = murmur_hash3_2(gray,0);
                    rgb_pixel pix;
                    pix.red   = static_cast<unsigned char>(h)%200 + 55;
                    pix.green = static_cast<unsigned char>(h>>8)%200 + 55;
                    pix.blue  = static_cast<unsigned char>(h>>16)%200 + 55;
                    return pix;
                }
                else
                {
                    // keep black pixels black
                    return rgb_pixel(0,0,0);
                }
            }

            long nr () const { return num_rows(img); }
            long nc () const { return num_columns(img); }
        };

        template <
            typename image_type
            >
        const matrix_op<op_randomly_color_image<image_type> >
        randomly_color_image (
            const image_type& img
        )
        {
            typedef op_randomly_color_image<image_type> op;
            return matrix_op<op>(op(img));
        }

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

        inline rgb_pixel colormap_heat (
            double value,
            double min_val,
            double max_val
        )
        {
            // scale the gray value into the range [0, 1]
            const double gray = put_in_range(0, 1, (value - min_val)/(max_val-min_val));
            rgb_pixel pix(0,0,0);

            pix.red = static_cast<unsigned char>(std::min(gray/0.4,1.0)*255 + 0.5);

            if (gray > 0.4)
            {
                pix.green = static_cast<unsigned char>(std::min((gray-0.4)/0.4,1.0)*255 + 0.5);
            }
            if (gray > 0.8)
            {
                pix.blue = static_cast<unsigned char>(std::min((gray-0.8)/0.2,1.0)*255 + 0.5);
            }

            return pix;
        }

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

        template <typename T>
        struct op_heatmap : does_not_alias
        {
            op_heatmap(
                const T& img_,
                const double max_val_,
                const double min_val_
                ) : img(img_), max_val(max_val_), min_val(min_val_){}

            const T& img;

            const double max_val;
            const double min_val;

            const static long cost = 7;
            const static long NR = 0;
            const static long NC = 0;
            typedef rgb_pixel type;
            typedef const rgb_pixel const_ret_type;
            typedef default_memory_manager mem_manager_type;
            typedef row_major_layout layout_type;

            const_ret_type apply (long r, long c ) const
            {
                return colormap_heat(get_pixel_intensity(mat(img)(r,c)), min_val, max_val);
            }

            long nr () const { return num_rows(img); }
            long nc () const { return num_columns(img); }
        };

        template <
            typename image_type
            >
        const matrix_op<op_heatmap<image_type> >
        heatmap (
            const image_type& img,
            double max_val,
            double min_val = 0
        )
        {
            typedef op_heatmap<image_type> op;
            return matrix_op<op>(op(img,max_val,min_val));
        }

        template <
            typename image_type
            >
        const matrix_op<op_heatmap<image_type> >
        heatmap (
            const image_type& img
        )
        {
            typedef op_heatmap<image_type> op;
            if (num_columns(img) * num_rows(img) != 0)
                return matrix_op<op>(op(img,max(mat(img)),min(mat(img))));
            else
                return matrix_op<op>(op(img,0,0));
        }

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

        inline rgb_pixel colormap_jet (
            double value,
            double min_val,
            double max_val
        )
        {
            // scale the gray value into the range [0, 8]
            const double gray = 8*put_in_range(0, 1, (value - min_val)/(max_val-min_val));
            rgb_pixel pix;
            // s is the slope of color change
            const double s = 1.0/2.0;

            if (gray <= 1)
            {
                pix.red = 0;
                pix.green = 0;
                pix.blue = static_cast<unsigned char>((gray+1)*s*255 + 0.5);
            }
            else if (gray <= 3)
            {
                pix.red = 0;
                pix.green = static_cast<unsigned char>((gray-1)*s*255 + 0.5);
                pix.blue = 255;
            }
            else if (gray <= 5)
            {
                pix.red = static_cast<unsigned char>((gray-3)*s*255 + 0.5);
                pix.green = 255;
                pix.blue = static_cast<unsigned char>((5-gray)*s*255 + 0.5);
            }
            else if (gray <= 7)
            {
                pix.red = 255;
                pix.green = static_cast<unsigned char>((7-gray)*s*255 + 0.5);
                pix.blue = 0;
            }
            else
            {
                pix.red = static_cast<unsigned char>((9-gray)*s*255 + 0.5);
                pix.green = 0;
                pix.blue = 0;
            }

            return pix;
        }

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

        template <typename T>
        struct op_jet : does_not_alias
        {
            op_jet(
                const T& img_,
                const double max_val_,
                const double min_val_
                ) : img(img_), max_val(max_val_), min_val(min_val_){}

            const T& img;

            const double max_val;
            const double min_val;

            const static long cost = 7;
            const static long NR = 0;
            const static long NC = 0;
            typedef rgb_pixel type;
            typedef const rgb_pixel const_ret_type;
            typedef default_memory_manager mem_manager_type;
            typedef row_major_layout layout_type;

            const_ret_type apply (long r, long c ) const
            {
                return colormap_jet(get_pixel_intensity(mat(img)(r,c)), min_val, max_val);
            }

            long nr () const { return num_rows(img); }
            long nc () const { return num_columns(img); }
        };

        template <
            typename image_type
            >
        const matrix_op<op_jet<image_type> >
        jet (
            const image_type& img,
            double max_val,
            double min_val = 0
        )
        {
            typedef op_jet<image_type> op;
            return matrix_op<op>(op(img,max_val,min_val));
        }

        template <
            typename image_type
            >
        const matrix_op<op_jet<image_type> >
        jet (
            const image_type& img
        )
        {
            typedef op_jet<image_type> op;
            if (num_columns(img) * num_rows(img) != 0)
                return matrix_op<op>(op(img,max(mat(img)),min(mat(img))));
            else
                return matrix_op<op>(op(img,0,0));
        }

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

    }

    #endif // DLIB_RANDOMLY_COlOR_IMAGE_Hh_