Minutia.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"
 
namespace inno
{
     */
    class Minutia : public Serializable
    {
    public:
        /// @image latex bifurcation_ending.png "Minutia types" width = 5cm
        enum class Type : uint8_t
        {
            BIFURCATION = 0,
            RIDGE_ENDING = 1
        };
        Point center;
        Type type;
        Angle angle;
        uint8_t quality;

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

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

     */
    class MinutiaShape : public ImageShape
    {
    public:
         */
        void DrawIn(ImageShapeDrawer& drawer) const final
        {
            // Draw minutia shape according https://www.nist.gov/system/files/documents/srd/nistsd27.pdf
            if (m->type == Minutia::Type::BIFURCATION)
            {
                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 rs = RectangleShape(rect, a);
                rs.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);
        }

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

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

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

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

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