CRNImage.h

Go to the documentation of this file.

/* Copyright 2006-2016 Yann LEYDIER, INSA-Lyon, CoReNum, ENS-Lyon
 * 
 * This file is part of libcrn.
 * 
 * libcrn 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 3 of the License, or
 * (at your option) any later version.
 * 
 * libcrn 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 libcrn.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * file: CRNImage.h
 * \author Yann LEYDIER
 */

#ifndef CRNIMAGE_HEADER
#define CRNIMAGE_HEADER

#include <CRNMath/CRNMath.h>
#include <CRNException.h>
#include <CRNString.h>
#include <CRNImage/CRNSummedAreaTable.h>
#include <vector>
#include <type_traits>

namespace crn
{
#define FOREACHPIXEL(x, y, img) for (size_t y = 0; y < (img).GetHeight(); y++) for (size_t x = 0; x < (img).GetWidth(); x++)

    class Rect;
    class MatrixInt;
    class MatrixDouble;
    class Path;
    class Point2DInt;

    class ImageBase
    {
        public:
            virtual ~ImageBase();

            /**************************************************************************************
             * Construction and copy
             *************************************************************************************/
            ImageBase(size_t w, size_t h): width(w), height(h) {}
            ImageBase(const ImageBase&) = default;
            ImageBase(ImageBase&&) = default;
            ImageBase& operator=(const ImageBase&) = default;
            ImageBase& operator=(ImageBase&&) = default;

            virtual std::unique_ptr<ImageBase> Clone() const = 0;

            virtual void SavePNG(const Path &fname) const = 0;
            virtual void SaveJPEG(const Path &fname, unsigned int qual) const = 0;

            /**************************************************************************************
             * Accessors
             *************************************************************************************/

            size_t GetWidth() const noexcept { return width; }
            size_t GetHeight() const noexcept { return height; }
            Rect GetBBox() const noexcept;
            size_t Size() const noexcept { return width * height; }

            /**************************************************************************************
             * Edition
             *************************************************************************************/

            virtual void ScaleToSize(size_t w, size_t h) = 0;

            /**************************************************************************************
             * Transformation
             *************************************************************************************/

        protected:
            size_t width, height;

#ifdef CRN_USING_GDIPLUS
            struct gditoken;
            static std::unique_ptr<gditoken> gdiinit;
            CRN_DECLARE_CLASS_CONSTRUCTOR(ImageBase)
#endif
    };

    using SImage = std::shared_ptr<ImageBase>;
    using SCImage = std::shared_ptr<const ImageBase>;
    using WImage = std::weak_ptr<ImageBase>;
    using WCImage = std::weak_ptr<const ImageBase>;
    using UImage = std::unique_ptr<ImageBase>;
    using UCImage = std::unique_ptr<const ImageBase>;

    class Path;
    UImage NewImageFromFile(const Path &fname);
    
    template<typename T> struct BoolNotBool
    {
        using type = bool;
    };
    struct BoolNotBoolDummy
    {
        inline BoolNotBoolDummy(int i = 0) {}
        inline BoolNotBoolDummy& operator+=(const BoolNotBoolDummy&) { return *this; }
    };
    inline BoolNotBoolDummy operator+(const BoolNotBoolDummy&, const BoolNotBoolDummy&) { return BoolNotBoolDummy{}; }
    inline BoolNotBoolDummy operator-(const BoolNotBoolDummy&, const BoolNotBoolDummy&) { return BoolNotBoolDummy{}; }
    inline BoolNotBoolDummy operator*(const BoolNotBoolDummy&, const BoolNotBoolDummy&) { return BoolNotBoolDummy{}; }
    inline BoolNotBoolDummy operator/(const BoolNotBoolDummy&, const BoolNotBoolDummy&) { return BoolNotBoolDummy{}; }
    template<> struct BoolNotBool<bool>
    {
        using type = BoolNotBoolDummy;
    };
    /****************************************************************************/
    template<class T> class Image: public ImageBase
    {
        public:
            using pixel_type = T;
            
            /**************************************************************************************
             * Construction and copy
             *************************************************************************************/

            Image(size_t w, size_t h, pixel_type val = pixel_type(0));
            Image():Image{1, 1} { }
            Image(size_t w, size_t h, const pixel_type *data);
            
            Image(const Image &img) = default;
            template<typename Y> explicit Image(const Image<Y> &img);
            explicit Image(const Image<typename BoolNotBool<T>::type> &img);
            template<typename Y> Image(const Image<Y> &img, const Rect &bbox);
            Image(const Image<typename BoolNotBool<T>::type> &img, const Rect &bbox);
            Image(Image &&img) = default;

            virtual ~Image() override = default;

            Image& operator=(const Image &img) = default;
            template<typename Y> Image& operator=(const Image<Y> &img);
            Image& operator=(const Image<typename BoolNotBool<T>::type> &img);
            template<typename Y> void Assign(const Image<Y> &img);
            Image& operator=(Image &&img) = default;

            virtual std::unique_ptr<ImageBase> Clone() const override { return std::make_unique<Image>(*this); }

            void Swap(Image &other)
            {
                std::swap(width, other.width);
                std::swap(height, other.height);
                std::swap(pixels, other.pixels);
            }

            virtual void SavePNG(const Path &fname) const override;
            virtual void SaveJPEG(const Path &fname, unsigned int qual) const override;

            template<typename MAT> MAT ToMatrix() const
            {
                auto mat = MAT{GetHeight(), GetWidth()};
                std::copy(begin(), end(), mat[0]);
                return mat;
            }

            /**************************************************************************************
             * Accessors
             *************************************************************************************/

            typename std::vector<pixel_type>::iterator begin() { return pixels.begin(); }
            typename std::vector<pixel_type>::const_iterator begin() const { return pixels.begin(); }
            typename std::vector<pixel_type>::iterator end() { return pixels.end(); }
            typename std::vector<pixel_type>::const_iterator end() const { return pixels.end(); }
            typename std::vector<pixel_type>::const_iterator cbegin() const { return pixels.begin(); }
            typename std::vector<pixel_type>::const_iterator cend() const { return pixels.end(); }

            inline typename std::vector<pixel_type>::pointer GetPixels() noexcept { return pixels.data(); }
            inline typename std::vector<pixel_type>::const_pointer GetPixels() const noexcept { return pixels.data(); }

            inline typename std::vector<pixel_type>::reference At(size_t x, size_t y) noexcept { return pixels[x + y * width]; }
            inline typename std::vector<pixel_type>::reference At(size_t offset) noexcept { return pixels[offset]; }
            inline typename std::vector<pixel_type>::const_reference At(size_t x, size_t y) const noexcept { return pixels[x + y * width]; }
            inline typename std::vector<pixel_type>::const_reference At(size_t offset) const noexcept { return pixels[offset]; }

            bool operator==(const Image &other) const;
            bool operator!=(const Image &other) const { return !(*this == other); }

            /**************************************************************************************
             * Arithmetic
             *************************************************************************************/

            Image& operator+=(const Image &img);
            Image& operator-=(const Image &img);
            Image& operator*=(double f);
            Image& operator*=(const Image &img);
            Image& operator/=(const Image &img);

            /**************************************************************************************
             * Edition
             *************************************************************************************/

            void Negative();
            void Complement(pixel_type maxval = std::numeric_limits<pixel_type>::max());

            template<typename Y> void Blit(const Image<Y> &src, const Rect &srczone, size_t dx, size_t dy);
            
            void FloodFill(size_t x, size_t y, const pixel_type &val, crn::DistanceType dist = crn::DistanceType::D4);
            void ScanFill(size_t x, size_t y, const pixel_type &val, crn::DistanceType dist = crn::DistanceType::D4);

            void DrawRect(const Rect &r, pixel_type color, bool filled = false);
            void DrawLine(size_t x1, size_t y1, size_t x2, size_t y2, pixel_type color);

            virtual void ScaleToSize(size_t w, size_t h) override;

            void Flip(const Orientation &ori);

            template<typename CMP = std::less<pixel_type>> void Dilate(const MatrixInt &strel, CMP cmp = std::less<pixel_type>{});
            template<typename CMP = std::less<pixel_type>> void Erode(const MatrixInt &strel, CMP cmp = std::less<pixel_type>{});
            template<typename CMP = std::less<pixel_type>> void FastDilate(size_t halfwin, size_t index = 0, CMP cmp = std::less<pixel_type>{});
            template<typename CMP = std::less<pixel_type>> void FastErode(size_t halfwin, size_t index = 0, CMP cmp = std::less<pixel_type>{});

            void Convolve(const MatrixDouble &mat);
            void GaussianBlur(double sigma);

        protected:
            std::vector<pixel_type> pixels; 
    };

    /**************************************************************************************
     * Characterization
     *************************************************************************************/

    template<typename T> bool IsBitonal(const Image<T> &img);

    template<typename T, typename CMP = std::less<T>> std::pair<T, T> MinMax(const Image<T> &img, CMP cmp = CMP{});

    template<typename T> Rect AutoCrop(const Image<T> &img, const T &bgval);
    template<typename T> Image<T> MakeAutoCrop(const Image<T> &img, const T &bgval);

    template<typename T, typename Y> Point2DInt CrossCorrelation(const Image<T> &img1, const Image<Y> &img2, T fill1 = T(0), Y fill2 = Y(0));

    /**************************************************************************************
     * Transformation
     *************************************************************************************/

    template<typename IMG, typename T> IMG Downgrade(const Image<T> &img);

    template<typename T> SummedAreaTable<SumType<T>> MakeSummedAreaTable(const Image<T> &img);

    template<typename T> Image<T> MakeRotation(const Image<T> &img, const Angle<Degree> &angle, const T &bgColor);
    template<typename T> Image<T> Make90Rotation(const Image<T> &img);
    template<typename T> Image<T> Make180Rotation(const Image<T> &img);
    template<typename T> Image<T> Make270Rotation(const Image<T> &img);

    template<typename T> inline auto Size(const Image<T> &img) noexcept(noexcept(img.Size())) -> decltype(img.Size()) { return img.Size(); }
} // namespace crn

template<typename T1, typename T2> crn::Image<crn::SumType<typename std::common_type<T1, T2>::type>> operator+(const crn::Image<T1> &i1, const crn::Image<T2> &i2);
template<typename T1, typename T2> crn::Image<crn::DiffType<typename std::common_type<T1, T2>::type>> operator-(const crn::Image<T1> &i1, const crn::Image<T2> &i2);
template<typename T1, typename T2> crn::Image<crn::SumType<typename std::common_type<T1, T2>::type>> operator*(const crn::Image<T1> &i1, const crn::Image<T2> &i2);
template<typename T> crn::Image<crn::SumType<typename std::common_type<T, double>::type>> operator*(double d, const crn::Image<T> &i);
template<typename T> crn::Image<crn::SumType<typename std::common_type<T, double>::type>> operator*(const crn::Image<T> &i, double d);
template<typename T1, typename T2> crn::Image<crn::SumType<typename std::common_type<T1, T2>::type>> operator/(const crn::Image<T1> &i1, const crn::Image<T2> &i2);
#include <CRNImage/CRNImageFormats.h>

namespace crn
{
    UImageRGB NewImageRGBFromFile(const Path &fname);
    UImageGray NewImageGrayFromFile(const Path &fname);
    UImageBW NewImageBWFromFile(const Path &fname);

    template<typename IMG, typename T> IMG Downgrade(const Image<T> &img)
    {
        using new_pixel = typename IMG::pixel_type;
        using common_pixel = typename std::common_type<T, new_pixel>::type;

        auto res = IMG(img.GetWidth(), img.GetHeight());
        const auto mM = MinMax(img);
        if ((common_pixel(mM.first) < common_pixel(std::numeric_limits<new_pixel>::lowest())) || 
                (common_pixel(mM.second) > common_pixel(std::numeric_limits<new_pixel>::max())))
        {
            for (auto tmp : Range(img))
            {
                auto val = common_pixel(img.At(tmp)) - common_pixel(mM.first);
                val = (val * common_pixel(std::numeric_limits<new_pixel>::max())) / common_pixel(mM.second - mM.first);
                res.At(tmp) = new_pixel(val);
            }
        }
        else
        {
            for (auto tmp : Range(img))
                res.At(tmp) = new_pixel(img.At(tmp));
        }
        return res;
    }

    template<typename IMG, typename T> IMG Downgrade(const Image<pixel::RGB<T>> &img)
    {
        using new_pixel = typename IMG::pixel_type;
        using new_base = typename new_pixel::type;
        using common_base = typename std::common_type<T, typename new_pixel::type>::type;
        using common_pixel = pixel::RGB<common_base>;

        auto res = IMG(img.GetWidth(), img.GetHeight());
        auto m = std::numeric_limits<T>::max();
        auto M = std::numeric_limits<T>::lowest();
        for (const auto &p : img)
        {
            if (p.r < m) m = p.r;
            if (p.g < m) m = p.g;
            if (p.b < m) m = p.b;
            if (p.r > M) M = p.r;
            if (p.g > M) M = p.g;
            if (p.b > M) M = p.b;
        }
        if ((common_base(m) < common_base(std::numeric_limits<new_base>::lowest())) || 
                (common_base(M) > common_base(std::numeric_limits<new_base>::max())))
        {
            for (auto tmp : Range(img))
            {
                auto val = common_pixel(img.At(tmp)) - common_pixel(m);
                val = (val * common_base(std::numeric_limits<new_base>::max())) / common_base(M - m);
                res.At(tmp) = new_pixel(val);
            }
        }
        else
        {
            for (auto tmp : Range(img))
                res.At(tmp) = new_pixel(img.At(tmp));
        }
        return res;
    }

    /*************************************************************************************
     * File operations
     ************************************************************************************/

    namespace impl
    {
        void SavePNG(const ImageBW &img, const Path &fname);
        void SaveJPEG(const ImageBW &img, const Path &fname, unsigned int qual);

        void SavePNG(const ImageGray &img, const Path &fname);
        void SaveJPEG(const ImageGray &img, const Path &fname, unsigned int qual);

        void SavePNG(const ImageRGB &img, const Path &fname);
        void SaveJPEG(const ImageRGB &img, const Path &fname, unsigned int qual);

        template<typename T> void SavePNG(const Image<pixel::RGB<T>> &img, const Path &fname)
        {
            SavePNG(Downgrade<ImageRGB>(img), fname);
        }
        template<typename T> void SaveJPEG(const Image<pixel::RGB<T>> &img, const Path &fname, unsigned int qual)
        {
            SaveJPEG(Downgrade<ImageRGB>(img), fname, qual);
        }

        template<typename T> void SavePNG(const Image<T> &img, const Path &fname, typename std::enable_if<std::is_arithmetic<T>::value>::type *dummy = nullptr)
        {
            SavePNG(Downgrade<ImageGray>(img), fname);
        }
        template<typename T> void SaveJPEG(const Image<T> &img, const Path &fname, unsigned int qual, typename std::enable_if<std::is_arithmetic<T>::value>::type *dummy = nullptr)
        {
            SaveJPEG(Downgrade<ImageGray>(img), fname, qual);
        }

        template<typename T> void SavePNG(const Image<T> &img, const Path &fname, typename std::enable_if<!std::is_arithmetic<T>::value>::type *dummy = nullptr)
        {
            throw ExceptionInvalidArgument("SavePNG(): pixel format not supported.");
        }

        template<typename T> void SaveJPEG(const Image<T> &img, const Path &fname, unsigned int qual, typename std::enable_if<!std::is_arithmetic<T>::value>::type *dummy = nullptr)
        {
            throw ExceptionInvalidArgument("SaveJPEG(): pixel format not supported.");
        }
    }

}

#include <CRNImage/CRNImage.hpp>

#endif