Image.h

Go to the documentation of this file.

#pragma once
 
#include "enrollment/Exception/CallbackError.h"
#include "enrollment/Export.h"
#include "enrollment/Image/ImageAttribute.h"
#include "enrollment/Image/ImageEncoder.h"
#include "enrollment/Image/ImageException.h"
#include "enrollment/Image/ImageExecutor.h"
#include "enrollment/Image/ImageMask.h"
#include "enrollment/Image/ImageShape.h"
#include "enrollment/Image/ImageType.h"
#include "enrollment/Serialization/Writer.h"
#include <ciso646>
#include <mutex>
#include <optional>
#include <variant>
#include <vector>
 
namespace inno
{

     */
    class Image
    {
    public:
         */
        static std::shared_ptr<Image> Decode(const std::vector<uint8_t>& imageData)
        {
            return Decode(imageData, static_cast<unsigned int>(DefaultDpi), GlobalImageExecutor::Get());
        }

         */
        static std::shared_ptr<Image> Decode(const std::vector<uint8_t>& imageData, unsigned int dpi)
        {
            return Decode(imageData, dpi, GlobalImageExecutor::Get());
        }

         */
        static std::shared_ptr<Image> Decode(const std::vector<uint8_t>& imageData,
                                             std::shared_ptr<ImageExecutor> executor)
        {
            return Decode(imageData, static_cast<unsigned int>(DefaultDpi), std::move(executor));
        }

         */
        static std::shared_ptr<Image> Decode(const std::vector<uint8_t>& imageData,
                                             unsigned int dpi,
                                             std::shared_ptr<ImageExecutor> executor)
        {
            if (executor == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
 
            const ImageType type = DeduceType(imageData);
 
            auto* impl = executor->Create(imageData.data(), imageData.size(), dpi, ThrowOnError{});
 
            if (impl == nullptr)
            {
                throw ImageException(ImageException::DECODE_IMAGE);
            }
 
            std::shared_ptr<ImageEncoder> encoder = ImageEncoder::Create(type);
 
            return SharedImage(impl, std::move(encoder), std::move(executor));
        }

        /// Enum define possible intersection of Image and some Object e.g. Rectangle, Circle.
        enum class Intersection : uint8_t
        {
            PARTIAL,
            INSIDE,
            OUTSIDE,
            NO,
            SAME
        };
         */
        [[nodiscard]] Intersection RectangleIntersection(const Rectangle& rectangle) const
        {
            auto result = static_cast<Intersection>(exec->IntersectionRectangle(impl.get(),
                                                                                rectangle.GetTopLeft().x,
                                                                                rectangle.GetTopLeft().y,
                                                                                rectangle.GetTopRight().x,
                                                                                rectangle.GetTopRight().y,
                                                                                rectangle.GetBottomRight().x,
                                                                                rectangle.GetBottomRight().y,
                                                                                rectangle.GetBottomLeft().x,
                                                                                rectangle.GetBottomLeft().y,
                                                                                ThrowOnError{}));
 
            return result;
        }

         */
        [[nodiscard]] Intersection CircleIntersection(const Circle& circle) const
        {
            auto result = static_cast<Intersection>(
              exec->IntersectionCircle(impl.get(), circle.center.x, circle.center.y, circle.radius, ThrowOnError{}));
 
            return result;
        }

         */
        [[nodiscard]] Intersection PointIntersection(const Point& point) const
        {
            auto result =
              static_cast<Intersection>(exec->IntersectionPoint(impl.get(), point.x, point.y, ThrowOnError{}));
 
            return result;
        }

         */
        static std::shared_ptr<Image> DecodeRawImage(
          const RawImage& raw,
          std::shared_ptr<ImageEncoder> originalEncoder = nullptr,
          std::shared_ptr<ImageExecutor> executor = GlobalImageExecutor::Get())
        {
            auto* impl = executor->CreateRaw(
              raw.width, raw.height, static_cast<unsigned int>(raw.dpi), raw.type, raw.Data().data(), ThrowOnError{});
 
            if (originalEncoder != nullptr)
            {
                return SharedImage(impl, std::move(originalEncoder), std::move(executor));
            }
 
            std::shared_ptr<ImageEncoder> encoder = std::make_shared<IRawImageEncoder>();
 
            return SharedImage(impl, std::move(encoder), std::move(executor));
        }

         */
        static ImageType DeduceType(const std::vector<uint8_t>& imageData)
        {
            auto type = inno_local_Image_DeduceType(imageData.data(), imageData.size(), ThrowOnError{});
            auto result = ImageType{ type };
 
            return result;
        }

         */
        [[nodiscard]] ImageDpi Dpi() const
        {
            return ImageDpi{ exec->Dpi(impl.get()) };
        }

         */
        [[nodiscard]] ImageWidth Width() const
        {
            return exec->Width(impl.get());
        }

         */
        [[nodiscard]] ImageHeight Height() const
        {
            return exec->Height(impl.get());
        }

         */
        [[nodiscard]] std::shared_ptr<ImageEncoder> OriginalEncoder() const
        {
            return originalEncoder;
        }

         */
        [[nodiscard]] RawImage AsRawImage() const
        {
            auto size = exec->RawSize(impl.get());
            std::vector<uint8_t> raw(size, 0);
            unsigned int type = 0;
 
            exec->ToRaw(impl.get(), raw.data(), size, &type, ThrowOnError{});
 
            return { Width(), Height(), Dpi(), static_cast<RawImage::Type>(type), std::move(raw) };
        }

         */
        [[nodiscard]] RawImage AsRawGrayscale() const
        {
            auto size = exec->RawTypeSize(impl.get(), RawImage::Type::GRAYSCALE, ThrowOnError{});
 
            std::vector<uint8_t> raw(size, 0);
            exec->ToRawType(impl.get(), raw.data(), size, RawImage::Type::GRAYSCALE, ThrowOnError{});
 
            return { Width(), Height(), Dpi(), RawImage::Type::GRAYSCALE, std::move(raw) };
        }

         */
        [[nodiscard]] RawImage AsRawBGR() const
        {
            auto size = exec->RawTypeSize(impl.get(), RawImage::Type::BGR, ThrowOnError{});
 
            std::vector<uint8_t> raw(size, 0);
            exec->ToRawType(impl.get(), raw.data(), size, RawImage::Type::BGR, ThrowOnError{});
 
            return { Width(), Height(), Dpi(), RawImage::Type::BGR, std::move(raw) };
        }

         */
        [[nodiscard]] std::shared_ptr<Image> AsBGR() const
        {
            auto rawBgr = AsRawBGR();
            return DecodeRawImage(rawBgr, originalEncoder, exec);
        }

         */
        [[nodiscard]] RawImage AsRawBGRA() const
        {
            auto size = exec->RawTypeSize(impl.get(), RawImage::Type::BGRA, ThrowOnError{});
 
            std::vector<uint8_t> raw(size, 0);
            exec->ToRawType(impl.get(), raw.data(), size, RawImage::Type::BGRA, ThrowOnError{});
 
            return { Width(), Height(), Dpi(), RawImage::Type::BGRA, std::move(raw) };
        }

         */
        [[nodiscard]] std::shared_ptr<Image> AsBGRA() const
        {
            auto rawBgr = AsRawBGRA();
            return DecodeRawImage(rawBgr, originalEncoder, exec);
        }

         */
        [[nodiscard]] std::vector<uint8_t> EncodeIn(ImageEncoder& encoder) const
        {
            auto raw = AsRawImage();
            return encoder.Encode(raw);
        }

         */
        void SaveIn(ImageSaver& saver) const
        {
            auto raw = AsRawImage();
            saver.Save(raw);
        }

         */
        void SaveAs(const std::string& path) const
        {
            auto raw = AsRawImage();
            auto saver = ImageFileSaver(path);
            saver.Save(raw);
        }

         */
        bool operator==(const Image& right) const
        {
            if (exec == nullptr && right.exec == nullptr)
            {
                // both images are empty
                return true;
            }
            if (exec == right.exec)
            {
 
                auto result = exec->IsEqual(impl.get(), right.impl.get(), ThrowOnError{});
 
                return result;
            }
            if (exec != nullptr && right.exec != nullptr)
            {
                // compare raw data
                auto raw = AsRawImage();
                auto rightRaw = right.AsRawImage();
                return raw == rightRaw;
            }
 
            // one image is empty and one not, they are not same
            return false;
        }

         */
        [[nodiscard]] std::shared_ptr<Image> DrawShape(const ImageShape& shape) const
        {
            auto* newImpl = exec->Clone(impl.get(), ThrowOnError{});
 
            ImplDrawer drawer(newImpl, exec);
            shape.DrawIn(drawer);
            drawer.DrawingFinished();
            return SharedImage(newImpl, originalEncoder, exec);
        }

         */
        [[nodiscard]] std::shared_ptr<Image> CropRectangle(const Rectangle& r) const
        {
            return CropRectangle(r, Colors::White);
        }

         */
        [[nodiscard]] std::shared_ptr<Image> CropRectangle(const Rectangle& r, const RGBA& background) const
        {
            return CropRectangle(r, background, ImageDimensions{});
        }

         */
        [[nodiscard]] std::shared_ptr<Image> CropRectangle(const Rectangle& r,
                                                           const RGBA& background,
                                                           const ImageDimensions& dimension) const
        {
            if (RectangleIntersection(r) == Intersection::NO)
            {
                throw EnrollmentInvalidArgumentException("Given rectangle has no intersection with image");
            }
 
            auto* newImpl = exec->CropRectangle(impl.get(),
                                                r.GetTopLeft().x,
                                                r.GetTopLeft().y,
                                                r.GetTopRight().x,
                                                r.GetTopRight().y,
                                                r.GetBottomRight().x,
                                                r.GetBottomRight().y,
                                                r.GetBottomLeft().x,
                                                r.GetBottomLeft().y,
                                                dimension.width,
                                                dimension.height,
                                                background.color.red,
                                                background.color.green,
                                                background.color.blue,
                                                background.transparency,
                                                ThrowOnError{});
 
            return SharedImage(newImpl, originalEncoder, exec);
        }

         */
        class ImageResampler
        {
        public:
             */
            explicit ImageResampler(ImageDpi targetDpi)
              : dpi(targetDpi)
            {
                if (static_cast<unsigned int>(targetDpi) == 0)
                {
                    throw EnrollmentInvalidArgumentException("Target DPI must be greater than 0");
                }
            }

            [[nodiscard]] virtual std::shared_ptr<Image> Resample(const inno::Image& image) const = 0;
 
            ImageResampler() = delete;
            virtual ~ImageResampler() = default;
            ImageResampler(const ImageResampler&) = default;
            ImageResampler(ImageResampler&&) = default;
            ImageResampler& operator=(const ImageResampler&) = default;
            ImageResampler& operator=(ImageResampler&&) = default;
 
        protected:
             */
            [[nodiscard]] ImageDpi GetDpi() const
            {
                return dpi;
            }
 
        private:
            ImageDpi dpi;
        };

         */
        class BicubicImageResampler : public ImageResampler
        {
        public:
             */
            explicit BicubicImageResampler(ImageDpi targetDpi)
              : ImageResampler(targetDpi)
            {
            }

             */
            [[nodiscard]] std::shared_ptr<Image> Resample(const inno::Image& image) const final
            {
                auto* newImpl =
                  image.exec->ChangeDpi(image.impl.get(), static_cast<unsigned int>(GetDpi()), ThrowOnError{});
 
                return SharedImage(newImpl, image.originalEncoder, image.exec);
            }
 
            BicubicImageResampler() = delete;
            virtual ~BicubicImageResampler() = default;
            BicubicImageResampler(const BicubicImageResampler&) = default;
            BicubicImageResampler(BicubicImageResampler&&) = default;
            BicubicImageResampler& operator=(const BicubicImageResampler&) = default;
            BicubicImageResampler& operator=(BicubicImageResampler&&) = default;
        };

         */
        class AreaImageResampler : public ImageResampler
        {
        public:
             */
            explicit AreaImageResampler(ImageDpi targetDpi)
              : ImageResampler(targetDpi)
            {
            }

             */
            [[nodiscard]] std::shared_ptr<Image> Resample(const inno::Image& image) const final
            {
                auto* newImpl =
                  image.exec->ChangeDpiArea(image.impl.get(), static_cast<unsigned int>(GetDpi()), ThrowOnError{});
 
                return SharedImage(newImpl, image.originalEncoder, image.exec);
            }
 
            AreaImageResampler() = delete;
            virtual ~AreaImageResampler() = default;
            AreaImageResampler(const AreaImageResampler&) = default;
            AreaImageResampler(AreaImageResampler&&) = default;
            AreaImageResampler& operator=(const AreaImageResampler&) = default;
            AreaImageResampler& operator=(AreaImageResampler&&) = default;
        };

         */
        class NISTImageResampler : public ImageResampler
        {
        public:
            /// Enum defines possible types of interpolation methods to apply during image resampling.
            enum class InterpolationMethod : uint8_t
            {
                BICUBIC,
                BILINEAR,
            };

            /// Enum defines possible types of filtering methods to apply before image resampling.
            enum class FilterType : uint8_t
            {
                GAUSSIAN,
                IDEAL,
            };

             */
            explicit NISTImageResampler(ImageDpi targetDpi)
              : ImageResampler(targetDpi)
            {
            }

             */
            NISTImageResampler(ImageDpi targetDpi, InterpolationMethod interpolationMethod, FilterType filterType)
              : ImageResampler(targetDpi)
              , interpolation(interpolationMethod)
              , filter(filterType)
            {
                const auto checkInterpolationValueIsValid = [](InterpolationMethod i)
                {
                    switch (i)
                    {
                    case InterpolationMethod::BILINEAR:
                        [[fallthrough]];
                    case InterpolationMethod::BICUBIC:
                        return;
                    }
                    throw EnrollmentInvalidArgumentException("Unknown value of interpolation method provided (" +
                                                             std::to_string(static_cast<int>(i)) + ")");
                };
 
                const auto checkFilterValueIsValid = [](FilterType f)
                {
                    switch (f)
                    {
                    case FilterType::GAUSSIAN:
                        [[fallthrough]];
                    case FilterType::IDEAL:
                        return;
                    }
                    throw EnrollmentInvalidArgumentException("Unknown value of filtering type provided (" +
                                                             std::to_string(static_cast<int>(f)) + ")");
                };
 
                checkInterpolationValueIsValid(interpolationMethod);
                checkFilterValueIsValid(filterType);
            }

             */
            [[nodiscard]] std::shared_ptr<Image> Resample(const inno::Image& image) const final
            {
                if (GetDpi() == image.Dpi())
                {
                    throw EnrollmentInvalidArgumentException("Original and target DPI cannot be equal");
                }
                if (image.Channels() > 1)
                {
                    throw EnrollmentInvalidArgumentException(
                      "Only grayscale images are supported by NIST resampling algorithm");
                }
 
                void* newImpl = {};
                if (interpolation.has_value() && filter.has_value())
                {
                    newImpl = image.exec->ChangeDpiNistWithOptions(image.impl.get(),
                                                                   static_cast<unsigned int>(GetDpi()),
                                                                   static_cast<unsigned int>(interpolation.value()),
                                                                   static_cast<unsigned int>(filter.value()),
                                                                   ThrowOnError{});
                }
                else
                {
                    newImpl =
                      image.exec->ChangeDpiNist(image.impl.get(), static_cast<unsigned int>(GetDpi()), ThrowOnError{});
                }
                return SharedImage(newImpl, image.originalEncoder, image.exec);
            }
 
            NISTImageResampler() = delete;
            virtual ~NISTImageResampler() = default;
            NISTImageResampler(const NISTImageResampler&) = default;
            NISTImageResampler(NISTImageResampler&&) = default;
            NISTImageResampler& operator=(const NISTImageResampler&) = default;
            NISTImageResampler& operator=(NISTImageResampler&&) = default;
 
        private:
            std::optional<InterpolationMethod> interpolation;
            std::optional<FilterType> filter;
        };

         */
        [[nodiscard]] std::shared_ptr<Image> ChangeDpiTo(const ImageResampler& resampler) const
        {
            return resampler.Resample(*this);
        }

         */
        [[nodiscard]] std::shared_ptr<Image> ChangeDpiTo(ImageDpi targetDpi) const
        {
            const BicubicImageResampler resampler{ targetDpi };
            return ChangeDpiTo(resampler);
        }

         */
        [[nodiscard]] std::shared_ptr<Image> Resize(float factor) const
        {
            if (not(factor > 0))
            {
                throw EnrollmentInvalidArgumentException("resize factor is not positive real number except 0");
            }
 
            auto* newImpl = exec->Resize(impl.get(), factor, ThrowOnError{});
 
            return SharedImage(newImpl, originalEncoder, exec);
        }

         */
        [[nodiscard]] std::shared_ptr<Image> ResizeToMaxDimension(ImageDimension maxDimension) const
        {
            auto actualMaxDimension = std::max(Width(), Height());
            if (actualMaxDimension <= maxDimension)
            {
                // even if we can return this instance via std::shred_from_this, we will create new instance
                // to keep all functions const. The std::shred_from_this cannot be used only in non const functions
                auto result = SharedImage(exec->Clone(impl.get(), ThrowOnError{}), originalEncoder, exec);
 
                return result;
            }
 
            if (maxDimension == 0)
            {
                return SharedImage(nullptr, originalEncoder, exec);
            }
 
            auto factor = static_cast<float>(maxDimension) / static_cast<float>(actualMaxDimension);
            return Resize(factor);
        }

         */
        [[nodiscard]] std::shared_ptr<Image> CropAlignedRectangle(const Rectangle& r) const
        {
            return CropAlignedRectangle(r, Colors::White);
        }

         */
        [[nodiscard]] std::shared_ptr<Image> CropAlignedRectangle(const Rectangle& r, const RGBA& background) const
        {
            return CropAlignedRectangle(r, background, ImageDimensions{});
        }

         */
        [[nodiscard]] std::shared_ptr<Image> CropAlignedRectangle(const Rectangle& r,
                                                                  const RGBA& background,
                                                                  const ImageDimensions& dimension) const
        {
            auto* newImpl = exec->CropAlignedRectangle(impl.get(),
                                                       r.GetTopLeft().x,
                                                       r.GetTopLeft().y,
                                                       r.GetTopRight().x,
                                                       r.GetTopRight().y,
                                                       r.GetBottomRight().x,
                                                       r.GetBottomRight().y,
                                                       r.GetBottomLeft().x,
                                                       r.GetBottomLeft().y,
                                                       r.GetWidth(),
                                                       r.GetHeight(),
                                                       dimension.width,
                                                       dimension.height,
                                                       background.color.red,
                                                       background.color.green,
                                                       background.color.blue,
                                                       background.transparency,
                                                       ThrowOnError{});
 
            return SharedImage(newImpl, originalEncoder, exec);
        }

         */
        [[nodiscard]] std::shared_ptr<Image> CropCircle(const Circle& circle,
                                                        const RGBA& background = Colors::White) const
        {
            if (CircleIntersection(circle) == Intersection::NO)
            {
                throw EnrollmentInvalidArgumentException("Given circle has no intersection with image");
            }
 
            auto* newImpl = exec->CropCircle(impl.get(),
                                             circle.center.x,
                                             circle.center.y,
                                             circle.radius,
                                             background.color.red,
                                             background.color.green,
                                             background.color.blue,
                                             background.transparency,
                                             ThrowOnError{});
 
            return SharedImage(newImpl, originalEncoder, exec);
        }

         */
        [[nodiscard]] std::shared_ptr<Image> MaskImageBy(const ImageMask& mask) const
        {
            auto* maskerImpl = exec->CreateMasker(impl.get(), ThrowOnError{});
            ImplMasker masker(maskerImpl, exec);
            mask.MaskWith(masker);
            auto* newImageImpl = masker.GetMaskedImage();
            return SharedImage(newImageImpl, originalEncoder, exec);
        }

         */
        [[nodiscard]] size_t Channels() const
        {
            const size_t numOfChannels = exec->Channels(impl.get(), ThrowOnError{});
            return numOfChannels;
        }
 
        Image(const Image& image) = delete;
        Image(Image&& image) = delete;
        Image& operator=(const Image& image) = delete;
        Image& operator=(Image&& image) = delete;
        ~Image() = default;
        Image() = delete;
 
    private:
        std::unique_ptr<void, void (*)(void*)> impl;
        std::shared_ptr<ImageEncoder> originalEncoder;
        std::shared_ptr<ImageExecutor> exec;
        static constexpr size_t MaxErrorMessage = 200;
 
        Image(void* i, std::shared_ptr<ImageEncoder> encoder, std::shared_ptr<ImageExecutor> e)
          : impl(i, e->Destroy())
          , originalEncoder(std::move(encoder))
          , exec(std::move(e))
        {
        }
 
        static std::shared_ptr<Image> SharedImage(void* i,
                                                  std::shared_ptr<ImageEncoder> encoder,
                                                  std::shared_ptr<ImageExecutor> e)
        {
            return std::shared_ptr<Image>(new Image(i, std::move(encoder), std::move(e)));
        }
 
        class ImplDrawer : public ImageShapeDrawer
        {
        public:
            void DrawLine(const Line& line, const ImageShapeAttributes& attr) final
            {
                exec->DrawLine(impl,
                               line.begin.x,
                               line.begin.y,
                               line.end.x,
                               line.end.y,
                               attr.rgba.color.red,
                               attr.rgba.color.green,
                               attr.rgba.color.blue,
                               attr.rgba.transparency,
                               attr.thickness,
                               ThrowOnError{});
            }
 
            void DrawCircle(const Circle& circle, const ImageShapeAttributes& attr) final
            {
                exec->DrawCircle(impl,
                                 circle.center.x,
                                 circle.center.y,
                                 circle.radius,
                                 attr.rgba.color.red,
                                 attr.rgba.color.green,
                                 attr.rgba.color.blue,
                                 attr.rgba.transparency,
                                 attr.thickness,
                                 ThrowOnError{});
            }
 
            void DrawRectangle(const Rectangle& rect, const ImageShapeAttributes& attr) final
            {
                DrawLine(Line{ rect.GetTopLeft(), rect.GetTopRight() }, attr);
                DrawLine(Line{ rect.GetTopRight(), rect.GetBottomRight() }, attr);
                DrawLine(Line{ rect.GetBottomRight(), rect.GetBottomLeft() }, attr);
                DrawLine(Line{ rect.GetBottomLeft(), rect.GetTopLeft() }, attr);
            }
 
            void DrawingFinished()
            {
                exec->DrawingFinished(impl, ThrowOnError{});
            }
 
            ImplDrawer(void* imageImpl, std::shared_ptr<ImageExecutor> e)
              : impl(imageImpl)
              , exec(std::move(e))
            {
            }
 
            ImplDrawer() = delete;
            ImplDrawer(const ImplDrawer&) = delete;
            ImplDrawer(ImplDrawer&&) = delete;
            ImplDrawer& operator=(const ImplDrawer&) = delete;
            ImplDrawer& operator=(ImplDrawer&&) = delete;
            virtual ~ImplDrawer() = default;
 
        private:
            void* impl;
            std::shared_ptr<ImageExecutor> exec;
        };
 
        class ImplMasker final : public ImageMasker
        {
        public:
            void MaskCircle(const Circle& circle, const class ImageMaskConfiguration& conf) final
            {
 
                exec->MaskCircle(impl.get(),
                                 circle.center.x,
                                 circle.center.y,
                                 static_cast<unsigned int>(circle.radius),
                                 conf.GetMaskColor().color.red,
                                 conf.GetMaskColor().color.green,
                                 conf.GetMaskColor().color.blue,
                                 conf.GetMaskColor().transparency,
                                 static_cast<unsigned int>(conf.GetMaskType()),
                                 ThrowOnError{});
            }
 
            void MaskPolygon(const Polygon& polygon, const class ImageMaskConfiguration& conf) final
            {
                const auto& pp = polygon.GetPoints();
                std::vector<int> polygonX(pp.size());
                std::vector<int> polygonY(pp.size());
                for (auto x = polygonX.begin(), y = polygonY.begin(); const auto& p : pp)
                {
                    *x = p.x;
                    *y = p.y;
                    std::advance(x, 1);
                    std::advance(y, 1);
                }
 
                exec->MaskPolygon(impl.get(),
                                  polygonX.data(),
                                  polygonY.data(),
                                  pp.size(),
                                  conf.GetMaskColor().color.red,
                                  conf.GetMaskColor().color.green,
                                  conf.GetMaskColor().color.blue,
                                  conf.GetMaskColor().transparency,
                                  static_cast<unsigned int>(conf.GetMaskType()),
                                  ThrowOnError{});
            }
 
            void BlurCircle(const Circle& circle, ImageMaskType maskType, ImageBlurType blurType) final
            {
 
                exec->BlurCircle(impl.get(),
                                 circle.center.x,
                                 circle.center.y,
                                 static_cast<unsigned int>(circle.radius),
                                 static_cast<unsigned int>(maskType),
                                 static_cast<unsigned int>(blurType),
                                 ThrowOnError{});
            }
 
            void BlurPolygon(const Polygon& polygon, ImageMaskType maskType, ImageBlurType blurType) final
            {
                const auto& pp = polygon.GetPoints();
                std::vector<int> polygonX(pp.size());
                std::vector<int> polygonY(pp.size());
                for (auto x = polygonX.begin(), y = polygonY.begin(); const auto& p : pp)
                {
                    *x = p.x;
                    *y = p.y;
                    std::advance(x, 1);
                    std::advance(y, 1);
                }
 
                exec->BlurPolygon(impl.get(),
                                  polygonX.data(),
                                  polygonY.data(),
                                  pp.size(),
                                  static_cast<unsigned int>(maskType),
                                  static_cast<unsigned int>(blurType),
                                  ThrowOnError{});
            }
 
            void AddToBlur(const Circle& circle, ImageMaskType maskType) final
            {
 
                exec->AddCircleToBlurMask(impl.get(),
                                          circle.center.x,
                                          circle.center.y,
                                          static_cast<unsigned int>(circle.radius),
                                          static_cast<unsigned int>(maskType),
                                          ThrowOnError{});
            }
 
            void AddToBlur(const Polygon& polygon, ImageMaskType maskType) final
            {
                const auto& pp = polygon.GetPoints();
                std::vector<int> polygonX(pp.size());
                std::vector<int> polygonY(pp.size());
                for (auto x = polygonX.begin(), y = polygonY.begin(); const auto& p : pp)
                {
                    *x = p.x;
                    *y = p.y;
                    std::advance(x, 1);
                    std::advance(y, 1);
                }
 
                exec->AddPolygonToBlurMask(impl.get(),
                                           polygonX.data(),
                                           polygonY.data(),
                                           pp.size(),
                                           static_cast<unsigned int>(maskType),
                                           ThrowOnError{});
            }
 
            void ApplyBlur(ImageBlurType blurType) final
            {
 
                exec->ApplyBlur(impl.get(), static_cast<unsigned int>(blurType), ThrowOnError{});
            }
 
            [[nodiscard]] void* GetMaskedImage() const
            {
 
                auto* newImage = exec->MaskingFinished(impl.get(), ThrowOnError{});
 
                return newImage;
            }
 
            ImplMasker(void* imageImpl, std::shared_ptr<ImageExecutor> e)
              : impl(imageImpl, e->DestroyMask())
              , exec(std::move(e))
            {
            }
 
            ImplMasker() = delete;
            ImplMasker(const ImplMasker&) = delete;
            ImplMasker(ImplMasker&&) = delete;
            ImplMasker& operator=(const ImplMasker&) = delete;
            ImplMasker& operator=(ImplMasker&&) = delete;
            virtual ~ImplMasker() = default;
 
        private:
            std::unique_ptr<void, void (*)(void*)> impl;
            std::shared_ptr<ImageExecutor> exec;
        };
    };
} // namespace inno