CriticalPoint.h

Go to the documentation of this file.

 
#pragma once
 
#include "enrollment/Image/ImageAttribute.h"
#include "enrollment/Image/ImageShape.h"
#include "enrollment/Serialization/Writer.h"
#include <cmath>
 
namespace inno
{
     */
    class CriticalPoint : public Serializable
    {
    public:
        /// @image latex cores_deltas.png "Critical points types" width = 5cm
        enum class Type : uint8_t
        {
            CORE = 1,
            DELTA = 2
        };
        Point center;
        Type type;
        Angle angle;

         */
        void WriteTo(Writer& writer) const final
        {
            writer.Write("c", center);
            writer.Write("t", static_cast<uint8_t>(type));
            writer.Write("a", angle);
        }

         */
        CriticalPoint(Point pointArg, Type typeArg, Angle angleArg)
          : center(std::move(pointArg))
          , type(typeArg)
          , angle(angleArg)
        {
        }
        bool operator==(const CriticalPoint& m) const
        {
            auto isAngleEqual = std::abs(angle - m.angle) < std::numeric_limits<Angle>::epsilon();
            return center == m.center && type == m.type && isAngleEqual;
        }
        bool operator!=(const CriticalPoint& m) const
        {
            return !(*this == m);
        }
 
        CriticalPoint()
          : type(Type::CORE)
          , angle(0)
        {
        }
 
        virtual ~CriticalPoint() = default;
 
        CriticalPoint(const CriticalPoint& m) = default;
        CriticalPoint(CriticalPoint&& m) = delete;
        CriticalPoint& operator=(const CriticalPoint& m) = default;
        CriticalPoint& operator=(CriticalPoint&& m) = delete;
    };

     */
    class CriticalPointShape : public ImageShape
    {
    public:
         */
        void DrawIn(ImageShapeDrawer& drawer) const final
        {
            if (m->type == CriticalPoint::Type::DELTA)
            {
                auto rect = Rectangle{ { m->center.x - static_cast<int>(r), m->center.y - static_cast<int>(r) },
                                       { m->center.x + static_cast<int>(r), m->center.y - static_cast<int>(r) },
                                       { m->center.x + static_cast<int>(r), m->center.y + static_cast<int>(r) },
                                       { m->center.x - static_cast<int>(r), m->center.y + static_cast<int>(r) } };
                auto rectShape = RectangleShape(rect, a);
                rectShape.DrawIn(drawer);
            }
            else
            {
                drawer.DrawCircle(Circle{ { m->center.x, m->center.y }, r }, a);
            }
            auto angleLine = Line{ { m->center.x, m->center.y }, m->angle, al };
            drawer.DrawLine(angleLine, a);
        }

         */
        CriticalPointShape(std::shared_ptr<CriticalPoint> point,
                           Radius radius,
                           ImageShapeAttributes attr,
                           unsigned int angleLength)
          : m(std::move(point))
          , r(radius)
          , a(std::move(attr))
          , al(angleLength)
        {
        }

         */
        CriticalPointShape(std::shared_ptr<CriticalPoint> point, ImageShapeAttributes attr)
          : m(std::move(point))
          , r(DefaultRadius)
          , a(std::move(attr))
          , al(DefaultAngleLength)
        {
        }
 
        CriticalPointShape() = delete;
        virtual ~CriticalPointShape() = default;
        CriticalPointShape(const CriticalPointShape&) = delete;
        CriticalPointShape(CriticalPointShape&&) = delete;
        CriticalPointShape& operator=(const CriticalPointShape&) = delete;
        CriticalPointShape& operator=(CriticalPointShape&&) = delete;
 
    private:
        std::shared_ptr<CriticalPoint> m;
        static constexpr Radius DefaultRadius = 5;
        Radius r;
        ImageShapeAttributes a;
        static constexpr unsigned int DefaultAngleLength = 10;
        unsigned int al;
    };

     */
    class CriticalPointsShape : public ImageShape
    {
    public:
         */
        void DrawIn(ImageShapeDrawer& drawer) const final
        {
            for (const auto& mi : m)
            {
                auto ms = CriticalPointShape(mi, r, a, al);
                ms.DrawIn(drawer);
            }
        }

         */
        CriticalPointsShape(const std::vector<std::shared_ptr<CriticalPoint>>& point,
                            Radius radius,
                            ImageShapeAttributes attr,
                            unsigned int angleLength)
          : m(point)
          , r(radius)
          , a(std::move(attr))
          , al(angleLength)
        {
        }

         */
        CriticalPointsShape(const std::vector<std::shared_ptr<CriticalPoint>>& point, ImageShapeAttributes attr)
          : m(point)
          , r(DefaultRadius)
          , a(std::move(attr))
          , al(DefaultAngleLength)
        {
        }
        CriticalPointsShape() = delete;
        virtual ~CriticalPointsShape() = default;
        CriticalPointsShape(const CriticalPointsShape&) = delete;
        CriticalPointsShape(CriticalPointsShape&&) = delete;
        CriticalPointsShape& operator=(const CriticalPointsShape&) = delete;
        CriticalPointsShape& operator=(CriticalPointsShape&&) = delete;
 
    private:
        std::vector<std::shared_ptr<CriticalPoint>> m;
        static constexpr Radius DefaultRadius = 5;
        Radius r;
        ImageShapeAttributes a;
        static constexpr unsigned int DefaultAngleLength = 10;
        unsigned int al;
    };
} // namespace inno