ImageEncoder.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Exception/CallbackError.h"
#include "enrollment/Export.h"
#include "enrollment/File/BinaryFile.h"
#include "enrollment/File/FileException.h"
#include "enrollment/Image/ImageAttribute.h"
#include "enrollment/Image/ImageException.h"
#include "enrollment/Image/ImageType.h"
#include "enrollment/Serialization/Writer.h"
#include <array>
#include <atomic>
#include <functional>
#include <map>
#include <memory>
#include <mutex>
#include <set>
#include <vector>
 
namespace inno
{
    extern "C"
    {
        using inno_AllocateData = uint8_t* (*)(void*, size_t);
        INNO_ENROLLMENT_API void inno_ImageEncoder_Encode(const uint8_t* raw,
                                                          unsigned int rawHeight,
                                                          unsigned int rawWidth,
                                                          unsigned int rawDpi,
                                                          uint8_t rawType,
                                                          const int* options,
                                                          size_t optionLength,
                                                          uint8_t type,
                                                          inno_AllocateData allocator,
                                                          void* container,
                                                          ErrorCallbacks errorCallbacks);
        INNO_ENROLLMENT_API int inno_ImageEncoder_GetPngCompressionLevelId();
        INNO_ENROLLMENT_API size_t inno_ImageEncoder_GetRawLength(unsigned int rawHeight,
                                                                  unsigned int rawWidth,
                                                                  unsigned char channels);
        INNO_ENROLLMENT_API void inno_ImageEncoder_EncodeRaw(uint8_t* storage,
                                                             unsigned int rawHeight,
                                                             unsigned int rawWidth,
                                                             unsigned int rawDpi,
                                                             uint8_t rawType,
                                                             const uint8_t* raw,
                                                             size_t rawSize);
 
        INNO_ENROLLMENT_API int inno_ImageEncoder_GeJpgQualityId();
        INNO_ENROLLMENT_API int inno_ImageEncoder_GeJpgProgressiveId();
        INNO_ENROLLMENT_API int inno_ImageEncoder_GeJpgOptimizedId();
        INNO_ENROLLMENT_API int inno_ImageEncoder_GetTiffCompressionId();
        INNO_ENROLLMENT_API int inno_ImageEncoder_GetTiffUnitId();
        INNO_ENROLLMENT_API int inno_ImageEncoder_GetTiffXDpiId();
        INNO_ENROLLMENT_API int inno_ImageEncoder_GetTiffYDpiId();
        INNO_ENROLLMENT_API int inno_ImageEncoder_GeWebpQualityId();
        INNO_ENROLLMENT_API int inno_ImageEncoder_GetJpg2000CompressionRateId();
    }
 
    class BmpImageEncoder;
    class PngImageEncoder;
    class TiffImageEncoder;
    class JpgImageEncoder;
    class Jp2ImageEncoder;
    class WsqImageEncoder;
    class IRawImageEncoder;
    class WebpImageEncoder;

     */
    class ImageEncoderVisitor
    {
    public:
        virtual void Visit(const BmpImageEncoder& encoder) = 0;
        virtual void Visit(const PngImageEncoder& encoder) = 0;
        virtual void Visit(const TiffImageEncoder& encoder) = 0;
        virtual void Visit(const JpgImageEncoder& encoder) = 0;
        virtual void Visit(const Jp2ImageEncoder& encoder) = 0;
        virtual void Visit(const WsqImageEncoder& encoder) = 0;
        virtual void Visit(const IRawImageEncoder& encoder) = 0;
        virtual void Visit(const WebpImageEncoder& encoder) = 0;
 
        ImageEncoderVisitor() = default;
        virtual ~ImageEncoderVisitor() = default;
        ImageEncoderVisitor(const ImageEncoderVisitor&) = delete;
        ImageEncoderVisitor(ImageEncoderVisitor&&) = delete;
        ImageEncoderVisitor& operator=(const ImageEncoderVisitor&) = delete;
        ImageEncoderVisitor& operator=(ImageEncoderVisitor&&) = delete;
    };

     */
    class ImageEncoder
    {
    public:
        [[nodiscard]] virtual std::vector<uint8_t> Encode(const RawImage& raw) const = 0;
        virtual void Accept(ImageEncoderVisitor& visitor) const = 0;

        static std::shared_ptr<ImageEncoder> Create(ImageType type);
 
        ImageEncoder() = default;
        ImageEncoder(const ImageEncoder&) = delete;
        ImageEncoder(ImageEncoder&&) = delete;
        ImageEncoder& operator=(const ImageEncoder&) = delete;
        ImageEncoder& operator=(ImageEncoder&&) = delete;
        virtual ~ImageEncoder() = default;
    };

     */
    class SupportedImageEncoder : public ImageEncoder
    {
    public:
         */
        std::vector<uint8_t> Encode(const RawImage& raw) const final
        {
            if (raw.height == 0 || raw.width == 0 || raw.Data().empty())
            {
                throw InvalidImageArgumentException("Empty image");
            }
 
            std::vector<uint8_t> encodedImage;
            auto opt = ComposeOptions(raw);
 
            inno_ImageEncoder_Encode(raw.Data().data(),
                                     raw.height,
                                     raw.width,
                                     static_cast<unsigned int>(raw.dpi),
                                     static_cast<uint8_t>(raw.type),
                                     opt.data(),
                                     opt.size(),
                                     static_cast<ImageType::Type>(type),
                                     &SupportedImageEncoder::AllocateData,
                                     &encodedImage,
                                     ThrowOnError{});
 
            return encodedImage;
        }
 
        SupportedImageEncoder() = delete;
        SupportedImageEncoder(const SupportedImageEncoder&) = delete;
        SupportedImageEncoder(SupportedImageEncoder&&) = delete;
        SupportedImageEncoder& operator=(const SupportedImageEncoder&) = delete;
        SupportedImageEncoder& operator=(SupportedImageEncoder&&) = delete;
        virtual ~SupportedImageEncoder() = default;
 
    protected:
        explicit SupportedImageEncoder(ImageType::Type imageType)
          : type(imageType)
        {
        }
 
        void SetOption(int key, int value)
        {
            const std::scoped_lock lock(mux);
            options[key] = value;
        }
 
    private:
        ImageType type;
        std::map<int, int> options;
        mutable std::mutex mux;
 
        using AllocFunc = uint8_t* (*)(void*, std::size_t);
        static uint8_t* AllocateData(void* container, const size_t length)
        {
            std::vector<uint8_t>& vec = *static_cast<std::vector<uint8_t>*>(container);
            vec.resize(length);
            return vec.data();
        }
 
        virtual void AddOptionsForImageAttributes(const RawImage& /*image*/,
                                                  const std::function<void(int, int)>& /*addOption*/) const
        {
        }
 
        std::vector<int> ComposeOptions(const RawImage& image) const
        {
            std::vector<int> o;
            o.reserve(options.size() * 2);
 
            {
                const std::scoped_lock lock(mux);
                for (auto const& [key, val] : options)
                {
                    o.push_back(key);
                    o.push_back(val);
                }
            }
 
            AddOptionsForImageAttributes(image,
                                         [&](int key, int val)
                                         {
                                             o.push_back(key);
                                             o.push_back(val);
                                         });
            return o;
        }
    };

     */
    class BmpImageEncoder : public SupportedImageEncoder
    {
    public:
         */
        BmpImageEncoder()
          : SupportedImageEncoder(ImageType::BMP)
        {
        }
 
        void Accept(ImageEncoderVisitor& visitor) const final
        {
            visitor.Visit(*this);
        }
 
        BmpImageEncoder(const BmpImageEncoder&) = delete;
        BmpImageEncoder(BmpImageEncoder&&) = delete;
        BmpImageEncoder& operator=(const BmpImageEncoder&) = delete;
        BmpImageEncoder& operator=(BmpImageEncoder&&) = delete;
        virtual ~BmpImageEncoder() = default;
    };

     */
    class PngImageEncoder : public SupportedImageEncoder
    {
    public:
         */
        PngImageEncoder()
          : SupportedImageEncoder(ImageType::PNG)
          , lev(DefaultLevel)
        {
            SetCompressionLevel(lev);
        }

         */
        void SetCompressionLevel(int level)
        {
            static const int MinLevel = 0;
            static const int MaxLevel = 9;
            if (level < MinLevel || level > MaxLevel)
            {
                throw EnrollmentInvalidArgumentException("PNG compression level must be in <0,9>");
            }
            lev = level;
            SetOption(inno_ImageEncoder_GetPngCompressionLevelId(), level);
        }

         */
        int GetCompressionLevel() const
        {
            return lev;
        }
 
        void Accept(ImageEncoderVisitor& visitor) const final
        {
            visitor.Visit(*this);
        }
 
        PngImageEncoder(const PngImageEncoder&) = delete;
        PngImageEncoder(PngImageEncoder&&) = delete;
        PngImageEncoder& operator=(const PngImageEncoder&) = delete;
        PngImageEncoder& operator=(PngImageEncoder&&) = delete;
        virtual ~PngImageEncoder() = default;
 
    private:
        static const int DefaultLevel = 9;
        std::atomic<int> lev;
    };

     */
    class JpgImageEncoder : public SupportedImageEncoder
    {
    public:
        // The member variables are initialized in constructor body
        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init,hicpp-member-init)
        JpgImageEncoder()
          : SupportedImageEncoder(ImageType::JPG)
        {
            SetQuality(DefaultQuality);
            SetProgressive(false);
            SetOptimize(false);
        }

         */
        void SetQuality(int quality)
        {
            static const int MinQuality = 0;
            static const int MaxQuality = 100;
            if (quality < MinQuality || quality > MaxQuality)
            {
                throw EnrollmentInvalidArgumentException("JPG quality must be in <0,100>");
            }
            q = quality;
            SetOption(inno_ImageEncoder_GeJpgQualityId(), quality);
        }

         */
        int GetQuality() const
        {
            return q;
        }

         */
        void SetProgressive(bool isOn)
        {
            pf = isOn;
            SetOption(inno_ImageEncoder_GeJpgProgressiveId(), isOn ? 1 : 0);
        }

         */
        bool GetProgressive() const
        {
            return pf;
        }

         */
        void SetOptimize(bool isOn)
        {
            o = isOn;
            SetOption(inno_ImageEncoder_GeJpgOptimizedId(), isOn ? 1 : 0);
        }

         */
        bool GetOptimize() const
        {
            return o;
        }
 
        void Accept(ImageEncoderVisitor& visitor) const final
        {
            visitor.Visit(*this);
        }
 
        JpgImageEncoder(const JpgImageEncoder&) = delete;
        JpgImageEncoder(JpgImageEncoder&&) = delete;
        JpgImageEncoder& operator=(const JpgImageEncoder&) = delete;
        JpgImageEncoder& operator=(JpgImageEncoder&&) = delete;
        virtual ~JpgImageEncoder() = default;
 
    private:
        static const int DefaultQuality = 95;
        std::atomic<int> q;
        std::atomic<bool> pf;
        std::atomic<bool> o;
    };

     */
    class TiffImageEncoder : public SupportedImageEncoder
    {
    public:
         */
        TiffImageEncoder()
          : SupportedImageEncoder(ImageType::TIFF)
          , comp(NONE)
        {
        }
         */
        enum Compression : uint16_t
        {
            NONE = 1,
            CCITTRLE = 2,
            CCITTFAX3 = 3,
            CCITT_T4 = CCITTFAX3,
            CCITTFAX4 = 4,
            CCITT_T6 = CCITTFAX4,
            LZW = 5,
            JPEG = 7,
            NEXT = 32766,
            CCITTRLEW = 32771,
            PACKBITS = 32773,
            THUNDERSCAN = 32809,
            IT8CTPAD = 32895,
            IT8LW = 32896,
            IT8MP = 32897,
            IT8BL = 32898,
            PIXARFILM = 32908,
            PIXARLOG = 32909,
            DEFLATE = 32946,
            ADOBE_DEFLATE = 8,
            DCS = 32947,
            SGILOG = 34676,
            SGILOG24 = 34677,
            JP2000 = 34712
        };

         */
        void SetCompression(Compression compression)
        {
            if (!IsCompressionValid(compression))
            {
                throw EnrollmentInvalidArgumentException("Unsupported TIFF compression type: " +
                                                         std::to_string(compression));
            }
 
            comp = compression;
            SetOption(inno_ImageEncoder_GetTiffCompressionId(), compression);
        }

         */
        Compression GetCompression() const
        {
            return comp;
        }
 
        void Accept(ImageEncoderVisitor& visitor) const final
        {
            visitor.Visit(*this);
        }
 
        TiffImageEncoder(const TiffImageEncoder&) = delete;
        TiffImageEncoder(TiffImageEncoder&&) = delete;
        TiffImageEncoder& operator=(const TiffImageEncoder&) = delete;
        TiffImageEncoder& operator=(TiffImageEncoder&&) = delete;
        virtual ~TiffImageEncoder() = default;
 
    private:
        std::atomic<Compression> comp;
 
        void AddOptionsForImageAttributes(const RawImage& image,
                                          const std::function<void(int, int)>& addOption) const final
        {
            constexpr int ResultUnitInch = 2;
            addOption(inno_ImageEncoder_GetTiffUnitId(), ResultUnitInch);
            addOption(inno_ImageEncoder_GetTiffXDpiId(), static_cast<int>(static_cast<unsigned int>(image.dpi)));
            addOption(inno_ImageEncoder_GetTiffYDpiId(), static_cast<int>(static_cast<unsigned int>(image.dpi)));
        }
 
        static bool IsCompressionValid(const Compression compression)
        {
            switch (compression)
            {
            case NONE:
                [[fallthrough]];
            case CCITTRLE:
                [[fallthrough]];
            case CCITT_T4:
                [[fallthrough]];
            case CCITT_T6:
                [[fallthrough]];
            case LZW:
                [[fallthrough]];
            case JPEG:
                [[fallthrough]];
            case NEXT:
                [[fallthrough]];
            case CCITTRLEW:
                [[fallthrough]];
            case PACKBITS:
                [[fallthrough]];
            case THUNDERSCAN:
                [[fallthrough]];
            case IT8CTPAD:
                [[fallthrough]];
            case IT8LW:
                [[fallthrough]];
            case IT8MP:
                [[fallthrough]];
            case IT8BL:
                [[fallthrough]];
            case PIXARFILM:
                [[fallthrough]];
            case PIXARLOG:
                [[fallthrough]];
            case DEFLATE:
                [[fallthrough]];
            case ADOBE_DEFLATE:
                [[fallthrough]];
            case DCS:
                [[fallthrough]];
            case SGILOG:
                [[fallthrough]];
            case SGILOG24:
                [[fallthrough]];
            case JP2000:
                return true;
            }
            return false;
        }
    };

     */
    class Jp2ImageEncoder : public SupportedImageEncoder
    {
    public:
         */
        Jp2ImageEncoder()
          : SupportedImageEncoder(ImageType::JPG2000)
          , r(4)
        {
        }

         */
        void SetCompressionRatio(int ratio)
        {
            static const int MaxRatio = 1000;
            static const int MinRatio = 1;
            if (ratio < MinRatio || ratio > MaxRatio)
            {
                throw EnrollmentInvalidArgumentException("JP2 compression ratio dcd must be in <1,1000>");
            }
 
            r = ratio;
            // calculate compression rate used by underlying encoder
            auto rate = MaxRatio / ratio;
            SetOption(inno_ImageEncoder_GetJpg2000CompressionRateId(), rate);
        }

         */
        int GetCompressionRatio() const
        {
            return r;
        }

         */
        bool IsLossy() const
        {
            return r != 1;
        }

         */
        bool IsLossless() const
        {
            return r == 1;
        }
 
        void Accept(ImageEncoderVisitor& visitor) const final
        {
            visitor.Visit(*this);
        }
 
        Jp2ImageEncoder(const Jp2ImageEncoder&) = delete;
        Jp2ImageEncoder(Jp2ImageEncoder&&) = delete;
        Jp2ImageEncoder& operator=(const Jp2ImageEncoder&) = delete;
        Jp2ImageEncoder& operator=(Jp2ImageEncoder&&) = delete;
        virtual ~Jp2ImageEncoder() = default;
 
    private:
        std::atomic<int> r;
    };

     */
    class WebpImageEncoder : public SupportedImageEncoder
    {
    public:
         */
        WebpImageEncoder()
          : SupportedImageEncoder(ImageType::WEBP)
          , q(DefaultQuality)
        {
        }

         */
        void SetQuality(int quality)
        {
            static const int MinQuality = 0;
            static const int MaxQuality = 100;
            if (quality < MinQuality || quality > MaxQuality)
            {
                throw EnrollmentInvalidArgumentException("WebP quality must be in <0,100>");
            }
            q = quality;
            SetOption(inno_ImageEncoder_GeWebpQualityId(), quality);
        }

         */
        int GetQuality() const
        {
            return q;
        }
 
        void Accept(ImageEncoderVisitor& visitor) const final
        {
            visitor.Visit(*this);
        }
 
        WebpImageEncoder(const WebpImageEncoder&) = delete;
        WebpImageEncoder(WebpImageEncoder&&) = delete;
        WebpImageEncoder& operator=(const WebpImageEncoder&) = delete;
        WebpImageEncoder& operator=(WebpImageEncoder&&) = delete;
        virtual ~WebpImageEncoder() = default;
 
    private:
        static const int DefaultQuality = 95;
        std::atomic<int> q;
    };

     */
    class WsqImageEncoder : public SupportedImageEncoder
    {
    public:
         */
        WsqImageEncoder()
          : SupportedImageEncoder(ImageType::WSQ)
        {
        }
 
        void Accept(ImageEncoderVisitor& visitor) const final
        {
            visitor.Visit(*this);
        }

         */
        void SetBitrate(float bitrate)
        {
            static constexpr float MaxBitrate = 5.0F;
            static constexpr float MinBitrate = 0.1F;
            if (bitrate < MinBitrate || bitrate > MaxBitrate)
            {
                throw EnrollmentInvalidArgumentException("WSQ bitrate must be in <0.1,5.0>");
            }
 
            b = bitrate;
        }

         */
        float GetBitrate() const
        {
            return b;
        }
 
        WsqImageEncoder(const WsqImageEncoder&) = delete;
        WsqImageEncoder(WsqImageEncoder&&) = delete;
        WsqImageEncoder& operator=(const WsqImageEncoder&) = delete;
        WsqImageEncoder& operator=(WsqImageEncoder&&) = delete;
        virtual ~WsqImageEncoder() = default;
 
        static constexpr float WsqBitrateDefault = 1.25;
        static constexpr int WsqBitrateId = 1;
        static constexpr float WsqBitrateCoeff = 100.F;
 
    private:
        std::atomic<float> b = WsqBitrateDefault;
 
        void AddOptionsForImageAttributes(const RawImage& /*image*/,
                                          const std::function<void(int, int)>& addOption) const final
        {
            const auto bitrate = static_cast<int>(b * WsqBitrateCoeff);
            addOption(WsqBitrateId, bitrate);
        }
    };

     */
    class IRawImageEncoder : public ImageEncoder
    {
    public:
         */
        [[nodiscard]] std::vector<uint8_t> Encode(const RawImage& raw) const final
        {
            if (raw.height == 0 || raw.width == 0 || raw.channels == 0 || raw.Data().empty())
            {
                throw InvalidImageArgumentException("Empty image");
            }
 
            std::vector<uint8_t> encoded(inno_ImageEncoder_GetRawLength(raw.height, raw.width, raw.channels));
            inno_ImageEncoder_EncodeRaw(encoded.data(),
                                        raw.height,
                                        raw.width,
                                        static_cast<unsigned int>(raw.dpi),
                                        raw.type,
                                        raw.Data().data(),
                                        raw.Data().size());
            return encoded;
        }
 
        void Accept(ImageEncoderVisitor& visitor) const final
        {
            visitor.Visit(*this);
        }
 
        IRawImageEncoder() = default;
        IRawImageEncoder(const IRawImageEncoder&) = delete;
        IRawImageEncoder(IRawImageEncoder&&) = delete;
        IRawImageEncoder& operator=(const IRawImageEncoder&) = delete;
        IRawImageEncoder& operator=(IRawImageEncoder&&) = delete;
        virtual ~IRawImageEncoder() = default;
    };
 
    inline std::shared_ptr<ImageEncoder> ImageEncoder::Create(ImageType type)
    {
        switch (static_cast<ImageType::Type>(type))
        {
        case ImageType::BMP:
            return std::make_shared<BmpImageEncoder>();
        case ImageType::PNG:
            return std::make_shared<PngImageEncoder>();
        case ImageType::WSQ:
            return std::make_shared<WsqImageEncoder>();
        case ImageType::IRAW:
            return std::make_shared<IRawImageEncoder>();
        case ImageType::JPG:
            return std::make_shared<JpgImageEncoder>();
        case ImageType::TIFF:
            return std::make_shared<TiffImageEncoder>();
        case ImageType::JPG2000:
            return std::make_shared<Jp2ImageEncoder>();
        case ImageType::WEBP:
            return std::make_shared<WebpImageEncoder>();
        }
 
        throw ImageException(ImageException::UNKNOWN_IMAGE);
    }

     */
    class ImageSaver
    {
    public:
        virtual void Save(const RawImage& raw) const = 0;
 
        ImageSaver() = default;
        ImageSaver(const ImageSaver&) = delete;
        ImageSaver(ImageSaver&&) = delete;
        ImageSaver& operator=(const ImageSaver&) = delete;
        ImageSaver& operator=(ImageSaver&&) = delete;
        virtual ~ImageSaver() = default;
    };

     */
    class ImageFileSaver : public ImageSaver
    {
    public:
         */
        explicit ImageFileSaver(std::string path)
          : fp(std::move(path))
        {
        }

         */
        void Save(const RawImage& raw) const final
        {
            auto extension = fp.substr(fp.find_last_of('.'), fp.length());
            auto encoder = ImageEncoder::Create(ImageType::FromFileExtension(extension));
            BinaryFile::WriteAll(fp, encoder->Encode(raw));
        }
 
        ImageFileSaver(const ImageFileSaver&) = delete;
        ImageFileSaver(ImageFileSaver&&) = delete;
        ImageFileSaver& operator=(const ImageFileSaver&) = delete;
        ImageFileSaver& operator=(ImageFileSaver&&) = delete;
        virtual ~ImageFileSaver() = default;
 
    private:
        std::string fp;
    };
} // namespace inno