ImageMask.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Image/ImageAttribute.h"
#include "enrollment/Serialization/Writer.h"
 
#include <memory>
 
namespace inno
{
     */
    enum class ImageMaskType : uint8_t
    {
        OUTSIDE = 0,
        INSIDE = 1,
    };

     */
    enum class ImageBlurType : uint8_t
    {
        NO_BORDER_BLURRING = 0,

        ISO_19794_BORDER_BLURRING = 1,
    };

     */
    class ImageMaskConfiguration
    {
    public:
         */
        ImageMaskConfiguration()
          : m(ImageMaskType::OUTSIDE)
          , c(Colors::White)
        {
        }

         */
        ImageMaskConfiguration(ImageMaskType maskType, RGBA maskColor)
          : m(maskType)
          , c(std::move(maskColor))
        {
        }

         */
        [[nodiscard]] ImageMaskType GetMaskType() const
        {
            return m;
        }

         */
        [[nodiscard]] RGBA GetMaskColor() const
        {
            return c;
        }
 
        virtual ~ImageMaskConfiguration() = default;
        ImageMaskConfiguration(const ImageMaskConfiguration&) = default;
        ImageMaskConfiguration(ImageMaskConfiguration&&) = default;
        ImageMaskConfiguration& operator=(const ImageMaskConfiguration&) = default;
        ImageMaskConfiguration& operator=(ImageMaskConfiguration&&) = default;
 
    private:
        ImageMaskType m;
        RGBA c;
    };

     */
    class ImageMasker
    {
    public:
        virtual void MaskCircle(const Circle& mask, const class ImageMaskConfiguration& conf) = 0;

        virtual void MaskPolygon(const Polygon& mask, const ImageMaskConfiguration& conf) = 0;

        virtual void BlurCircle(const Circle& circle, ImageMaskType maskType, ImageBlurType blurType) = 0;

        virtual void BlurPolygon(const Polygon& polygon, ImageMaskType maskType, ImageBlurType blurType) = 0;

        virtual void AddToBlur(const Circle& circle, ImageMaskType maskType) = 0;

        virtual void AddToBlur(const Polygon& polygon, ImageMaskType maskType) = 0;

        virtual void ApplyBlur(ImageBlurType blurType) = 0;
        ImageMasker() = default;
        virtual ~ImageMasker() = default;
        ImageMasker(const ImageMasker&) = default;
        ImageMasker(ImageMasker&&) = default;
        ImageMasker& operator=(const ImageMasker&) = default;
        ImageMasker& operator=(ImageMasker&&) = default;
    };

     */
    class ImageMask
    {
    public:
        virtual void MaskWith(ImageMasker& masker) const = 0;
 
        ImageMask() = default;
        virtual ~ImageMask() = default;
        ImageMask(const ImageMask&) = default;
        ImageMask(ImageMask&&) = default;
        ImageMask& operator=(const ImageMask&) = delete;
        ImageMask& operator=(ImageMask&&) = delete;
    };

     */
    class CircleImageMask : public ImageMask
    {
    public:
         */
        CircleImageMask(Circle circle, ImageMaskConfiguration config)
          : cfg(std::move(config))
          , c(std::move(circle))
        {
        }

         */
        CircleImageMask(Circle circle, ImageMaskConfiguration config, ImageBlurType blur)
          : cfg(std::move(config))
          , c(std::move(circle))
          , b(blur)
        {
        }

         */
        void MaskWith(ImageMasker& masker) const override
        {
            masker.MaskCircle(c, cfg);
            if (b != ImageBlurType::NO_BORDER_BLURRING)
            {
                masker.BlurCircle(c, cfg.GetMaskType(), b);
            }
        }
 
        CircleImageMask() = default;
        ~CircleImageMask() override = default;
        CircleImageMask(const CircleImageMask&) = default;
        CircleImageMask(CircleImageMask&&) = default;
        CircleImageMask& operator=(const CircleImageMask&) = delete;
        CircleImageMask& operator=(CircleImageMask&&) = delete;
 
    private:
        ImageMaskConfiguration cfg;
        Circle c;
        ImageBlurType b = ImageBlurType::NO_BORDER_BLURRING;
    };

     */
    class PolygonImageMask : public ImageMask
    {
    public:
         */
        PolygonImageMask(Polygon polygon, ImageMaskConfiguration config)
          : cfg(std::move(config))
          , p(std::move(polygon))
        {
        }
         */
        PolygonImageMask(Polygon polygon, ImageMaskConfiguration config, ImageBlurType blur)
          : cfg(std::move(config))
          , p(std::move(polygon))
          , b(blur)
        {
        }

         */
        void MaskWith(ImageMasker& masker) const override
        {
            masker.MaskPolygon(p, cfg);
            if (b != ImageBlurType::NO_BORDER_BLURRING)
            {
                masker.BlurPolygon(p, cfg.GetMaskType(), b);
            }
        }
 
        PolygonImageMask() = default;
        ~PolygonImageMask() override = default;
        PolygonImageMask(const PolygonImageMask&) = default;
        PolygonImageMask(PolygonImageMask&&) = default;
        PolygonImageMask& operator=(const PolygonImageMask&) = delete;
        PolygonImageMask& operator=(PolygonImageMask&&) = delete;
 
    private:
        ImageMaskConfiguration cfg;
        Polygon p;
        ImageBlurType b = ImageBlurType::NO_BORDER_BLURRING;
    };
 
} // namespace inno