ImageShape.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Image/ImageAttribute.h"
#include <vector>
 
namespace inno
{

     */
    class ImageShapeAttributes : public Serializable
    {
    private:
        static constexpr unsigned char DefaultThickness = 2;
 
    public:
        RGBA rgba;
        unsigned char thickness = DefaultThickness;
 
        ImageShapeAttributes(RGBA color, unsigned char lw) noexcept
          : rgba(std::move(color))
          , thickness(lw)
        {
        }
 
        explicit ImageShapeAttributes(RGBA color) noexcept
          : rgba(std::move(color))
        {
        }
 
        explicit ImageShapeAttributes(RGB color) noexcept
          : rgba(std::move(color))
        {
        }
 
        void WriteTo(Writer& writer) const final
        {
            writer.Write("c", rgba);
            writer.Write("t", thickness);
        }
 
        ImageShapeAttributes() = default;
        virtual ~ImageShapeAttributes() = default;
        ImageShapeAttributes(const ImageShapeAttributes&) = default;
        ImageShapeAttributes(ImageShapeAttributes&&) = default;
        ImageShapeAttributes& operator=(const ImageShapeAttributes&) = default;
        ImageShapeAttributes& operator=(ImageShapeAttributes&&) = default;
 
        bool operator==(const ImageShapeAttributes& c) const
        {
            return rgba == c.rgba && thickness == c.thickness;
        }
 
        bool operator!=(const ImageShapeAttributes& c) const
        {
            return !(*this == c);
        }
    };
 
#if defined SWIGPYTHON || defined SWIGRUBY
    // The Shapes 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 ImageShapeAttributes ShapesInnoBlue = ImageShapeAttributes(Colors::InnoBlue);
    static const ImageShapeAttributes ShapesWhite = ImageShapeAttributes(Colors::White);
    static const ImageShapeAttributes ShapesLightGray = ImageShapeAttributes(Colors::LightGray);
#endif

     */
    class Shapes final
    {
    public:
        // NOLINTNEXTLINE(fuchsia-statically-constructed-objects)
        inline static const ImageShapeAttributes InnoBlue = ImageShapeAttributes(Colors::InnoBlue);
        // NOLINTNEXTLINE(fuchsia-statically-constructed-objects)
        inline static const ImageShapeAttributes White = ImageShapeAttributes(Colors::White);
        // NOLINTNEXTLINE(fuchsia-statically-constructed-objects)
        inline static const ImageShapeAttributes LightGray = ImageShapeAttributes(Colors::LightGray);
 
        Shapes(const Shapes&) = delete;
        Shapes(Shapes&&) = delete;
        Shapes& operator=(const Shapes&) = delete;
        Shapes& operator=(Shapes&&) = delete;
        Shapes() = delete;
        ~Shapes() = delete;
    };

     */
    class ImageShapeDrawer
    {
    public:
        virtual void DrawLine(const Line& line, const ImageShapeAttributes& attr) = 0;
        virtual void DrawCircle(const Circle& circle, const ImageShapeAttributes& attr) = 0;
        virtual void DrawRectangle(const Rectangle& rectangle, const ImageShapeAttributes& attr) = 0;
 
        ImageShapeDrawer() = default;
        ImageShapeDrawer(const ImageShapeDrawer&) = delete;
        ImageShapeDrawer(ImageShapeDrawer&&) = delete;
        ImageShapeDrawer& operator=(const ImageShapeDrawer&) = delete;
        ImageShapeDrawer& operator=(ImageShapeDrawer&&) = delete;
        virtual ~ImageShapeDrawer() = default;
    };

     */
    class ImageShape
    {
    public:
        virtual void DrawIn(ImageShapeDrawer& drawer) const = 0;
 
        ImageShape() = default;
        ImageShape(const ImageShape&) = delete;
        ImageShape(ImageShape&&) = delete;
        ImageShape& operator=(const ImageShape&) = delete;
        ImageShape& operator=(ImageShape&&) = delete;
        virtual ~ImageShape() = default;
    };

     */
    class RectangleShape final : public ImageShape
    {
    public:
         */
        void DrawIn(ImageShapeDrawer& drawer) const final
        {
            drawer.DrawRectangle(rect, a);
        }

         */
        RectangleShape(Rectangle rectangle, ImageShapeAttributes attr)
          : rect(std::move(rectangle))
          , a(std::move(attr))
        {
        }
 
    private:
        Rectangle rect;
        ImageShapeAttributes a;
    };

     */
    class RectanglesShape final : public ImageShape
    {
    public:
         */
        void DrawIn(ImageShapeDrawer& drawer) const final
        {
            for (const auto& r : rectangles)
            {
                auto rectangleShape = RectangleShape(r, a);
                rectangleShape.DrawIn(drawer);
            }
        }

         */
        RectanglesShape(std::vector<Rectangle> r, ImageShapeAttributes attr)
          : rectangles(std::move(r))
          , a(std::move(attr))
        {
        }
 
    private:
        std::vector<Rectangle> rectangles;
        ImageShapeAttributes a;
    };

     */
    class CircleShape final : public ImageShape
    {
    public:
         */
        void DrawIn(ImageShapeDrawer& drawer) const final
        {
            drawer.DrawCircle(circ, a);
        }

         */
        CircleShape(Circle circle, ImageShapeAttributes attr)
          : circ(std::move(circle))
          , a(std::move(attr))
        {
        }
 
    private:
        Circle circ;
        ImageShapeAttributes a;
    };

     */
    class LineShape final : public ImageShape
    {
    public:
         */
        void DrawIn(ImageShapeDrawer& drawer) const final
        {
            drawer.DrawLine(ln, a);
        }

         */
        LineShape(Line line, ImageShapeAttributes attr)
          : ln(std::move(line))
          , a(std::move(attr))
        {
        }
 
    private:
        Line ln;
        ImageShapeAttributes a;
    };
} // namespace inno