ImageAttribute.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Image/ImageExecutor.h"
#include "enrollment/Serialization/Writer.h"
#include <array>
#include <cmath>
#include <cstdint>
#include <memory>
#include <vector>
 
// cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes: This is not a
// problem because we are using them only as read only.
// cppcoreguidelines-avoid-const-or-ref-data-members: We design te API with const member variables instead of
// implementing getter methods. This is nicely transformed in C# to properties. Usually our objects are immutable by
// intention to have no problem in multithreaded applications.
// NOLINTBEGIN(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes,cppcoreguidelines-avoid-const-or-ref-data-members)
namespace inno
{
    using ImageDimension = unsigned int;
    using ImageHeight = ImageDimension;
    using ImageWidth = ImageDimension;
     */
    class ImageDpi
    {
    public:
         */
        explicit constexpr ImageDpi(unsigned int i)
          : dpi(i)
        {
        }
         */
        explicit operator unsigned int() const
        {
            return dpi;
        }
         */
        [[nodiscard]] unsigned int ToDPCM() const
        {
            static constexpr float CmInInch = 2.54F;
            return static_cast<unsigned int>(std::round(static_cast<float>(dpi) / CmInInch));
        }

         */
        [[nodiscard]] static ImageDpi FromDPCM(unsigned int dpcm)
        {
            static constexpr float CmInInch = 2.54F;
            return ImageDpi{ static_cast<unsigned int>(static_cast<float>(dpcm) * CmInInch) };
        }
 
        bool operator==(const ImageDpi& r) const
        {
            return dpi == r.dpi;
        }
 
        ImageDpi() = default;
        ~ImageDpi() = default;
        ImageDpi(const ImageDpi&) = default;
        ImageDpi(ImageDpi&&) = default;
        ImageDpi& operator=(const ImageDpi&) = default;
        ImageDpi& operator=(ImageDpi&&) = default;
 
    private:
        static constexpr unsigned int DefaultDpi = 500;
        unsigned int dpi = DefaultDpi;
    };
    constexpr ImageDpi DefaultDpi;
    using X = int;
    using Y = int;
    using Angle = float;
    using Radius = unsigned int;

     */
    class RawImage : public Serializable
    {
    public:
        /// RawImage encoding type.
        enum Type : uint8_t
        {
            GRAYSCALE,
            BGR,
            BGRA
        };

        const ImageDpi dpi;
        const ImageWidth width;
        const ImageHeight height;
        const Type type;
        const unsigned char channels;

         */
        [[nodiscard]] const std::vector<uint8_t>& Data() const
        {
            return data;
        }

         */
        void WriteTo(Writer& writer) const final
        {
            writer.Write("t", type);
            writer.Write("h", height);
            writer.Write("w", width);
            writer.Write("p", static_cast<unsigned int>(dpi));
            writer.WriteArray("d", data);
        }

         */
        RawImage(ImageWidth w, ImageHeight h, ImageDpi d, Type t, std::vector<uint8_t>&& r)
          : dpi(d)
          , width(w)
          , height(h)
          , type(t)
          , channels(Channels(t))
          , data(std::move(r))
        {
        }
         */
        RawImage(ImageWidth w, ImageHeight h, ImageDpi d, Type t, const std::vector<uint8_t>& r)
          : dpi(d)
          , width(w)
          , height(h)
          , type(t)
          , channels(Channels(t))
          , data(r)
        {
        }
        RawImage() = delete;
        RawImage(const RawImage& r) = default;
        RawImage(RawImage&&) = default;
        RawImage& operator=(const RawImage&) = delete;
        RawImage& operator=(RawImage&&) = delete;
        virtual ~RawImage() = default;
 
        bool operator==(const RawImage& r) const
        {
            return dpi == r.dpi && width == r.width && height == r.height && type == r.type && channels == r.channels &&
                   data == r.data;
        }
        bool operator!=(const RawImage& r) const
        {
            return !(*this == r);
        }
 
    private:
        std::vector<uint8_t> data;
 
        static unsigned char Channels(Type t)
        {
            switch (t)
            {
            case BGR:
                return 3;
            case BGRA:
                return 4;
            case GRAYSCALE:
                return 1;
            }
            return 0;
        }
    };

     */
    class ImageDimensions final
    {
    public:
         */
        ImageDimensions(ImageWidth w, ImageHeight h)
          : width(w)
          , height(h)
        {
        }

        ImageWidth width = 0;
        ImageHeight height = 0;
 
        ImageDimensions() = default;
        ImageDimensions(const ImageDimensions& d) = default;
        ImageDimensions(ImageDimensions&&) = default;
        ImageDimensions& operator=(const ImageDimensions&) = default;
        ImageDimensions& operator=(ImageDimensions&&) = default;
        ~ImageDimensions() = default;
    };

     */
    class Point final : public Serializable
    {
    public:
         */
        Point(X xCoordinate, Y yCoordinate)
          : x(xCoordinate)
          , y(yCoordinate)
        {
        }

        X x = 0;
        Y y = 0;
 
        void WriteTo(Writer& writer) const final
        {
            writer.Write("x", x);
            writer.Write("y", y);
        }
 
        Point(const Point& p) = default;
        Point(Point&& p) = default;
        Point() = default;
        Point& operator=(const Point& r) = default;
        Point& operator=(Point&& r) = default;
 
        bool operator==(const Point& r) const
        {
            return r.x == x && r.y == y;
        }
 
        virtual ~Point() = default;
    };

     */
    class Rectangle final : public Serializable
    {
    public:
        using Dimension = float;
        using Height = Dimension;
        using Width = Dimension;

         */
        [[nodiscard]] const Point& GetTopLeft() const
        {
            return topLeft;
        }
         */
        [[nodiscard]] const Point& GetTopRight() const
        {
            return topRight;
        }
         */
        [[nodiscard]] const Point& GetBottomRight() const
        {
            return bottomRight;
        }
         */
        [[nodiscard]] const Point& GetBottomLeft() const
        {
            return bottomLeft;
        }
         */
        [[nodiscard]] Width GetWidth() const
        {
            return width;
        }
         */
        [[nodiscard]] Height GetHeight() const
        {
            return height;
        }
         */
        [[nodiscard]] Rectangle Resize(Width w, Height h) const
        {
            if (w < 1)
            {
                throw EnrollmentInvalidArgumentException("Width must be >= 1 to resize rectangle");
            }
            if (h < 1)
            {
                throw EnrollmentInvalidArgumentException("Height must be >= 1 to resize rectangle");
            }
 
            int newTopLeftX = 0;
            int newTopLeftY = 0;
            int newTopRightX = 0;
            int newTopRightY = 0;
            int newBottomRightX = 0;
            int newBottomRightY = 0;
            int newBottomLeftX = 0;
            int newBottomLeftY = 0;
            exec->ResizeRectangle(w,
                                  h,
                                  topLeft.x,
                                  topLeft.y,
                                  topRight.x,
                                  topRight.y,
                                  bottomRight.x,
                                  bottomRight.y,
                                  bottomLeft.x,
                                  bottomLeft.y,
                                  &newTopLeftX,
                                  &newTopLeftY,
                                  &newTopRightX,
                                  &newTopRightY,
                                  &newBottomRightX,
                                  &newBottomRightY,
                                  &newBottomLeftX,
                                  &newBottomLeftY,
                                  ThrowOnError{});
 
            return { { newTopLeftX, newTopLeftY },
                     { newTopRightX, newTopRightY },
                     { newBottomRightX, newBottomRightY },
                     { newBottomLeftX, newBottomLeftY },
                     w,
                     h,
                     exec };
        }

         */
        [[nodiscard]] Point CalculateCenter() const
        {
            const auto centerX =
              static_cast<int>(static_cast<float>(topLeft.x + bottomRight.x + topRight.x + bottomLeft.x) / 4.0F);
            const auto centerY =
              static_cast<int>(static_cast<float>(topLeft.y + bottomRight.y + topRight.y + bottomLeft.y) / 4.0F);
            return { centerX, centerY };
        }
 
        void WriteTo(Writer& writer) const final
        {
            writer.Write("tl", topLeft);
            writer.Write("tr", topRight);
            writer.Write("br", bottomRight);
            writer.Write("bl", bottomLeft);
            writer.Write("h", height);
            writer.Write("w", width);
        }

         */
        Rectangle(Point topLeftPoint, Point topRightPoint, Point bottomRightPoint, Point bottomLeftPoint)
          : Rectangle(std::move(topLeftPoint),
                      std::move(topRightPoint),
                      std::move(bottomRightPoint),
                      std::move(bottomLeftPoint),
                      GlobalImageExecutor::Get())
        {
        }

         */
        Rectangle(Point topLeftPoint,
                  Point topRightPoint,
                  Point bottomRightPoint,
                  Point bottomLeftPoint,
                  std::shared_ptr<ImageExecutor> executor)
          : topLeft(std::move(topLeftPoint))
          , topRight(std::move(topRightPoint))
          , bottomLeft(std::move(bottomLeftPoint))
          , bottomRight(std::move(bottomRightPoint))
          , exec(std::move(executor))
        {
            if (exec == nullptr)
            {
                throw NullArgumentException("executor can not be null");
            }
 
            exec->GetRectangleDimensions(&width,
                                         &height,
                                         topLeft.x,
                                         topLeft.y,
                                         topRight.x,
                                         topRight.y,
                                         bottomRight.x,
                                         bottomRight.y,
                                         bottomLeft.x,
                                         bottomLeft.y,
                                         ThrowOnError{});
        }
 
        Rectangle(const Rectangle&) = default;
        Rectangle(Rectangle&& r) = default;
        Rectangle& operator=(const Rectangle&) = default;
        Rectangle& operator=(Rectangle&&) = default;
 
        bool operator==(const Rectangle& r) const
        {
            return r.bottomLeft == bottomLeft && r.bottomRight == bottomRight && r.topLeft == topLeft &&
                   r.topRight == topRight;
        }
 
        bool operator!=(const Rectangle& r) const
        {
            return !(*this == r);
        }
 
        virtual ~Rectangle() = default;
        Rectangle() = default;
 
    private:
        Rectangle(Point topLeftPoint,
                  Point topRightPoint,
                  Point bottomRightPoint,
                  Point bottomLeftPoint,
                  Width w,
                  Height h,
                  std::shared_ptr<ImageExecutor> executor)
          : topLeft(std::move(topLeftPoint))
          , topRight(std::move(topRightPoint))
          , bottomLeft(std::move(bottomLeftPoint))
          , bottomRight(std::move(bottomRightPoint))
          , width(w)
          , height(h)
          , exec(std::move(executor))
        {
        }
 
        Point topLeft;
        Point topRight;
        Point bottomLeft;
        Point bottomRight;
        Width width = 0.0F;
        Height height = 0.0F;
        std::shared_ptr<ImageExecutor> exec;
    };

     */
    class Line final : public Serializable
    {
    public:
        Point begin;
        Point end;
 
        void WriteTo(Writer& writer) const final
        {
            writer.Write("b", begin);
            writer.Write("e", end);
        }

         */
        Line(Point beginPoint, Point endPoint)
          : begin(std::move(beginPoint))
          , end(std::move(endPoint))
        {
        }
         */
        Line(Point b, float angle, unsigned int length)
          : begin(std::move(b))
          , end(CalculateEndPoint(begin, angle, length))
        {
        }
        Line(const Line&) = default;
        Line(Line&& r) = default;
        Line& operator=(const Line&) = default;
        Line& operator=(Line&&) = default;
 
        bool operator==(const Line& r) const
        {
            return r.begin == begin && r.end == end;
        }
 
        bool operator!=(const Line& r) const
        {
            return !(*this == r);
        }
 
        virtual ~Line() = default;
        Line() = default;
 
    private:
        static Point CalculateEndPoint(const Point& begin, float angle, unsigned int length)
        {
            // The clang-tidy suggest to use 'std::numbers::pi'. Due to compilation issues with our dependency
            // Boost 1.73 in Android NDK r26d (first version that contains 'number' header), we're unable to utilize the
            // suggested change. NOLINTNEXTLINE(modernize-use-std-numbers)
            static constexpr float PiNum = 3.14159265358979323846F;
            static constexpr float Degrees = 180.0F;
            // Convert degrees to radians for std::cos and std::sin
            auto angleRadians = angle * PiNum / Degrees;
            auto ex = static_cast<X>(
              std::round(static_cast<float>(begin.x) + static_cast<float>(length) * std::cos(angleRadians)));
            auto ey = static_cast<Y>(
              std::round(static_cast<float>(begin.y) - static_cast<float>(length) * std::sin(angleRadians)));
            return Point{ ex, ey };
        }
    };

     */
    class Circle final : public Serializable
    {
    public:
        Point center;
        Radius radius = 0;

         */
        [[nodiscard]] static Circle CreateInscribedCircle(const Rectangle& rect)
        {
            const auto width = rect.GetWidth();
            const auto height = rect.GetHeight();
            const float diameter = std::min(width, height);
            constexpr auto RadiusDiameterQuotient = 2.0F;
            const auto radius = static_cast<unsigned int>(diameter / RadiusDiameterQuotient);
            const auto center = rect.CalculateCenter();
            return { center, radius };
        }
 
        void WriteTo(Writer& writer) const final
        {
            writer.Write("c", center);
            writer.Write("r", radius);
        }

         */
        [[nodiscard]] Rectangle BoundingRectangle() const
        {
            return Rectangle{ { center.x - static_cast<int>(radius), center.y - static_cast<int>(radius) },
                              { center.x + static_cast<int>(radius), center.y - static_cast<int>(radius) },
                              { center.x + static_cast<int>(radius), center.y + static_cast<int>(radius) },
                              { center.x - static_cast<int>(radius), center.y + static_cast<int>(radius) } };
        }
         */
        Circle(Point centerPoint, Radius circleRadius)
          : center(std::move(centerPoint))
          , radius(circleRadius)
        {
        }
        Circle(const Circle& c) = default;
        Circle(Circle&& c) = default;
        Circle& operator=(const Circle& r) = default;
        Circle& operator=(Circle&& c) = default;
        virtual ~Circle() = default;
        Circle() = default;
 
        bool operator==(const Circle& c) const
        {
            return c.center == center && c.radius == radius;
        }
 
        bool operator!=(const Circle& c) const
        {
            return !(*this == c);
        }
    };

     */
    class Polygon final : public Serializable
    {
    public:
        void WriteTo(Writer& writer) const final
        {
            writer.WriteArray("p", p);
        }

         */
        void AddPoint(const Point& point)
        {
            p.push_back(point);
        }

         */
        void AddPoint(Point&& point)
        {
            p.push_back(std::move(point));
        }

         */
        [[nodiscard]] const std::vector<Point>& GetPoints() const
        {
            return p;
        }

         */
        explicit Polygon(std::vector<Point>&& points)
          : p(std::move(points)) {};

         */
        explicit Polygon(const std::vector<Point>& points)
          : p(points) {};
 
        Polygon(const Polygon&) = default;
        Polygon(Polygon&& other) = default;
        Polygon& operator=(Polygon&& other) = default;
        Polygon& operator=(const Polygon&) = default;
        virtual ~Polygon() = default;
        Polygon() = default;
 
        bool operator==(const Polygon& other) const
        {
            auto otherIt = other.GetPoints().cbegin();
            for (const auto& thisPoint : p)
            {
                if (thisPoint != *otherIt)
                {
                    return false;
                }
                otherIt++;
            }
            return true;
        }
 
        bool operator!=(const Polygon& other) const
        {
            return !(*this == other);
        }
 
    private:
        std::vector<Point> p;
    };
 
#ifdef _WIN32
#undef RGB
#endif

     */
    class RGB final : public Serializable
    {
    public:
        unsigned char red = 0;
        unsigned char green = 0;
        unsigned char blue = 0;
 
        void WriteTo(Writer& writer) const final
        {
            writer.Write("r", red);
            writer.Write("g", green);
            writer.Write("b", blue);
        }
 
        RGB(unsigned char r, unsigned char g, unsigned char b)
          : red(r)
          , green(g)
          , blue(b)
        {
        }
        RGB(const RGB&) = default;
        RGB(RGB&&) = default;
        RGB& operator=(const RGB&) = default;
        RGB& operator=(RGB&& c) = default;
        RGB() = default;
 
        bool operator==(const RGB& c) const
        {
            return c.red == red && c.green == green && c.blue == blue;
        }
 
        bool operator!=(const RGB& c) const
        {
            return !(*this == c);
        }
 
        virtual ~RGB() = default;
    };

     */
    class RGBA final : public Serializable
    {
    public:
        RGB color;
        unsigned char transparency = FULLY_OPAQUE;
 
        enum : uint8_t
        {
            FULLY_TRANSPARENT = 0,
            FULLY_OPAQUE = 255
        };
 
        void WriteTo(Writer& writer) const final
        {
            writer.Write("c", color);
            writer.Write("t", transparency);
        }
 
        RGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char t) noexcept
          : color(r, g, b)
          , transparency(t)
        {
        }
        RGBA(RGB rgb, unsigned char t) noexcept
          : color(std::move(rgb))
          , transparency(t)
        {
        }
 
        explicit RGBA(RGB rgb) noexcept
          : color(std::move(rgb))
        {
        }
        RGBA(const RGBA& c) = default;
        RGBA(RGBA&& c) = default;
        RGBA& operator=(const RGBA& c) = default;
        RGBA& operator=(RGBA&& c) = default;
        RGBA() = default;
 
        bool operator==(const RGBA& c) const
        {
            return c.color == color && c.transparency == transparency;
        }
 
        bool operator!=(const RGBA& c) const
        {
            return !(*this == c);
        }
 
        virtual ~RGBA() = default;
    };
 
#if defined SWIGPYTHON || defined SWIGRUBY
    // The Colors class will be ignored for python and ruby binding.
    // Swig is not able to generate binding correctly for inline static const members
    // for python and ruby.
    static const RGBA ColorsInnoBlue = RGBA(133, 183, 226, RGBA::FULLY_OPAQUE);
    static const RGBA ColorsWhite = RGBA(255, 255, 255, RGBA::FULLY_OPAQUE);
    static const RGBA ColorsLightGray = RGBA(211, 211, 211, RGBA::FULLY_OPAQUE);
 
#endif

     */
    class Colors final
    {
    public:
        // NOLINTNEXTLINE(fuchsia-statically-constructed-objects)
        inline static const RGBA InnoBlue = RGBA(133, 183, 226, RGBA::FULLY_OPAQUE);
        // NOLINTNEXTLINE(fuchsia-statically-constructed-objects)
        inline static const RGBA White = RGBA(255, 255, 255, RGBA::FULLY_OPAQUE);
        // NOLINTNEXTLINE(fuchsia-statically-constructed-objects)
        inline static const RGBA LightGray = RGBA(211, 211, 211, RGBA::FULLY_OPAQUE);
 
        Colors(const Colors&) = delete;
        Colors(Colors&&) = delete;
        Colors& operator=(const Colors&) = delete;
        Colors& operator=(Colors&&) = delete;
        Colors() = delete;
        ~Colors() = delete;
    };
} // namespace inno
// NOLINTEND(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes,cppcoreguidelines-avoid-const-or-ref-data-members)